clang 10.0.0git

RewriteObjC.cpp
Go to the documentation of this file.
1 //===--- RewriteObjC.cpp - Playground for the code rewriter ---------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Hacks and fun related to the code rewriter.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/Rewrite/Frontend/ASTConsumers.h"
14 #include "clang/AST/AST.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/Attr.h"
17 #include "clang/AST/ParentMap.h"
18 #include "clang/Basic/CharInfo.h"
19 #include "clang/Basic/Diagnostic.h"
20 #include "clang/Basic/IdentifierTable.h"
21 #include "clang/Basic/SourceManager.h"
22 #include "clang/Config/config.h"
23 #include "clang/Lex/Lexer.h"
24 #include "clang/Rewrite/Core/Rewriter.h"
25 #include "llvm/ADT/DenseSet.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/Support/MemoryBuffer.h"
29 #include "llvm/Support/raw_ostream.h"
30 #include <memory>
31
32 #if CLANG_ENABLE_OBJC_REWRITER
33
34 using namespace clang;
35 using llvm::utostr;
36
37 namespace {
38 class RewriteObjC : public ASTConsumer {
39 protected:
40 enum {
41 BLOCK_FIELD_IS_OBJECT = 3, /* id, NSObject, __attribute__((NSObject)),
42 block, ... */
43 BLOCK_FIELD_IS_BLOCK = 7, /* a block variable */
44 BLOCK_FIELD_IS_BYREF = 8, /* the on stack structure holding the
45 __block variable */
46 BLOCK_FIELD_IS_WEAK = 16, /* declared __weak, only used in byref copy
47 helpers */
48 BLOCK_BYREF_CALLER = 128, /* called from __block (byref) copy/dispose
49 support routines */
50 BLOCK_BYREF_CURRENT_MAX = 256
51 };
52
53 enum {
54 BLOCK_NEEDS_FREE = (1 << 24),
55 BLOCK_HAS_COPY_DISPOSE = (1 << 25),
56 BLOCK_HAS_CXX_OBJ = (1 << 26),
57 BLOCK_IS_GC = (1 << 27),
58 BLOCK_IS_GLOBAL = (1 << 28),
59 BLOCK_HAS_DESCRIPTOR = (1 << 29)
60 };
61 static const int OBJC_ABI_VERSION = 7;
62
63 Rewriter Rewrite;
64 DiagnosticsEngine &Diags;
65 const LangOptions &LangOpts;
66 ASTContext *Context;
67 SourceManager *SM;
68 TranslationUnitDecl *TUDecl;
69 FileID MainFileID;
70 const char *MainFileStart, *MainFileEnd;
71 Stmt *CurrentBody;
72 ParentMap *PropParentMap; // created lazily.
73 std::string InFileName;
74 std::unique_ptr<raw_ostream> OutFile;
75 std::string Preamble;
76
77 TypeDecl *ProtocolTypeDecl;
78 VarDecl *GlobalVarDecl;
79 unsigned RewriteFailedDiag;
80 // ObjC string constant support.
81 unsigned NumObjCStringLiterals;
82 VarDecl *ConstantStringClassReference;
83 RecordDecl *NSStringRecord;
84
85 // ObjC foreach break/continue generation support.
86 int BcLabelCount;
87
88 unsigned TryFinallyContainsReturnDiag;
89 // Needed for super.
90 ObjCMethodDecl *CurMethodDef;
91 RecordDecl *SuperStructDecl;
92 RecordDecl *ConstantStringDecl;
93
94 FunctionDecl *MsgSendFunctionDecl;
95 FunctionDecl *MsgSendSuperFunctionDecl;
96 FunctionDecl *MsgSendStretFunctionDecl;
97 FunctionDecl *MsgSendSuperStretFunctionDecl;
98 FunctionDecl *MsgSendFpretFunctionDecl;
99 FunctionDecl *GetClassFunctionDecl;
100 FunctionDecl *GetMetaClassFunctionDecl;
101 FunctionDecl *GetSuperClassFunctionDecl;
102 FunctionDecl *SelGetUidFunctionDecl;
103 FunctionDecl *CFStringFunctionDecl;
104 FunctionDecl *SuperConstructorFunctionDecl;
105 FunctionDecl *CurFunctionDef;
106 FunctionDecl *CurFunctionDeclToDeclareForBlock;
107
108 /* Misc. containers needed for meta-data rewrite. */
109 SmallVector<ObjCImplementationDecl *, 8> ClassImplementation;
110 SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation;
111 llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs;
112 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols;
113 llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCForwardDecls;
114 llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;
115 SmallVector<Stmt *, 32> Stmts;
116 SmallVector<int, 8> ObjCBcLabelNo;
117 // Remember all the @protocol(<expr>) expressions.
118 llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ProtocolExprDecls;
119
120 llvm::DenseSet<uint64_t> CopyDestroyCache;
121
122 // Block expressions.
123 SmallVector<BlockExpr *, 32> Blocks;
124 SmallVector<int, 32> InnerDeclRefsCount;
125 SmallVector<DeclRefExpr *, 32> InnerDeclRefs;
126
127 SmallVector<DeclRefExpr *, 32> BlockDeclRefs;
128
129 // Block related declarations.
130 SmallVector<ValueDecl *, 8> BlockByCopyDecls;
131 llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDeclsPtrSet;
132 SmallVector<ValueDecl *, 8> BlockByRefDecls;
133 llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDeclsPtrSet;
134 llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo;
135 llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls;
136 llvm::SmallPtrSet<VarDecl *, 8> ImportedLocalExternalDecls;
137
138 llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;
139
140 // This maps an original source AST to it's rewritten form. This allows
141 // us to avoid rewriting the same node twice (which is very uncommon).
142 // This is needed to support some of the exotic property rewriting.
143 llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
144
145 // Needed for header files being rewritten
146 bool IsHeader;
147 bool SilenceRewriteMacroWarning;
148 bool objc_impl_method;
149
150 bool DisableReplaceStmt;
151 class DisableReplaceStmtScope {
152 RewriteObjC &R;
153 bool SavedValue;
154
155 public:
156 DisableReplaceStmtScope(RewriteObjC &R)
157 : R(R), SavedValue(R.DisableReplaceStmt) {
158 R.DisableReplaceStmt = true;
159 }
160
161 ~DisableReplaceStmtScope() {
162 R.DisableReplaceStmt = SavedValue;
163 }
164 };
165
166 void InitializeCommon(ASTContext &context);
167
168 public:
169 // Top Level Driver code.
170 bool HandleTopLevelDecl(DeclGroupRef D) override {
171 for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
172 if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*I)) {
173 if (!Class->isThisDeclarationADefinition()) {
174 RewriteForwardClassDecl(D);
175 break;
176 }
177 }
178
179 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*I)) {
180 if (!Proto->isThisDeclarationADefinition()) {
181 RewriteForwardProtocolDecl(D);
182 break;
183 }
184 }
185
186 HandleTopLevelSingleDecl(*I);
187 }
188 return true;
189 }
190
191 void HandleTopLevelSingleDecl(Decl *D);
192 void HandleDeclInMainFile(Decl *D);
193 RewriteObjC(std::string inFile, std::unique_ptr<raw_ostream> OS,
194 DiagnosticsEngine &D, const LangOptions &LOpts,
195 bool silenceMacroWarn);
196
197 ~RewriteObjC() override {}
198
199 void HandleTranslationUnit(ASTContext &C) override;
200
201 void ReplaceStmt(Stmt *Old, Stmt *New) {
202 ReplaceStmtWithRange(Old, New, Old->getSourceRange());
203 }
204
205 void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
206 assert(Old != nullptr && New != nullptr && "Expected non-null Stmt's");
207
208 Stmt *ReplacingStmt = ReplacedNodes[Old];
209 if (ReplacingStmt)
210 return; // We can't rewrite the same node twice.
211
212 if (DisableReplaceStmt)
213 return;
214
215 // Measure the old text.
216 int Size = Rewrite.getRangeSize(SrcRange);
217 if (Size == -1) {
218 Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)
219 << Old->getSourceRange();
220 return;
221 }
222 // Get the new text.
223 std::string SStr;
224 llvm::raw_string_ostream S(SStr);
225 New->printPretty(S, nullptr, PrintingPolicy(LangOpts));
226 const std::string &Str = S.str();
227
228 // If replacement succeeded or warning disabled return with no warning.
229 if (!Rewrite.ReplaceText(SrcRange.getBegin(), Size, Str)) {
230 ReplacedNodes[Old] = New;
231 return;
232 }
233 if (SilenceRewriteMacroWarning)
234 return;
235 Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)
236 << Old->getSourceRange();
237 }
238
239 void InsertText(SourceLocation Loc, StringRef Str,
240 bool InsertAfter = true) {
241 // If insertion succeeded or warning disabled return with no warning.
242 if (!Rewrite.InsertText(Loc, Str, InsertAfter) ||
243 SilenceRewriteMacroWarning)
244 return;
245
246 Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
247 }
248
249 void ReplaceText(SourceLocation Start, unsigned OrigLength,
250 StringRef Str) {
251 // If removal succeeded or warning disabled return with no warning.
252 if (!Rewrite.ReplaceText(Start, OrigLength, Str) ||
253 SilenceRewriteMacroWarning)
254 return;
255
256 Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag);
257 }
258
259 // Syntactic Rewriting.
260 void RewriteRecordBody(RecordDecl *RD);
261 void RewriteInclude();
262 void RewriteForwardClassDecl(DeclGroupRef D);
263 void RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &DG);
264 void RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,
265 const std::string &typedefString);
266 void RewriteImplementations();
267 void RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
268 ObjCImplementationDecl *IMD,
269 ObjCCategoryImplDecl *CID);
270 void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl);
271 void RewriteImplementationDecl(Decl *Dcl);
272 void RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,
273 ObjCMethodDecl *MDecl, std::string &ResultStr);
274 void RewriteTypeIntoString(QualType T, std::string &ResultStr,
275 const FunctionType *&FPRetType);
276 void RewriteByRefString(std::string &ResultStr, const std::string &Name,
277 ValueDecl *VD, bool def=false);
278 void RewriteCategoryDecl(ObjCCategoryDecl *Dcl);
279 void RewriteProtocolDecl(ObjCProtocolDecl *Dcl);
280 void RewriteForwardProtocolDecl(DeclGroupRef D);
281 void RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG);
282 void RewriteMethodDeclaration(ObjCMethodDecl *Method);
283 void RewriteProperty(ObjCPropertyDecl *prop);
284 void RewriteFunctionDecl(FunctionDecl *FD);
285 void RewriteBlockPointerType(std::string& Str, QualType Type);
286 void RewriteBlockPointerTypeVariable(std::string& Str, ValueDecl *VD);
287 void RewriteBlockLiteralFunctionDecl(FunctionDecl *FD);
288 void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl);
289 void RewriteTypeOfDecl(VarDecl *VD);
290 void RewriteObjCQualifiedInterfaceTypes(Expr *E);
291
292 // Expression Rewriting.
293 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
294 Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
295 Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo);
296 Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo);
297 Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
298 Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
299 Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
300 Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
301 void RewriteTryReturnStmts(Stmt *S);
302 void RewriteSyncReturnStmts(Stmt *S, std::string buf);
303 Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
304 Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
305 Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
306 Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
307 SourceLocation OrigEnd);
308 Stmt *RewriteBreakStmt(BreakStmt *S);
309 Stmt *RewriteContinueStmt(ContinueStmt *S);
310 void RewriteCastExpr(CStyleCastExpr *CE);
311
312 // Block rewriting.
313 void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D);
314
315 // Block specific rewrite rules.
316 void RewriteBlockPointerDecl(NamedDecl *VD);
317 void RewriteByRefVar(VarDecl *VD);
318 Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD);
319 Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE);
320 void RewriteBlockPointerFunctionArgs(FunctionDecl *FD);
321
322 void RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl,
323 std::string &Result);
324
325 void Initialize(ASTContext &context) override = 0;
326
327 // Metadata Rewriting.
328 virtual void RewriteMetaDataIntoBuffer(std::string &Result) = 0;
329 virtual void RewriteObjCProtocolListMetaData(const ObjCList<ObjCProtocolDecl> &Prots,
330 StringRef prefix,
331 StringRef ClassName,
332 std::string &Result) = 0;
333 virtual void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
334 std::string &Result) = 0;
335 virtual void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol,
336 StringRef prefix,
337 StringRef ClassName,
338 std::string &Result) = 0;
339 virtual void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
340 std::string &Result) = 0;
341
342 // Rewriting ivar access
343 virtual Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) = 0;
344 virtual void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,
345 std::string &Result) = 0;
346
347 // Misc. AST transformation routines. Sometimes they end up calling
348 // rewriting routines on the new ASTs.
349 CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
350 ArrayRef<Expr *> Args,
351 SourceLocation StartLoc=SourceLocation(),
352 SourceLocation EndLoc=SourceLocation());
353 CallExpr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
354 QualType msgSendType,
355 QualType returnType,
356 SmallVectorImpl<QualType> &ArgTypes,
357 SmallVectorImpl<Expr*> &MsgExprs,
358 ObjCMethodDecl *Method);
359 Stmt *SynthMessageExpr(ObjCMessageExpr *Exp,
360 SourceLocation StartLoc=SourceLocation(),
361 SourceLocation EndLoc=SourceLocation());
362
363 void SynthCountByEnumWithState(std::string &buf);
364 void SynthMsgSendFunctionDecl();
365 void SynthMsgSendSuperFunctionDecl();
366 void SynthMsgSendStretFunctionDecl();
367 void SynthMsgSendFpretFunctionDecl();
368 void SynthMsgSendSuperStretFunctionDecl();
369 void SynthGetClassFunctionDecl();
370 void SynthGetMetaClassFunctionDecl();
371 void SynthGetSuperClassFunctionDecl();
372 void SynthSelGetUidFunctionDecl();
373 void SynthSuperConstructorFunctionDecl();
374
375 std::string SynthesizeByrefCopyDestroyHelper(VarDecl *VD, int flag);
376 std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
377 StringRef funcName, std::string Tag);
378 std::string SynthesizeBlockFunc(BlockExpr *CE, int i,
379 StringRef funcName, std::string Tag);
380 std::string SynthesizeBlockImpl(BlockExpr *CE,
381 std::string Tag, std::string Desc);
382 std::string SynthesizeBlockDescriptor(std::string DescTag,
383 std::string ImplTag,
384 int i, StringRef funcName,
385 unsigned hasCopy);
386 Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
387 void SynthesizeBlockLiterals(SourceLocation FunLocStart,
388 StringRef FunName);
389 FunctionDecl *SynthBlockInitFunctionDecl(StringRef name);
390 Stmt *SynthBlockInitExpr(BlockExpr *Exp,
391 const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs);
392
393 // Misc. helper routines.
394 QualType getProtocolType();
395 void WarnAboutReturnGotoStmts(Stmt *S);
396 void HasReturnStmts(Stmt *S, bool &hasReturns);
397 void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
398 void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);
399 void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD);
400
401 bool IsDeclStmtInForeachHeader(DeclStmt *DS);
402 void CollectBlockDeclRefInfo(BlockExpr *Exp);
403 void GetBlockDeclRefExprs(Stmt *S);
404 void GetInnerBlockDeclRefExprs(Stmt *S,
405 SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs,
406 llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts);
407
408 // We avoid calling Type::isBlockPointerType(), since it operates on the
409 // canonical type. We only care if the top-level type is a closure pointer.
410 bool isTopLevelBlockPointerType(QualType T) {
411 return isa<BlockPointerType>(T);
412 }
413
414 /// convertBlockPointerToFunctionPointer - Converts a block-pointer type
415 /// to a function pointer type and upon success, returns true; false
416 /// otherwise.
417 bool convertBlockPointerToFunctionPointer(QualType &T) {
418 if (isTopLevelBlockPointerType(T)) {
419 const auto *BPT = T->castAs<BlockPointerType>();
420 T = Context->getPointerType(BPT->getPointeeType());
421 return true;
422 }
423 return false;
424 }
425
426 bool needToScanForQualifiers(QualType T);
427 QualType getSuperStructType();
428 QualType getConstantStringStructType();
429 QualType convertFunctionTypeOfBlocks(const FunctionType *FT);
430 bool BufferContainsPPDirectives(const char *startBuf, const char *endBuf);
431
432 void convertToUnqualifiedObjCType(QualType &T) {
433 if (T->isObjCQualifiedIdType())
434 T = Context->getObjCIdType();
435 else if (T->isObjCQualifiedClassType())
436 T = Context->getObjCClassType();
437 else if (T->isObjCObjectPointerType() &&
438 T->getPointeeType()->isObjCQualifiedInterfaceType()) {
439 if (const ObjCObjectPointerType * OBJPT =
440 T->getAsObjCInterfacePointerType()) {
441 const ObjCInterfaceType *IFaceT = OBJPT->getInterfaceType();
442 T = QualType(IFaceT, 0);
443 T = Context->getPointerType(T);
444 }
445 }
446 }
447
448 // FIXME: This predicate seems like it would be useful to add to ASTContext.
449 bool isObjCType(QualType T) {
450 if (!LangOpts.ObjC)
451 return false;
452
453 QualType OCT = Context->getCanonicalType(T).getUnqualifiedType();
454
455 if (OCT == Context->getCanonicalType(Context->getObjCIdType()) ||
456 OCT == Context->getCanonicalType(Context->getObjCClassType()))
457 return true;
458
459 if (const PointerType *PT = OCT->getAs<PointerType>()) {
460 if (isa<ObjCInterfaceType>(PT->getPointeeType()) ||
461 PT->getPointeeType()->isObjCQualifiedIdType())
462 return true;
463 }
464 return false;
465 }
466 bool PointerTypeTakesAnyBlockArguments(QualType QT);
467 bool PointerTypeTakesAnyObjCQualifiedType(QualType QT);
468 void GetExtentOfArgList(const char *Name, const char *&LParen,
469 const char *&RParen);
470
471 void QuoteDoublequotes(std::string &From, std::string &To) {
472 for (unsigned i = 0; i < From.length(); i++) {
473 if (From[i] == '"')
474 To += "\\\"";
475 else
476 To += From[i];
477 }
478 }
479
480 QualType getSimpleFunctionType(QualType result,
481 ArrayRef<QualType> args,
482 bool variadic = false) {
483 if (result == Context->getObjCInstanceType())
484 result = Context->getObjCIdType();
485 FunctionProtoType::ExtProtoInfo fpi;
486 fpi.Variadic = variadic;
487 return Context->getFunctionType(result, args, fpi);
488 }
489
490 // Helper function: create a CStyleCastExpr with trivial type source info.
491 CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty,
492 CastKind Kind, Expr *E) {
493 TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation());
494 return CStyleCastExpr::Create(*Ctx, Ty, VK_RValue, Kind, E, nullptr,
495 TInfo, SourceLocation(), SourceLocation());
496 }
497
498 StringLiteral *getStringLiteral(StringRef Str) {
499 QualType StrType = Context->getConstantArrayType(
500 Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr,
501 ArrayType::Normal, 0);
502 return StringLiteral::Create(*Context, Str, StringLiteral::Ascii,
503 /*Pascal=*/false, StrType, SourceLocation());
504 }
505 };
506
507 class RewriteObjCFragileABI : public RewriteObjC {
508 public:
509 RewriteObjCFragileABI(std::string inFile, std::unique_ptr<raw_ostream> OS,
510 DiagnosticsEngine &D, const LangOptions &LOpts,
511 bool silenceMacroWarn)
512 : RewriteObjC(inFile, std::move(OS), D, LOpts, silenceMacroWarn) {}
513
514 ~RewriteObjCFragileABI() override {}
515 void Initialize(ASTContext &context) override;
516
517 // Rewriting metadata
518 template<typename MethodIterator>
519 void RewriteObjCMethodsMetaData(MethodIterator MethodBegin,
520 MethodIterator MethodEnd,
521 bool IsInstanceMethod,
522 StringRef prefix,
523 StringRef ClassName,
524 std::string &Result);
525 void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol,
526 StringRef prefix, StringRef ClassName,
527 std::string &Result) override;
528 void RewriteObjCProtocolListMetaData(
529 const ObjCList<ObjCProtocolDecl> &Prots,
530 StringRef prefix, StringRef ClassName, std::string &Result) override;
531 void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
532 std::string &Result) override;
533 void RewriteMetaDataIntoBuffer(std::string &Result) override;
534 void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
535 std::string &Result) override;
536
537 // Rewriting ivar
538 void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,
539 std::string &Result) override;
540 Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) override;
541 };
542 } // end anonymous namespace
543
544 void RewriteObjC::RewriteBlocksInFunctionProtoType(QualType funcType,
545 NamedDecl *D) {
546 if (const FunctionProtoType *fproto
547 = dyn_cast<FunctionProtoType>(funcType.IgnoreParens())) {
548 for (const auto &I : fproto->param_types())
549 if (isTopLevelBlockPointerType(I)) {
550 // All the args are checked/rewritten. Don't call twice!
551 RewriteBlockPointerDecl(D);
552 break;
553 }
554 }
555 }
556
557 void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
558 const PointerType *PT = funcType->getAs<PointerType>();
559 if (PT && PointerTypeTakesAnyBlockArguments(funcType))
560 RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND);
561 }
562
563 static bool IsHeaderFile(const std::string &Filename) {
564 std::string::size_type DotPos = Filename.rfind('.');
565
566 if (DotPos == std::string::npos) {
567 // no file extension
568 return false;
569 }
570
571 std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end());
572 // C header: .h
573 // C++ header: .hh or .H;
574 return Ext == "h" || Ext == "hh" || Ext == "H";
575 }
576
577 RewriteObjC::RewriteObjC(std::string inFile, std::unique_ptr<raw_ostream> OS,
578 DiagnosticsEngine &D, const LangOptions &LOpts,
579 bool silenceMacroWarn)
580 : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)),
581 SilenceRewriteMacroWarning(silenceMacroWarn) {
582 IsHeader = IsHeaderFile(inFile);
583 RewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning,
584 "rewriting sub-expression within a macro (may not be correct)");
585 TryFinallyContainsReturnDiag = Diags.getCustomDiagID(
586 DiagnosticsEngine::Warning,
587 "rewriter doesn't support user-specified control flow semantics "
588 "for @try/@finally (code may not execute properly)");
589 }
590
591 std::unique_ptr<ASTConsumer>
592 clang::CreateObjCRewriter(const std::string &InFile,
593 std::unique_ptr<raw_ostream> OS,
594 DiagnosticsEngine &Diags, const LangOptions &LOpts,
595 bool SilenceRewriteMacroWarning) {
596 return std::make_unique<RewriteObjCFragileABI>(
597 InFile, std::move(OS), Diags, LOpts, SilenceRewriteMacroWarning);
598 }
599
600 void RewriteObjC::InitializeCommon(ASTContext &context) {
601 Context = &context;
602 SM = &Context->getSourceManager();
603 TUDecl = Context->getTranslationUnitDecl();
604 MsgSendFunctionDecl = nullptr;
605 MsgSendSuperFunctionDecl = nullptr;
606 MsgSendStretFunctionDecl = nullptr;
607 MsgSendSuperStretFunctionDecl = nullptr;
608 MsgSendFpretFunctionDecl = nullptr;
609 GetClassFunctionDecl = nullptr;
610 GetMetaClassFunctionDecl = nullptr;
611 GetSuperClassFunctionDecl = nullptr;
612 SelGetUidFunctionDecl = nullptr;
613 CFStringFunctionDecl = nullptr;
614 ConstantStringClassReference = nullptr;
615 NSStringRecord = nullptr;
616 CurMethodDef = nullptr;
617 CurFunctionDef = nullptr;
618 CurFunctionDeclToDeclareForBlock = nullptr;
619 GlobalVarDecl = nullptr;
620 SuperStructDecl = nullptr;
621 ProtocolTypeDecl = nullptr;
622 ConstantStringDecl = nullptr;
623 BcLabelCount = 0;
624 SuperConstructorFunctionDecl = nullptr;
625 NumObjCStringLiterals = 0;
626 PropParentMap = nullptr;
627 CurrentBody = nullptr;
628 DisableReplaceStmt = false;
629 objc_impl_method = false;
630
631 // Get the ID and start/end of the main file.
632 MainFileID = SM->getMainFileID();
633 const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID);
634 MainFileStart = MainBuf->getBufferStart();
635 MainFileEnd = MainBuf->getBufferEnd();
636
637 Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts());
638 }
639
640 //===----------------------------------------------------------------------===//
641 // Top Level Driver Code
642 //===----------------------------------------------------------------------===//
643
644 void RewriteObjC::HandleTopLevelSingleDecl(Decl *D) {
645 if (Diags.hasErrorOccurred())
646 return;
647
648 // Two cases: either the decl could be in the main file, or it could be in a
649 // #included file. If the former, rewrite it now. If the later, check to see
650 // if we rewrote the #include/#import.
651 SourceLocation Loc = D->getLocation();
652 Loc = SM->getExpansionLoc(Loc);
653
654 // If this is for a builtin, ignore it.
655 if (Loc.isInvalid()) return;
656
657 // Look for built-in declarations that we need to refer during the rewrite.
658 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
659 RewriteFunctionDecl(FD);
660 } else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) {
661 // declared in <Foundation/NSString.h>
662 if (FVD->getName() == "_NSConstantStringClassReference") {
663 ConstantStringClassReference = FVD;
664 return;
665 }
666 } else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
667 if (ID->isThisDeclarationADefinition())
668 RewriteInterfaceDecl(ID);
669 } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
670 RewriteCategoryDecl(CD);
671 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
672 if (PD->isThisDeclarationADefinition())
673 RewriteProtocolDecl(PD);
674 } else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) {
675 // Recurse into linkage specifications
676 for (DeclContext::decl_iterator DI = LSD->decls_begin(),
677 DIEnd = LSD->decls_end();
678 DI != DIEnd; ) {
679 if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>((*DI))) {
680 if (!IFace->isThisDeclarationADefinition()) {
681 SmallVector<Decl *, 8> DG;
682 SourceLocation StartLoc = IFace->getBeginLoc();
683 do {
684 if (isa<ObjCInterfaceDecl>(*DI) &&
685 !cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition() &&
686 StartLoc == (*DI)->getBeginLoc())
687 DG.push_back(*DI);
688 else
689 break;
690
691 ++DI;
692 } while (DI != DIEnd);
693 RewriteForwardClassDecl(DG);
694 continue;
695 }
696 }
697
698 if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>((*DI))) {
699 if (!Proto->isThisDeclarationADefinition()) {
700 SmallVector<Decl *, 8> DG;
701 SourceLocation StartLoc = Proto->getBeginLoc();
702 do {
703 if (isa<ObjCProtocolDecl>(*DI) &&
704 !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() &&
705 StartLoc == (*DI)->getBeginLoc())
706 DG.push_back(*DI);
707 else
708 break;
709
710 ++DI;
711 } while (DI != DIEnd);
712 RewriteForwardProtocolDecl(DG);
713 continue;
714 }
715 }
716
717 HandleTopLevelSingleDecl(*DI);
718 ++DI;
719 }
720 }
721 // If we have a decl in the main file, see if we should rewrite it.
722 if (SM->isWrittenInMainFile(Loc))
723 return HandleDeclInMainFile(D);
724 }
725
726 //===----------------------------------------------------------------------===//
727 // Syntactic (non-AST) Rewriting Code
728 //===----------------------------------------------------------------------===//
729
730 void RewriteObjC::RewriteInclude() {
731 SourceLocation LocStart = SM->getLocForStartOfFile(MainFileID);
732 StringRef MainBuf = SM->getBufferData(MainFileID);
733 const char *MainBufStart = MainBuf.begin();
734 const char *MainBufEnd = MainBuf.end();
735 size_t ImportLen = strlen("import");
736
737 // Loop over the whole file, looking for includes.
738 for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr) {
739 if (*BufPtr == '#') {
740 if (++BufPtr == MainBufEnd)
741 return;
742 while (*BufPtr == ' ' || *BufPtr == '\t')
743 if (++BufPtr == MainBufEnd)
744 return;
745 if (!strncmp(BufPtr, "import", ImportLen)) {
746 // replace import with include
747 SourceLocation ImportLoc =
748 LocStart.getLocWithOffset(BufPtr-MainBufStart);
749 ReplaceText(ImportLoc, ImportLen, "include");
750 BufPtr += ImportLen;
751 }
752 }
753 }
754 }
755
756 static std::string getIvarAccessString(ObjCIvarDecl *OID) {
757 const ObjCInterfaceDecl *ClassDecl = OID->getContainingInterface();
758 std::string S;
759 S = "((struct ";
760 S += ClassDecl->getIdentifier()->getName();
761 S += "_IMPL *)self)->";
762 S += OID->getName();
763 return S;
764 }
765
766 void RewriteObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
767 ObjCImplementationDecl *IMD,
768 ObjCCategoryImplDecl *CID) {
769 static bool objcGetPropertyDefined = false;
770 static bool objcSetPropertyDefined = false;
771 SourceLocation startLoc = PID->getBeginLoc();
772 InsertText(startLoc, "// ");
773 const char *startBuf = SM->getCharacterData(startLoc);
774 assert((*startBuf == '@') && "bogus @synthesize location");
775 const char *semiBuf = strchr(startBuf, ';');
776 assert((*semiBuf == ';') && "@synthesize: can't find ';'");
777 SourceLocation onePastSemiLoc =
778 startLoc.getLocWithOffset(semiBuf-startBuf+1);
779
780 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
781 return; // FIXME: is this correct?
782
783 // Generate the 'getter' function.
784 ObjCPropertyDecl *PD = PID->getPropertyDecl();
785 ObjCIvarDecl *OID = PID->getPropertyIvarDecl();
786
787 if (!OID)
788 return;
789
790 unsigned Attributes = PD->getPropertyAttributes();
791 if (PID->getGetterMethodDecl() && !PID->getGetterMethodDecl()->isDefined()) {
792 bool GenGetProperty = !(Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic) &&
793 (Attributes & (ObjCPropertyDecl::OBJC_PR_retain |
794 ObjCPropertyDecl::OBJC_PR_copy));
795 std::string Getr;
796 if (GenGetProperty && !objcGetPropertyDefined) {
797 objcGetPropertyDefined = true;
798 // FIXME. Is this attribute correct in all cases?
799 Getr = "\nextern \"C\" __declspec(dllimport) "
800 "id objc_getProperty(id, SEL, long, bool);\n";
801 }
802 RewriteObjCMethodDecl(OID->getContainingInterface(),
803 PID->getGetterMethodDecl(), Getr);
804 Getr += "{ ";
805 // Synthesize an explicit cast to gain access to the ivar.
806 // See objc-act.c:objc_synthesize_new_getter() for details.
807 if (GenGetProperty) {
808 // return objc_getProperty(self, _cmd, offsetof(ClassDecl, OID), 1)
809 Getr += "typedef ";
810 const FunctionType *FPRetType = nullptr;
811 RewriteTypeIntoString(PID->getGetterMethodDecl()->getReturnType(), Getr,
812 FPRetType);
813 Getr += " _TYPE";
814 if (FPRetType) {
815 Getr += ")"; // close the precedence "scope" for "*".
816
817 // Now, emit the argument types (if any).
818 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)){
819 Getr += "(";
820 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
821 if (i) Getr += ", ";
822 std::string ParamStr =
823 FT->getParamType(i).getAsString(Context->getPrintingPolicy());
824 Getr += ParamStr;
825 }
826 if (FT->isVariadic()) {
827 if (FT->getNumParams())
828 Getr += ", ";
829 Getr += "...";
830 }
831 Getr += ")";
832 } else
833 Getr += "()";
834 }
835 Getr += ";\n";
836 Getr += "return (_TYPE)";
837 Getr += "objc_getProperty(self, _cmd, ";
838 RewriteIvarOffsetComputation(OID, Getr);
839 Getr += ", 1)";
840 }
841 else
842 Getr += "return " + getIvarAccessString(OID);
843 Getr += "; }";
844 InsertText(onePastSemiLoc, Getr);
845 }
846
847 if (PD->isReadOnly() || !PID->getSetterMethodDecl() ||
848 PID->getSetterMethodDecl()->isDefined())
849 return;
850
851 // Generate the 'setter' function.
852 std::string Setr;
853 bool GenSetProperty = Attributes & (ObjCPropertyDecl::OBJC_PR_retain |
854 ObjCPropertyDecl::OBJC_PR_copy);
855 if (GenSetProperty && !objcSetPropertyDefined) {
856 objcSetPropertyDefined = true;
857 // FIXME. Is this attribute correct in all cases?
858 Setr = "\nextern \"C\" __declspec(dllimport) "
859 "void objc_setProperty (id, SEL, long, id, bool, bool);\n";
860 }
861
862 RewriteObjCMethodDecl(OID->getContainingInterface(),
863 PID->getSetterMethodDecl(), Setr);
864 Setr += "{ ";
865 // Synthesize an explicit cast to initialize the ivar.
866 // See objc-act.c:objc_synthesize_new_setter() for details.
867 if (GenSetProperty) {
868 Setr += "objc_setProperty (self, _cmd, ";
869 RewriteIvarOffsetComputation(OID, Setr);
870 Setr += ", (id)";
871 Setr += PD->getName();
872 Setr += ", ";
873 if (Attributes & ObjCPropertyDecl::OBJC_PR_nonatomic)
874 Setr += "0, ";
875 else
876 Setr += "1, ";
877 if (Attributes & ObjCPropertyDecl::OBJC_PR_copy)
878 Setr += "1)";
879 else
880 Setr += "0)";
881 }
882 else {
883 Setr += getIvarAccessString(OID) + " = ";
884 Setr += PD->getName();
885 }
886 Setr += "; }";
887 InsertText(onePastSemiLoc, Setr);
888 }
889
890 static void RewriteOneForwardClassDecl(ObjCInterfaceDecl *ForwardDecl,
891 std::string &typedefString) {
892 typedefString += "#ifndef _REWRITER_typedef_";
893 typedefString += ForwardDecl->getNameAsString();
894 typedefString += "\n";
895 typedefString += "#define _REWRITER_typedef_";
896 typedefString += ForwardDecl->getNameAsString();
897 typedefString += "\n";
898 typedefString += "typedef struct objc_object ";
899 typedefString += ForwardDecl->getNameAsString();
900 typedefString += ";\n#endif\n";
901 }
902
903 void RewriteObjC::RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,
904 const std::string &typedefString) {
905 SourceLocation startLoc = ClassDecl->getBeginLoc();
906 const char *startBuf = SM->getCharacterData(startLoc);
907 const char *semiPtr = strchr(startBuf, ';');
908 // Replace the @class with typedefs corresponding to the classes.
909 ReplaceText(startLoc, semiPtr - startBuf + 1, typedefString);
910 }
911
912 void RewriteObjC::RewriteForwardClassDecl(DeclGroupRef D) {
913 std::string typedefString;
914 for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
915 ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(*I);
916 if (I == D.begin()) {
917 // Translate to typedef's that forward reference structs with the same name
918 // as the class. As a convenience, we include the original declaration
919 // as a comment.
920 typedefString += "// @class ";
921 typedefString += ForwardDecl->getNameAsString();
922 typedefString += ";\n";
923 }
924 RewriteOneForwardClassDecl(ForwardDecl, typedefString);
925 }
926 DeclGroupRef::iterator I = D.begin();
927 RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(*I), typedefString);
928 }
929
930 void RewriteObjC::RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &D) {
931 std::string typedefString;
932 for (unsigned i = 0; i < D.size(); i++) {
933 ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
934 if (i == 0) {
935 typedefString += "// @class ";
936 typedefString += ForwardDecl->getNameAsString();
937 typedefString += ";\n";
938 }
939 RewriteOneForwardClassDecl(ForwardDecl, typedefString);
940 }
941 RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
942 }
943
944 void RewriteObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) {
945 // When method is a synthesized one, such as a getter/setter there is
946 // nothing to rewrite.
947 if (Method->isImplicit())
948 return;
949 SourceLocation LocStart = Method->getBeginLoc();
950 SourceLocation LocEnd = Method->getEndLoc();
951
952 if (SM->getExpansionLineNumber(LocEnd) >
953 SM->getExpansionLineNumber(LocStart)) {
954 InsertText(LocStart, "#if 0\n");
955 ReplaceText(LocEnd, 1, ";\n#endif\n");
956 } else {
957 InsertText(LocStart, "// ");
958 }
959 }
960
961 void RewriteObjC::RewriteProperty(ObjCPropertyDecl *prop) {
962 SourceLocation Loc = prop->getAtLoc();
963
964 ReplaceText(Loc, 0, "// ");
965 // FIXME: handle properties that are declared across multiple lines.
966 }
967
968 void RewriteObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) {
969 SourceLocation LocStart = CatDecl->getBeginLoc();
970
971 // FIXME: handle category headers that are declared across multiple lines.
972 ReplaceText(LocStart, 0, "// ");
973
974 for (auto *I : CatDecl->instance_properties())
975 RewriteProperty(I);
976 for (auto *I : CatDecl->instance_methods())
977 RewriteMethodDeclaration(I);
978 for (auto *I : CatDecl->class_methods())
979 RewriteMethodDeclaration(I);
980
981 // Lastly, comment out the @end.
982 ReplaceText(CatDecl->getAtEndRange().getBegin(),
983 strlen("@end"), "/* @end */");
984 }
985
986 void RewriteObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) {
987 SourceLocation LocStart = PDecl->getBeginLoc();
988 assert(PDecl->isThisDeclarationADefinition());
989
990 // FIXME: handle protocol headers that are declared across multiple lines.
991 ReplaceText(LocStart, 0, "// ");
992
993 for (auto *I : PDecl->instance_methods())
994 RewriteMethodDeclaration(I);
995 for (auto *I : PDecl->class_methods())
996 RewriteMethodDeclaration(I);
997 for (auto *I : PDecl->instance_properties())
998 RewriteProperty(I);
999
1000 // Lastly, comment out the @end.
1001 SourceLocation LocEnd = PDecl->getAtEndRange().getBegin();
1002 ReplaceText(LocEnd, strlen("@end"), "/* @end */");
1003
1004 // Must comment out @optional/@required
1005 const char *startBuf = SM->getCharacterData(LocStart);
1006 const char *endBuf = SM->getCharacterData(LocEnd);
1007 for (const char *p = startBuf; p < endBuf; p++) {
1008 if (*p == '@' && !strncmp(p+1, "optional", strlen("optional"))) {
1009 SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf);
1010 ReplaceText(OptionalLoc, strlen("@optional"), "/* @optional */");
1011
1012 }
1013 else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))) {
1014 SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf);
1015 ReplaceText(OptionalLoc, strlen("@required"), "/* @required */");
1016
1017 }
1018 }
1019 }
1020
1021 void RewriteObjC::RewriteForwardProtocolDecl(DeclGroupRef D) {
1022 SourceLocation LocStart = (*D.begin())->getBeginLoc();
1023 if (LocStart.isInvalid())
1024 llvm_unreachable("Invalid SourceLocation");
1025 // FIXME: handle forward protocol that are declared across multiple lines.
1026 ReplaceText(LocStart, 0, "// ");
1027 }
1028
1029 void
1030 RewriteObjC::RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG) {
1031 SourceLocation LocStart = DG[0]->getBeginLoc();
1032 if (LocStart.isInvalid())
1033 llvm_unreachable("Invalid SourceLocation");
1034 // FIXME: handle forward protocol that are declared across multiple lines.
1035 ReplaceText(LocStart, 0, "// ");
1036 }
1037
1038 void RewriteObjC::RewriteTypeIntoString(QualType T, std::string &ResultStr,
1039 const FunctionType *&FPRetType) {
1040 if (T->isObjCQualifiedIdType())
1041 ResultStr += "id";
1042 else if (T->isFunctionPointerType() ||
1043 T->isBlockPointerType()) {
1044 // needs special handling, since pointer-to-functions have special
1045 // syntax (where a decaration models use).
1046 QualType retType = T;
1047 QualType PointeeTy;
1048 if (const PointerType* PT = retType->getAs<PointerType>())
1049 PointeeTy = PT->getPointeeType();
1050 else if (const BlockPointerType *BPT = retType->getAs<BlockPointerType>())
1051 PointeeTy = BPT->getPointeeType();
1052 if ((FPRetType = PointeeTy->getAs<FunctionType>())) {
1053 ResultStr +=
1054 FPRetType->getReturnType().getAsString(Context->getPrintingPolicy());
1055 ResultStr += "(*";
1056 }
1057 } else
1058 ResultStr += T.getAsString(Context->getPrintingPolicy());
1059 }
1060
1061 void RewriteObjC::RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,
1062 ObjCMethodDecl *OMD,
1063 std::string &ResultStr) {
1064 //fprintf(stderr,"In RewriteObjCMethodDecl\n");
1065 const FunctionType *FPRetType = nullptr;
1066 ResultStr += "\nstatic ";
1067 RewriteTypeIntoString(OMD->getReturnType(), ResultStr, FPRetType);
1068 ResultStr += " ";
1069
1070 // Unique method name
1071 std::string NameStr;
1072
1073 if (OMD->isInstanceMethod())
1074 NameStr += "_I_";
1075 else
1076 NameStr += "_C_";
1077
1078 NameStr += IDecl->getNameAsString();
1079 NameStr += "_";
1080
1081 if (ObjCCategoryImplDecl *CID =
1082 dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) {
1083 NameStr += CID->getNameAsString();
1084 NameStr += "_";
1085 }
1086 // Append selector names, replacing ':' with '_'
1087 {
1088 std::string selString = OMD->getSelector().getAsString();
1089 int len = selString.size();
1090 for (int i = 0; i < len; i++)
1091 if (selString[i] == ':')
1092 selString[i] = '_';
1093 NameStr += selString;
1094 }
1095 // Remember this name for metadata emission
1096 MethodInternalNames[OMD] = NameStr;
1097 ResultStr += NameStr;
1098
1099 // Rewrite arguments
1100 ResultStr += "(";
1101
1102 // invisible arguments
1103 if (OMD->isInstanceMethod()) {
1104 QualType selfTy = Context->getObjCInterfaceType(IDecl);
1105 selfTy = Context->getPointerType(selfTy);
1106 if (!LangOpts.MicrosoftExt) {
1107 if (ObjCSynthesizedStructs.count(const_cast<ObjCInterfaceDecl*>(IDecl)))
1108 ResultStr += "struct ";
1109 }
1110 // When rewriting for Microsoft, explicitly omit the structure name.
1111 ResultStr += IDecl->getNameAsString();
1112 ResultStr += " *";
1113 }
1114 else
1115 ResultStr += Context->getObjCClassType().getAsString(
1116 Context->getPrintingPolicy());
1117
1118 ResultStr += " self, ";
1119 ResultStr += Context->getObjCSelType().getAsString(Context->getPrintingPolicy());
1120 ResultStr += " _cmd";
1121
1122 // Method arguments.
1123 for (const auto *PDecl : OMD->parameters()) {
1124 ResultStr += ", ";
1125 if (PDecl->getType()->isObjCQualifiedIdType()) {
1126 ResultStr += "id ";
1127 ResultStr += PDecl->getNameAsString();
1128 } else {
1129 std::string Name = PDecl->getNameAsString();
1130 QualType QT = PDecl->getType();
1131 // Make sure we convert "t (^)(...)" to "t (*)(...)".
1132 (void)convertBlockPointerToFunctionPointer(QT);
1133 QT.getAsStringInternal(Name, Context->getPrintingPolicy());
1134 ResultStr += Name;
1135 }
1136 }
1137 if (OMD->isVariadic())
1138 ResultStr += ", ...";
1139 ResultStr += ") ";
1140
1141 if (FPRetType) {
1142 ResultStr += ")"; // close the precedence "scope" for "*".
1143
1144 // Now, emit the argument types (if any).
1145 if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)) {
1146 ResultStr += "(";
1147 for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1148 if (i) ResultStr += ", ";
1149 std::string ParamStr =
1150 FT->getParamType(i).getAsString(Context->getPrintingPolicy());
1151 ResultStr += ParamStr;
1152 }
1153 if (FT->isVariadic()) {
1154 if (FT->getNumParams())
1155 ResultStr += ", ";
1156 ResultStr += "...";
1157 }
1158 ResultStr += ")";
1159 } else {
1160 ResultStr += "()";
1161 }
1162 }
1163 }
1164
1165 void RewriteObjC::RewriteImplementationDecl(Decl *OID) {
1166 ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID);
1167 ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID);
1168 assert((IMD || CID) && "Unknown ImplementationDecl");
1169
1170 InsertText(IMD ? IMD->getBeginLoc() : CID->getBeginLoc(), "// ");
1171
1172 for (auto *OMD : IMD ? IMD->instance_methods() : CID->instance_methods()) {
1173 if (!OMD->getBody())
1174 continue;
1175 std::string ResultStr;
1176 RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr);
1177 SourceLocation LocStart = OMD->getBeginLoc();
1178 SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc();
1179
1180 const char *startBuf = SM->getCharacterData(LocStart);
1181 const char *endBuf = SM->getCharacterData(LocEnd);
1182 ReplaceText(LocStart, endBuf-startBuf, ResultStr);
1183 }
1184
1185 for (auto *OMD : IMD ? IMD->class_methods() : CID->class_methods()) {
1186 if (!OMD->getBody())
1187 continue;
1188 std::string ResultStr;
1189 RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr);
1190 SourceLocation LocStart = OMD->getBeginLoc();
1191 SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc();
1192
1193 const char *startBuf = SM->getCharacterData(LocStart);
1194 const char *endBuf = SM->getCharacterData(LocEnd);
1195 ReplaceText(LocStart, endBuf-startBuf, ResultStr);
1196 }
1197 for (auto *I : IMD ? IMD->property_impls() : CID->property_impls())
1198 RewritePropertyImplDecl(I, IMD, CID);
1199
1200 InsertText(IMD ? IMD->getEndLoc() : CID->getEndLoc(), "// ");
1201 }
1202
1203 void RewriteObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) {
1204 std::string ResultStr;
1205 if (!ObjCForwardDecls.count(ClassDecl->getCanonicalDecl())) {
1206 // we haven't seen a forward decl - generate a typedef.
1207 ResultStr = "#ifndef _REWRITER_typedef_";
1208 ResultStr += ClassDecl->getNameAsString();
1209 ResultStr += "\n";
1210 ResultStr += "#define _REWRITER_typedef_";
1211 ResultStr += ClassDecl->getNameAsString();
1212 ResultStr += "\n";
1213 ResultStr += "typedef struct objc_object ";
1214 ResultStr += ClassDecl->getNameAsString();
1215 ResultStr += ";\n#endif\n";
1216 // Mark this typedef as having been generated.
1217 ObjCForwardDecls.insert(ClassDecl->getCanonicalDecl());
1218 }
1219 RewriteObjCInternalStruct(ClassDecl, ResultStr);
1220
1221 for (auto *I : ClassDecl->instance_properties())
1222 RewriteProperty(I);
1223 for (auto *I : ClassDecl->instance_methods())
1224 RewriteMethodDeclaration(I);
1225 for (auto *I : ClassDecl->class_methods())
1226 RewriteMethodDeclaration(I);
1227
1228 // Lastly, comment out the @end.
1229 ReplaceText(ClassDecl->getAtEndRange().getBegin(), strlen("@end"),
1230 "/* @end */");
1231 }
1232
1233 Stmt *RewriteObjC::RewritePropertyOrImplicitSetter(PseudoObjectExpr *PseudoOp) {
1234 SourceRange OldRange = PseudoOp->getSourceRange();
1235
1236 // We just magically know some things about the structure of this
1237 // expression.
1238 ObjCMessageExpr *OldMsg =
1239 cast<ObjCMessageExpr>(PseudoOp->getSemanticExpr(
1240 PseudoOp->getNumSemanticExprs() - 1));
1241
1242 // Because the rewriter doesn't allow us to rewrite rewritten code,
1243 // we need to suppress rewriting the sub-statements.
1244 Expr *Base, *RHS;
1245 {
1246 DisableReplaceStmtScope S(*this);
1247
1248 // Rebuild the base expression if we have one.
1249 Base = nullptr;
1250 if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) {
1251 Base = OldMsg->getInstanceReceiver();
1252 Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1253 Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1254 }
1255
1256 // Rebuild the RHS.
1257 RHS = cast<BinaryOperator>(PseudoOp->getSyntacticForm())->getRHS();
1258 RHS = cast<OpaqueValueExpr>(RHS)->getSourceExpr();
1259 RHS = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(RHS));
1260 }
1261
1262 // TODO: avoid this copy.
1263 SmallVector<SourceLocation, 1> SelLocs;
1264 OldMsg->getSelectorLocs(SelLocs);
1265
1266 ObjCMessageExpr *NewMsg = nullptr;
1267 switch (OldMsg->getReceiverKind()) {
1268 case ObjCMessageExpr::Class:
1269 NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1270 OldMsg->getValueKind(),
1271 OldMsg->getLeftLoc(),
1272 OldMsg->getClassReceiverTypeInfo(),
1273 OldMsg->getSelector(),
1274 SelLocs,
1275 OldMsg->getMethodDecl(),
1276 RHS,
1277 OldMsg->getRightLoc(),
1278 OldMsg->isImplicit());
1279 break;
1280
1281 case ObjCMessageExpr::Instance:
1282 NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1283 OldMsg->getValueKind(),
1284 OldMsg->getLeftLoc(),
1285 Base,
1286 OldMsg->getSelector(),
1287 SelLocs,
1288 OldMsg->getMethodDecl(),
1289 RHS,
1290 OldMsg->getRightLoc(),
1291 OldMsg->isImplicit());
1292 break;
1293
1294 case ObjCMessageExpr::SuperClass:
1295 case ObjCMessageExpr::SuperInstance:
1296 NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1297 OldMsg->getValueKind(),
1298 OldMsg->getLeftLoc(),
1299 OldMsg->getSuperLoc(),
1300 OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance,
1301 OldMsg->getSuperType(),
1302 OldMsg->getSelector(),
1303 SelLocs,
1304 OldMsg->getMethodDecl(),
1305 RHS,
1306 OldMsg->getRightLoc(),
1307 OldMsg->isImplicit());
1308 break;
1309 }
1310
1311 Stmt *Replacement = SynthMessageExpr(NewMsg);
1312 ReplaceStmtWithRange(PseudoOp, Replacement, OldRange);
1313 return Replacement;
1314 }
1315
1316 Stmt *RewriteObjC::RewritePropertyOrImplicitGetter(PseudoObjectExpr *PseudoOp) {
1317 SourceRange OldRange = PseudoOp->getSourceRange();
1318
1319 // We just magically know some things about the structure of this
1320 // expression.
1321 ObjCMessageExpr *OldMsg =
1322 cast<ObjCMessageExpr>(PseudoOp->getResultExpr()->IgnoreImplicit());
1323
1324 // Because the rewriter doesn't allow us to rewrite rewritten code,
1325 // we need to suppress rewriting the sub-statements.
1326 Expr *Base = nullptr;
1327 {
1328 DisableReplaceStmtScope S(*this);
1329
1330 // Rebuild the base expression if we have one.
1331 if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) {
1332 Base = OldMsg->getInstanceReceiver();
1333 Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
1334 Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
1335 }
1336 }
1337
1338 // Intentionally empty.
1339 SmallVector<SourceLocation, 1> SelLocs;
1340 SmallVector<Expr*, 1> Args;
1341
1342 ObjCMessageExpr *NewMsg = nullptr;
1343 switch (OldMsg->getReceiverKind()) {
1344 case ObjCMessageExpr::Class:
1345 NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1346 OldMsg->getValueKind(),
1347 OldMsg->getLeftLoc(),
1348 OldMsg->getClassReceiverTypeInfo(),
1349 OldMsg->getSelector(),
1350 SelLocs,
1351 OldMsg->getMethodDecl(),
1352 Args,
1353 OldMsg->getRightLoc(),
1354 OldMsg->isImplicit());
1355 break;
1356
1357 case ObjCMessageExpr::Instance:
1358 NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1359 OldMsg->getValueKind(),
1360 OldMsg->getLeftLoc(),
1361 Base,
1362 OldMsg->getSelector(),
1363 SelLocs,
1364 OldMsg->getMethodDecl(),
1365 Args,
1366 OldMsg->getRightLoc(),
1367 OldMsg->isImplicit());
1368 break;
1369
1370 case ObjCMessageExpr::SuperClass:
1371 case ObjCMessageExpr::SuperInstance:
1372 NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
1373 OldMsg->getValueKind(),
1374 OldMsg->getLeftLoc(),
1375 OldMsg->getSuperLoc(),
1376 OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance,
1377 OldMsg->getSuperType(),
1378 OldMsg->getSelector(),
1379 SelLocs,
1380 OldMsg->getMethodDecl(),
1381 Args,
1382 OldMsg->getRightLoc(),
1383 OldMsg->isImplicit());
1384 break;
1385 }
1386
1387 Stmt *Replacement = SynthMessageExpr(NewMsg);
1388 ReplaceStmtWithRange(PseudoOp, Replacement, OldRange);
1389 return Replacement;
1390 }
1391
1392 /// SynthCountByEnumWithState - To print:
1393 /// ((unsigned int (*)
1394 /// (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
1395 /// (void *)objc_msgSend)((id)l_collection,
1396 /// sel_registerName(
1397 /// "countByEnumeratingWithState:objects:count:"),
1398 /// &enumState,
1399 /// (id *)__rw_items, (unsigned int)16)
1400 ///
1401 void RewriteObjC::SynthCountByEnumWithState(std::string &buf) {
1402 buf += "((unsigned int (*) (id, SEL, struct __objcFastEnumerationState *, "
1403 "id *, unsigned int))(void *)objc_msgSend)";
1404 buf += "\n\t\t";
1405 buf += "((id)l_collection,\n\t\t";
1406 buf += "sel_registerName(\"countByEnumeratingWithState:objects:count:\"),";
1407 buf += "\n\t\t";
1408 buf += "&enumState, "
1409 "(id *)__rw_items, (unsigned int)16)";
1410 }
1411
1412 /// RewriteBreakStmt - Rewrite for a break-stmt inside an ObjC2's foreach
1413 /// statement to exit to its outer synthesized loop.
1414 ///
1415 Stmt *RewriteObjC::RewriteBreakStmt(BreakStmt *S) {
1416 if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1417 return S;
1418 // replace break with goto __break_label
1419 std::string buf;
1420
1421 SourceLocation startLoc = S->getBeginLoc();
1422 buf = "goto __break_label_";
1423 buf += utostr(ObjCBcLabelNo.back());
1424 ReplaceText(startLoc, strlen("break"), buf);
1425
1426 return nullptr;
1427 }
1428
1429 /// RewriteContinueStmt - Rewrite for a continue-stmt inside an ObjC2's foreach
1430 /// statement to continue with its inner synthesized loop.
1431 ///
1432 Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) {
1433 if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1434 return S;
1435 // replace continue with goto __continue_label
1436 std::string buf;
1437
1438 SourceLocation startLoc = S->getBeginLoc();
1439 buf = "goto __continue_label_";
1440 buf += utostr(ObjCBcLabelNo.back());
1441 ReplaceText(startLoc, strlen("continue"), buf);
1442
1443 return nullptr;
1444 }
1445
1446 /// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement.
1447 /// It rewrites:
1448 /// for ( type elem in collection) { stmts; }
1449
1450 /// Into:
1451 /// {
1452 /// type elem;
1453 /// struct __objcFastEnumerationState enumState = { 0 };
1454 /// id __rw_items[16];
1455 /// id l_collection = (id)collection;
1456 /// unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1457 /// objects:__rw_items count:16];
1458 /// if (limit) {
1459 /// unsigned long startMutations = *enumState.mutationsPtr;
1460 /// do {
1461 /// unsigned long counter = 0;
1462 /// do {
1463 /// if (startMutations != *enumState.mutationsPtr)
1464 /// objc_enumerationMutation(l_collection);
1465 /// elem = (type)enumState.itemsPtr[counter++];
1466 /// stmts;
1467 /// __continue_label: ;
1468 /// } while (counter < limit);
1469 /// } while (limit = [l_collection countByEnumeratingWithState:&enumState
1470 /// objects:__rw_items count:16]);
1471 /// elem = nil;
1472 /// __break_label: ;
1473 /// }
1474 /// else
1475 /// elem = nil;
1476 /// }
1477 ///
1478 Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
1479 SourceLocation OrigEnd) {
1480 assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty");
1481 assert(isa<ObjCForCollectionStmt>(Stmts.back()) &&
1482 "ObjCForCollectionStmt Statement stack mismatch");
1483 assert(!ObjCBcLabelNo.empty() &&
1484 "ObjCForCollectionStmt - Label No stack empty");
1485
1486 SourceLocation startLoc = S->getBeginLoc();
1487 const char *startBuf = SM->getCharacterData(startLoc);
1488 StringRef elementName;
1489 std::string elementTypeAsString;
1490 std::string buf;
1491 buf = "\n{\n\t";
1492 if (DeclStmt *DS = dyn_cast<DeclStmt>(S->getElement())) {
1493 // type elem;
1494 NamedDecl* D = cast<NamedDecl>(DS->getSingleDecl());
1495 QualType ElementType = cast<ValueDecl>(D)->getType();
1496 if (ElementType->isObjCQualifiedIdType() ||
1497 ElementType->isObjCQualifiedInterfaceType())
1498 // Simply use 'id' for all qualified types.
1499 elementTypeAsString = "id";
1500 else
1501 elementTypeAsString = ElementType.getAsString(Context->getPrintingPolicy());
1502 buf += elementTypeAsString;
1503 buf += " ";
1504 elementName = D->getName();
1505 buf += elementName;
1506 buf += ";\n\t";
1507 }
1508 else {
1509 DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
1510 elementName = DR->getDecl()->getName();
1511 ValueDecl *VD = DR->getDecl();
1512 if (VD->getType()->isObjCQualifiedIdType() ||
1513 VD->getType()->isObjCQualifiedInterfaceType())
1514 // Simply use 'id' for all qualified types.
1515 elementTypeAsString = "id";
1516 else
1517 elementTypeAsString = VD->getType().getAsString(Context->getPrintingPolicy());
1518 }
1519
1520 // struct __objcFastEnumerationState enumState = { 0 };
1521 buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t";
1522 // id __rw_items[16];
1523 buf += "id __rw_items[16];\n\t";
1524 // id l_collection = (id)
1525 buf += "id l_collection = (id)";
1526 // Find start location of 'collection' the hard way!
1527 const char *startCollectionBuf = startBuf;
1528 startCollectionBuf += 3; // skip 'for'
1529 startCollectionBuf = strchr(startCollectionBuf, '(');
1530 startCollectionBuf++; // skip '('
1531 // find 'in' and skip it.
1532 while (*startCollectionBuf != ' ' ||
1533 *(startCollectionBuf+1) != 'i' || *(startCollectionBuf+2) != 'n' ||
1534 (*(startCollectionBuf+3) != ' ' &&
1535 *(startCollectionBuf+3) != '[' && *(startCollectionBuf+3) != '('))
1536 startCollectionBuf++;
1537 startCollectionBuf += 3;
1538
1539 // Replace: "for (type element in" with string constructed thus far.
1540 ReplaceText(startLoc, startCollectionBuf - startBuf, buf);
1541 // Replace ')' in for '(' type elem in collection ')' with ';'
1542 SourceLocation rightParenLoc = S->getRParenLoc();
1543 const char *rparenBuf = SM->getCharacterData(rightParenLoc);
1544 SourceLocation lparenLoc = startLoc.getLocWithOffset(rparenBuf-startBuf);
1545 buf = ";\n\t";
1546
1547 // unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1548 // objects:__rw_items count:16];
1549 // which is synthesized into:
1550 // unsigned int limit =
1551 // ((unsigned int (*)
1552 // (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
1553 // (void *)objc_msgSend)((id)l_collection,
1554 // sel_registerName(
1555 // "countByEnumeratingWithState:objects:count:"),
1556 // (struct __objcFastEnumerationState *)&state,
1557 // (id *)__rw_items, (unsigned int)16);
1558 buf += "unsigned long limit =\n\t\t";
1559 SynthCountByEnumWithState(buf);
1560 buf += ";\n\t";
1561 /// if (limit) {
1562 /// unsigned long startMutations = *enumState.mutationsPtr;
1563 /// do {
1564 /// unsigned long counter = 0;
1565 /// do {
1566 /// if (startMutations != *enumState.mutationsPtr)
1567 /// objc_enumerationMutation(l_collection);
1568 /// elem = (type)enumState.itemsPtr[counter++];
1569 buf += "if (limit) {\n\t";
1570 buf += "unsigned long startMutations = *enumState.mutationsPtr;\n\t";
1571 buf += "do {\n\t\t";
1572 buf += "unsigned long counter = 0;\n\t\t";
1573 buf += "do {\n\t\t\t";
1574 buf += "if (startMutations != *enumState.mutationsPtr)\n\t\t\t\t";
1575 buf += "objc_enumerationMutation(l_collection);\n\t\t\t";
1576 buf += elementName;
1577 buf += " = (";
1578 buf += elementTypeAsString;
1579 buf += ")enumState.itemsPtr[counter++];";
1580 // Replace ')' in for '(' type elem in collection ')' with all of these.
1581 ReplaceText(lparenLoc, 1, buf);
1582
1583 /// __continue_label: ;
1584 /// } while (counter < limit);
1585 /// } while (limit = [l_collection countByEnumeratingWithState:&enumState
1586 /// objects:__rw_items count:16]);
1587 /// elem = nil;
1588 /// __break_label: ;
1589 /// }
1590 /// else
1591 /// elem = nil;
1592 /// }
1593 ///
1594 buf = ";\n\t";
1595 buf += "__continue_label_";
1596 buf += utostr(ObjCBcLabelNo.back());
1597 buf += ": ;";
1598 buf += "\n\t\t";
1599 buf += "} while (counter < limit);\n\t";
1600 buf += "} while (limit = ";
1601 SynthCountByEnumWithState(buf);
1602 buf += ");\n\t";
1603 buf += elementName;
1604 buf += " = ((";
1605 buf += elementTypeAsString;
1606 buf += ")0);\n\t";
1607 buf += "__break_label_";
1608 buf += utostr(ObjCBcLabelNo.back());
1609 buf += ": ;\n\t";
1610 buf += "}\n\t";
1611 buf += "else\n\t\t";
1612 buf += elementName;
1613 buf += " = ((";
1614 buf += elementTypeAsString;
1615 buf += ")0);\n\t";
1616 buf += "}\n";
1617
1618 // Insert all these *after* the statement body.
1619 // FIXME: If this should support Obj-C++, support CXXTryStmt
1620 if (isa<CompoundStmt>(S->getBody())) {
1621 SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(1);
1622 InsertText(endBodyLoc, buf);
1623 } else {
1624 /* Need to treat single statements specially. For example:
1625 *
1626 * for (A *a in b) if (stuff()) break;
1627 * for (A *a in b) xxxyy;
1628 *
1629 * The following code simply scans ahead to the semi to find the actual end.
1630 */
1631 const char *stmtBuf = SM->getCharacterData(OrigEnd);
1632 const char *semiBuf = strchr(stmtBuf, ';');
1633 assert(semiBuf && "Can't find ';'");
1634 SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(semiBuf-stmtBuf+1);
1635 InsertText(endBodyLoc, buf);
1636 }
1637 Stmts.pop_back();
1638 ObjCBcLabelNo.pop_back();
1639 return nullptr;
1640 }
1641
1642 /// RewriteObjCSynchronizedStmt -
1643 /// This routine rewrites @synchronized(expr) stmt;
1644 /// into:
1645 /// objc_sync_enter(expr);
1646 /// @try stmt @finally { objc_sync_exit(expr); }
1647 ///
1648 Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
1649 // Get the start location and compute the semi location.
1650 SourceLocation startLoc = S->getBeginLoc();
1651 const char *startBuf = SM->getCharacterData(startLoc);
1652
1653 assert((*startBuf == '@') && "bogus @synchronized location");
1654
1655 std::string buf;
1656 buf = "objc_sync_enter((id)";
1657 const char *lparenBuf = startBuf;
1658 while (*lparenBuf != '(') lparenBuf++;
1659 ReplaceText(startLoc, lparenBuf-startBuf+1, buf);
1660 // We can't use S->getSynchExpr()->getEndLoc() to find the end location, since
1661 // the sync expression is typically a message expression that's already
1662 // been rewritten! (which implies the SourceLocation's are invalid).
1663 SourceLocation endLoc = S->getSynchBody()->getBeginLoc();
1664 const char *endBuf = SM->getCharacterData(endLoc);
1665 while (*endBuf != ')') endBuf--;
1666 SourceLocation rparenLoc = startLoc.getLocWithOffset(endBuf-startBuf);
1667 buf = ");\n";
1668 // declare a new scope with two variables, _stack and _rethrow.
1669 buf += "/* @try scope begin */ \n{ struct _objc_exception_data {\n";
1670 buf += "int buf[18/*32-bit i386*/];\n";
1671 buf += "char *pointers[4];} _stack;\n";
1672 buf += "id volatile _rethrow = 0;\n";
1673 buf += "objc_exception_try_enter(&_stack);\n";
1674 buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
1675 ReplaceText(rparenLoc, 1, buf);
1676 startLoc = S->getSynchBody()->getEndLoc();
1677 startBuf = SM->getCharacterData(startLoc);
1678
1679 assert((*startBuf == '}') && "bogus @synchronized block");
1680 SourceLocation lastCurlyLoc = startLoc;
1681 buf = "}\nelse {\n";
1682 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1683 buf += "}\n";
1684 buf += "{ /* implicit finally clause */\n";
1685 buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
1686
1687 std::string syncBuf;
1688 syncBuf += " objc_sync_exit(";
1689
1690 Expr *syncExpr = S->getSynchExpr();
1691 CastKind CK = syncExpr->getType()->isObjCObjectPointerType()
1692 ? CK_BitCast :
1693 syncExpr->getType()->isBlockPointerType()
1694 ? CK_BlockPointerToObjCPointerCast
1695 : CK_CPointerToObjCPointerCast;
1696 syncExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
1697 CK, syncExpr);
1698 std::string syncExprBufS;
1699 llvm::raw_string_ostream syncExprBuf(syncExprBufS);
1700 assert(syncExpr != nullptr && "Expected non-null Expr");
1701 syncExpr->printPretty(syncExprBuf, nullptr, PrintingPolicy(LangOpts));
1702 syncBuf += syncExprBuf.str();
1703 syncBuf += ");";
1704
1705 buf += syncBuf;
1706 buf += "\n if (_rethrow) objc_exception_throw(_rethrow);\n";
1707 buf += "}\n";
1708 buf += "}";
1709
1710 ReplaceText(lastCurlyLoc, 1, buf);
1711
1712 bool hasReturns = false;
1713 HasReturnStmts(S->getSynchBody(), hasReturns);
1714 if (hasReturns)
1715 RewriteSyncReturnStmts(S->getSynchBody(), syncBuf);
1716
1717 return nullptr;
1718 }
1719
1720 void RewriteObjC::WarnAboutReturnGotoStmts(Stmt *S)
1721 {
1722 // Perform a bottom up traversal of all children.
1723 for (Stmt *SubStmt : S->children())
1724 if (SubStmt)
1725 WarnAboutReturnGotoStmts(SubStmt);
1726
1727 if (isa<ReturnStmt>(S) || isa<GotoStmt>(S)) {
1728 Diags.Report(Context->getFullLoc(S->getBeginLoc()),
1729 TryFinallyContainsReturnDiag);
1730 }
1731 }
1732
1733 void RewriteObjC::HasReturnStmts(Stmt *S, bool &hasReturns)
1734 {
1735 // Perform a bottom up traversal of all children.
1736 for (Stmt *SubStmt : S->children())
1737 if (SubStmt)
1738 HasReturnStmts(SubStmt, hasReturns);
1739
1740 if (isa<ReturnStmt>(S))
1741 hasReturns = true;
1742 }
1743
1744 void RewriteObjC::RewriteTryReturnStmts(Stmt *S) {
1745 // Perform a bottom up traversal of all children.
1746 for (Stmt *SubStmt : S->children())
1747 if (SubStmt) {
1748 RewriteTryReturnStmts(SubStmt);
1749 }
1750 if (isa<ReturnStmt>(S)) {
1751 SourceLocation startLoc = S->getBeginLoc();
1752 const char *startBuf = SM->getCharacterData(startLoc);
1753 const char *semiBuf = strchr(startBuf, ';');
1754 assert((*semiBuf == ';') && "RewriteTryReturnStmts: can't find ';'");
1755 SourceLocation onePastSemiLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1);
1756
1757 std::string buf;
1758 buf = "{ objc_exception_try_exit(&_stack); return";
1759
1760 ReplaceText(startLoc, 6, buf);
1761 InsertText(onePastSemiLoc, "}");
1762 }
1763 }
1764
1765 void RewriteObjC::RewriteSyncReturnStmts(Stmt *S, std::string syncExitBuf) {
1766 // Perform a bottom up traversal of all children.
1767 for (Stmt *SubStmt : S->children())
1768 if (SubStmt) {
1769 RewriteSyncReturnStmts(SubStmt, syncExitBuf);
1770 }
1771 if (isa<ReturnStmt>(S)) {
1772 SourceLocation startLoc = S->getBeginLoc();
1773 const char *startBuf = SM->getCharacterData(startLoc);
1774
1775 const char *semiBuf = strchr(startBuf, ';');
1776 assert((*semiBuf == ';') && "RewriteSyncReturnStmts: can't find ';'");
1777 SourceLocation onePastSemiLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1);
1778
1779 std::string buf;
1780 buf = "{ objc_exception_try_exit(&_stack);";
1781 buf += syncExitBuf;
1782 buf += " return";
1783
1784 ReplaceText(startLoc, 6, buf);
1785 InsertText(onePastSemiLoc, "}");
1786 }
1787 }
1788
1789 Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
1790 // Get the start location and compute the semi location.
1791 SourceLocation startLoc = S->getBeginLoc();
1792 const char *startBuf = SM->getCharacterData(startLoc);
1793
1794 assert((*startBuf == '@') && "bogus @try location");
1795
1796 std::string buf;
1797 // declare a new scope with two variables, _stack and _rethrow.
1798 buf = "/* @try scope begin */ { struct _objc_exception_data {\n";
1799 buf += "int buf[18/*32-bit i386*/];\n";
1800 buf += "char *pointers[4];} _stack;\n";
1801 buf += "id volatile _rethrow = 0;\n";
1802 buf += "objc_exception_try_enter(&_stack);\n";
1803 buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
1804
1805 ReplaceText(startLoc, 4, buf);
1806
1807 startLoc = S->getTryBody()->getEndLoc();
1808 startBuf = SM->getCharacterData(startLoc);
1809
1810 assert((*startBuf == '}') && "bogus @try block");
1811
1812 SourceLocation lastCurlyLoc = startLoc;
1813 if (S->getNumCatchStmts()) {
1814 startLoc = startLoc.getLocWithOffset(1);
1815 buf = " /* @catch begin */ else {\n";
1816 buf += " id _caught = objc_exception_extract(&_stack);\n";
1817 buf += " objc_exception_try_enter (&_stack);\n";
1818 buf += " if (_setjmp(_stack.buf))\n";
1819 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1820 buf += " else { /* @catch continue */";
1821
1822 InsertText(startLoc, buf);
1823 } else { /* no catch list */
1824 buf = "}\nelse {\n";
1825 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1826 buf += "}";
1827 ReplaceText(lastCurlyLoc, 1, buf);
1828 }
1829 Stmt *lastCatchBody = nullptr;
1830 for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
1831 ObjCAtCatchStmt *Catch = S->getCatchStmt(I);
1832 VarDecl *catchDecl = Catch->getCatchParamDecl();
1833
1834 if (I == 0)
1835 buf = "if ("; // we are generating code for the first catch clause
1836 else
1837 buf = "else if (";
1838 startLoc = Catch->getBeginLoc();
1839 startBuf = SM->getCharacterData(startLoc);
1840
1841 assert((*startBuf == '@') && "bogus @catch location");
1842
1843 const char *lParenLoc = strchr(startBuf, '(');
1844
1845 if (Catch->hasEllipsis()) {
1846 // Now rewrite the body...
1847 lastCatchBody = Catch->getCatchBody();
1848 SourceLocation bodyLoc = lastCatchBody->getBeginLoc();
1849 const char *bodyBuf = SM->getCharacterData(bodyLoc);
1850 assert(*SM->getCharacterData(Catch->getRParenLoc()) == ')' &&
1851 "bogus @catch paren location");
1852 assert((*bodyBuf == '{') && "bogus @catch body location");
1853
1854 buf += "1) { id _tmp = _caught;";
1855 Rewrite.ReplaceText(startLoc, bodyBuf-startBuf+1, buf);
1856 } else if (catchDecl) {
1857 QualType t = catchDecl->getType();
1858 if (t == Context->getObjCIdType()) {
1859 buf += "1) { ";
1860 ReplaceText(startLoc, lParenLoc-startBuf+1, buf);
1861 } else if (const ObjCObjectPointerType *Ptr =
1862 t->getAs<ObjCObjectPointerType>()) {
1863 // Should be a pointer to a class.
1864 ObjCInterfaceDecl *IDecl = Ptr->getObjectType()->getInterface();
1865 if (IDecl) {
1866 buf += "objc_exception_match((struct objc_class *)objc_getClass(\"";
1867 buf += IDecl->getNameAsString();
1868 buf += "\"), (struct objc_object *)_caught)) { ";
1869 ReplaceText(startLoc, lParenLoc-startBuf+1, buf);
1870 }
1871 }
1872 // Now rewrite the body...
1873 lastCatchBody = Catch->getCatchBody();
1874 SourceLocation rParenLoc = Catch->getRParenLoc();
1875 SourceLocation bodyLoc = lastCatchBody->getBeginLoc();
1876 const char *bodyBuf = SM->getCharacterData(bodyLoc);
1877 const char *rParenBuf = SM->getCharacterData(rParenLoc);
1878 assert((*rParenBuf == ')') && "bogus @catch paren location");
1879 assert((*bodyBuf == '{') && "bogus @catch body location");
1880
1881 // Here we replace ") {" with "= _caught;" (which initializes and
1882 // declares the @catch parameter).
1883 ReplaceText(rParenLoc, bodyBuf-rParenBuf+1, " = _caught;");
1884 } else {
1885 llvm_unreachable("@catch rewrite bug");
1886 }
1887 }
1888 // Complete the catch list...
1889 if (lastCatchBody) {
1890 SourceLocation bodyLoc = lastCatchBody->getEndLoc();
1891 assert(*SM->getCharacterData(bodyLoc) == '}' &&
1892 "bogus @catch body location");
1893
1894 // Insert the last (implicit) else clause *before* the right curly brace.
1895 bodyLoc = bodyLoc.getLocWithOffset(-1);
1896 buf = "} /* last catch end */\n";
1897 buf += "else {\n";
1898 buf += " _rethrow = _caught;\n";
1899 buf += " objc_exception_try_exit(&_stack);\n";
1900 buf += "} } /* @catch end */\n";
1901 if (!S->getFinallyStmt())
1902 buf += "}\n";
1903 InsertText(bodyLoc, buf);
1904
1905 // Set lastCurlyLoc
1906 lastCurlyLoc = lastCatchBody->getEndLoc();
1907 }
1908 if (ObjCAtFinallyStmt *finalStmt = S->getFinallyStmt()) {
1909 startLoc = finalStmt->getBeginLoc();
1910 startBuf = SM->getCharacterData(startLoc);
1911 assert((*startBuf == '@') && "bogus @finally start");
1912
1913 ReplaceText(startLoc, 8, "/* @finally */");
1914
1915 Stmt *body = finalStmt->getFinallyBody();
1916 SourceLocation startLoc = body->getBeginLoc();
1917 SourceLocation endLoc = body->getEndLoc();
1918 assert(*SM->getCharacterData(startLoc) == '{' &&
1919 "bogus @finally body location");
1920 assert(*SM->getCharacterData(endLoc) == '}' &&
1921 "bogus @finally body location");
1922
1923 startLoc = startLoc.getLocWithOffset(1);
1924 InsertText(startLoc, " if (!_rethrow) objc_exception_try_exit(&_stack);\n");
1925 endLoc = endLoc.getLocWithOffset(-1);
1926 InsertText(endLoc, " if (_rethrow) objc_exception_throw(_rethrow);\n");
1927
1928 // Set lastCurlyLoc
1929 lastCurlyLoc = body->getEndLoc();
1930
1931 // Now check for any return/continue/go statements within the @try.
1932 WarnAboutReturnGotoStmts(S->getTryBody());
1933 } else { /* no finally clause - make sure we synthesize an implicit one */
1934 buf = "{ /* implicit finally clause */\n";
1935 buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
1936 buf += " if (_rethrow) objc_exception_throw(_rethrow);\n";
1937 buf += "}";
1938 ReplaceText(lastCurlyLoc, 1, buf);
1939
1940 // Now check for any return/continue/go statements within the @try.
1941 // The implicit finally clause won't called if the @try contains any
1942 // jump statements.
1943 bool hasReturns = false;
1944 HasReturnStmts(S->getTryBody(), hasReturns);
1945 if (hasReturns)
1946 RewriteTryReturnStmts(S->getTryBody());
1947 }
1948 // Now emit the final closing curly brace...
1949 lastCurlyLoc = lastCurlyLoc.getLocWithOffset(1);
1950 InsertText(lastCurlyLoc, " } /* @try scope end */\n");
1951 return nullptr;
1952 }
1953
1954 // This can't be done with ReplaceStmt(S, ThrowExpr), since
1955 // the throw expression is typically a message expression that's already
1956 // been rewritten! (which implies the SourceLocation's are invalid).
1957 Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
1958 // Get the start location and compute the semi location.
1959 SourceLocation startLoc = S->getBeginLoc();
1960 const char *startBuf = SM->getCharacterData(startLoc);
1961
1962 assert((*startBuf == '@') && "bogus @throw location");
1963
1964 std::string buf;
1965 /* void objc_exception_throw(id) __attribute__((noreturn)); */
1966 if (S->getThrowExpr())
1967 buf = "objc_exception_throw(";
1968 else // add an implicit argument
1969 buf = "objc_exception_throw(_caught";
1970
1971 // handle "@ throw" correctly.
1972 const char *wBuf = strchr(startBuf, 'w');
1973 assert((*wBuf == 'w') && "@throw: can't find 'w'");
1974 ReplaceText(startLoc, wBuf-startBuf+1, buf);
1975
1976 const char *semiBuf = strchr(startBuf, ';');
1977 assert((*semiBuf == ';') && "@throw: can't find ';'");
1978 SourceLocation semiLoc = startLoc.getLocWithOffset(semiBuf-startBuf);
1979 ReplaceText(semiLoc, 1, ");");
1980 return nullptr;
1981 }
1982
1983 Stmt *RewriteObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
1984 // Create a new string expression.
1985 std::string StrEncoding;
1986 Context->getObjCEncodingForType(Exp->getEncodedType(), StrEncoding);
1987 Expr *Replacement = getStringLiteral(StrEncoding);
1988 ReplaceStmt(Exp, Replacement);
1989
1990 // Replace this subexpr in the parent.
1991 // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
1992 return Replacement;
1993 }
1994
1995 Stmt *RewriteObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
1996 if (!SelGetUidFunctionDecl)
1997 SynthSelGetUidFunctionDecl();
1998 assert(SelGetUidFunctionDecl && "Can't find sel_registerName() decl");
1999 // Create a call to sel_registerName("selName").
2000 SmallVector<Expr*, 8> SelExprs;
2001 SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString()));
2002 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2003 SelExprs);
2004 ReplaceStmt(Exp, SelExp);
2005 // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
2006 return SelExp;
2007 }
2008
2009 CallExpr *
2010 RewriteObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
2011 ArrayRef<Expr *> Args,
2012 SourceLocation StartLoc,
2013 SourceLocation EndLoc) {
2014 // Get the type, we will need to reference it in a couple spots.
2015 QualType msgSendType = FD->getType();
2016
2017 // Create a reference to the objc_msgSend() declaration.
2018 DeclRefExpr *DRE = new (Context) DeclRefExpr(*Context, FD, false, msgSendType,
2019 VK_LValue, SourceLocation());
2020
2021 // Now, we cast the reference to a pointer to the objc_msgSend type.
2022 QualType pToFunc = Context->getPointerType(msgSendType);
2023 ImplicitCastExpr *ICE =
2024 ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
2025 DRE, nullptr, VK_RValue);
2026
2027 const auto *FT = msgSendType->castAs<FunctionType>();
2028
2029 CallExpr *Exp = CallExpr::Create(
2030 *Context, ICE, Args, FT->getCallResultType(*Context), VK_RValue, EndLoc);
2031 return Exp;
2032 }
2033
2034 static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
2035 const char *&startRef, const char *&endRef) {
2036 while (startBuf < endBuf) {
2037 if (*startBuf == '<')
2038 startRef = startBuf; // mark the start.
2039 if (*startBuf == '>') {
2040 if (startRef && *startRef == '<') {
2041 endRef = startBuf; // mark the end.
2042 return true;
2043 }
2044 return false;
2045 }
2046 startBuf++;
2047 }
2048 return false;
2049 }
2050
2051 static void scanToNextArgument(const char *&argRef) {
2052 int angle = 0;
2053 while (*argRef != ')' && (*argRef != ',' || angle > 0)) {
2054 if (*argRef == '<')
2055 angle++;
2056 else if (*argRef == '>')
2057 angle--;
2058 argRef++;
2059 }
2060 assert(angle == 0 && "scanToNextArgument - bad protocol type syntax");
2061 }
2062
2063 bool RewriteObjC::needToScanForQualifiers(QualType T) {
2064 if (T->isObjCQualifiedIdType())
2065 return true;
2066 if (const PointerType *PT = T->getAs<PointerType>()) {
2067 if (PT->getPointeeType()->isObjCQualifiedIdType())
2068 return true;
2069 }
2070 if (T->isObjCObjectPointerType()) {
2071 T = T->getPointeeType();
2072 return T->isObjCQualifiedInterfaceType();
2073 }
2074 if (T->isArrayType()) {
2075 QualType ElemTy = Context->getBaseElementType(T);
2076 return needToScanForQualifiers(ElemTy);
2077 }
2078 return false;
2079 }
2080
2081 void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
2082 QualType Type = E->getType();
2083 if (needToScanForQualifiers(Type)) {
2084 SourceLocation Loc, EndLoc;
2085
2086 if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) {
2087 Loc = ECE->getLParenLoc();
2088 EndLoc = ECE->getRParenLoc();
2089 } else {
2090 Loc = E->getBeginLoc();
2091 EndLoc = E->getEndLoc();
2092 }
2093 // This will defend against trying to rewrite synthesized expressions.
2094 if (Loc.isInvalid() || EndLoc.isInvalid())
2095 return;
2096
2097 const char *startBuf = SM->getCharacterData(Loc);
2098 const char *endBuf = SM->getCharacterData(EndLoc);
2099 const char *startRef = nullptr, *endRef = nullptr;
2100 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
2101 // Get the locations of the startRef, endRef.
2102 SourceLocation LessLoc = Loc.getLocWithOffset(startRef-startBuf);
2103 SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-startBuf+1);
2104 // Comment out the protocol references.
2105 InsertText(LessLoc, "/*");
2106 InsertText(GreaterLoc, "*/");
2107 }
2108 }
2109 }
2110
2111 void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) {
2112 SourceLocation Loc;
2113 QualType Type;
2114 const FunctionProtoType *proto = nullptr;
2115 if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) {
2116 Loc = VD->getLocation();
2117 Type = VD->getType();
2118 }
2119 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Dcl)) {
2120 Loc = FD->getLocation();
2121 // Check for ObjC 'id' and class types that have been adorned with protocol
2122 // information (id<p>, C<p>*). The protocol references need to be rewritten!
2123 const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
2124 assert(funcType && "missing function type");
2125 proto = dyn_cast<FunctionProtoType>(funcType);
2126 if (!proto)
2127 return;
2128 Type = proto->getReturnType();
2129 }
2130 else if (FieldDecl *FD = dyn_cast<FieldDecl>(Dcl)) {
2131 Loc = FD->getLocation();
2132 Type = FD->getType();
2133 }
2134 else
2135 return;
2136
2137 if (needToScanForQualifiers(Type)) {
2138 // Since types are unique, we need to scan the buffer.
2139
2140 const char *endBuf = SM->getCharacterData(Loc);
2141 const char *startBuf = endBuf;
2142 while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart)
2143 startBuf--; // scan backward (from the decl location) for return type.
2144 const char *startRef = nullptr, *endRef = nullptr;
2145 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
2146 // Get the locations of the startRef, endRef.
2147 SourceLocation LessLoc = Loc.getLocWithOffset(startRef-endBuf);
2148 SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-endBuf+1);
2149 // Comment out the protocol references.
2150 InsertText(LessLoc, "/*");
2151 InsertText(GreaterLoc, "*/");
2152 }
2153 }
2154 if (!proto)
2155 return; // most likely, was a variable
2156 // Now check arguments.
2157 const char *startBuf = SM->getCharacterData(Loc);
2158 const char *startFuncBuf = startBuf;
2159 for (unsigned i = 0; i < proto->getNumParams(); i++) {
2160 if (needToScanForQualifiers(proto->getParamType(i))) {
2161 // Since types are unique, we need to scan the buffer.
2162
2163 const char *endBuf = startBuf;
2164 // scan forward (from the decl location) for argument types.
2165 scanToNextArgument(endBuf);
2166 const char *startRef = nullptr, *endRef = nullptr;
2167 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
2168 // Get the locations of the startRef, endRef.
2169 SourceLocation LessLoc =
2170 Loc.getLocWithOffset(startRef-startFuncBuf);
2171 SourceLocation GreaterLoc =
2172 Loc.getLocWithOffset(endRef-startFuncBuf+1);
2173 // Comment out the protocol references.
2174 InsertText(LessLoc, "/*");
2175 InsertText(GreaterLoc, "*/");
2176 }
2177 startBuf = ++endBuf;
2178 }
2179 else {
2180 // If the function name is derived from a macro expansion, then the
2181 // argument buffer will not follow the name. Need to speak with Chris.
2182 while (*startBuf && *startBuf != ')' && *startBuf != ',')
2183 startBuf++; // scan forward (from the decl location) for argument types.
2184 startBuf++;
2185 }
2186 }
2187 }
2188
2189 void RewriteObjC::RewriteTypeOfDecl(VarDecl *ND) {
2190 QualType QT = ND->getType();
2191 const Type* TypePtr = QT->getAs<Type>();
2192 if (!isa<TypeOfExprType>(TypePtr))
2193 return;
2194 while (isa<TypeOfExprType>(TypePtr)) {
2195 const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
2196 QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType();
2197 TypePtr = QT->getAs<Type>();
2198 }
2199 // FIXME. This will not work for multiple declarators; as in:
2200 // __typeof__(a) b,c,d;
2201 std::string TypeAsString(QT.getAsString(Context->getPrintingPolicy()));
2202 SourceLocation DeclLoc = ND->getTypeSpecStartLoc();
2203 const char *startBuf = SM->getCharacterData(DeclLoc);
2204 if (ND->getInit()) {
2205 std::string Name(ND->getNameAsString());
2206 TypeAsString += " " + Name + " = ";
2207 Expr *E = ND->getInit();
2208 SourceLocation startLoc;
2209 if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E))
2210 startLoc = ECE->getLParenLoc();
2211 else
2212 startLoc = E->getBeginLoc();
2213 startLoc = SM->getExpansionLoc(startLoc);
2214 const char *endBuf = SM->getCharacterData(startLoc);
2215 ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString);
2216 }
2217 else {
2218 SourceLocation X = ND->getEndLoc();
2219 X = SM->getExpansionLoc(X);
2220 const char *endBuf = SM->getCharacterData(X);
2221 ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString);
2222 }
2223 }
2224
2225 // SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
2226 void RewriteObjC::SynthSelGetUidFunctionDecl() {
2227 IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
2228 SmallVector<QualType, 16> ArgTys;
2229 ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2230 QualType getFuncType =
2231 getSimpleFunctionType(Context->getObjCSelType(), ArgTys);
2232 SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2233 SourceLocation(),
2234 SourceLocation(),
2235 SelGetUidIdent, getFuncType,
2236 nullptr, SC_Extern);
2237 }
2238
2239 void RewriteObjC::RewriteFunctionDecl(FunctionDecl *FD) {
2240 // declared in <objc/objc.h>
2241 if (FD->getIdentifier() &&
2242 FD->getName() == "sel_registerName") {
2243 SelGetUidFunctionDecl = FD;
2244 return;
2245 }
2246 RewriteObjCQualifiedInterfaceTypes(FD);
2247 }
2248
2249 void RewriteObjC::RewriteBlockPointerType(std::string& Str, QualType Type) {
2250 std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
2251 const char *argPtr = TypeString.c_str();
2252 if (!strchr(argPtr, '^')) {
2253 Str += TypeString;
2254 return;
2255 }
2256 while (*argPtr) {
2257 Str += (*argPtr == '^' ? '*' : *argPtr);
2258 argPtr++;
2259 }
2260 }
2261
2262 // FIXME. Consolidate this routine with RewriteBlockPointerType.
2263 void RewriteObjC::RewriteBlockPointerTypeVariable(std::string& Str,
2264 ValueDecl *VD) {
2265 QualType Type = VD->getType();
2266 std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
2267 const char *argPtr = TypeString.c_str();
2268 int paren = 0;
2269 while (*argPtr) {
2270 switch (*argPtr) {
2271 case '(':
2272 Str += *argPtr;
2273 paren++;
2274 break;
2275 case ')':
2276 Str += *argPtr;
2277 paren--;
2278 break;
2279 case '^':
2280 Str += '*';
2281 if (paren == 1)
2282 Str += VD->getNameAsString();
2283 break;
2284 default:
2285 Str += *argPtr;
2286 break;
2287 }
2288 argPtr++;
2289 }
2290 }
2291
2292 void RewriteObjC::RewriteBlockLiteralFunctionDecl(FunctionDecl *FD) {
2293 SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
2294 const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
2295 const FunctionProtoType *proto = dyn_cast_or_null<FunctionProtoType>(funcType);
2296 if (!proto)
2297 return;
2298 QualType Type = proto->getReturnType();
2299 std::string FdStr = Type.getAsString(Context->getPrintingPolicy());
2300 FdStr += " ";
2301 FdStr += FD->getName();
2302 FdStr += "(";
2303 unsigned numArgs = proto->getNumParams();
2304 for (unsigned i = 0; i < numArgs; i++) {
2305 QualType ArgType = proto->getParamType(i);
2306 RewriteBlockPointerType(FdStr, ArgType);
2307 if (i+1 < numArgs)
2308 FdStr += ", ";
2309 }
2310 FdStr += ");\n";
2311 InsertText(FunLocStart, FdStr);
2312 CurFunctionDeclToDeclareForBlock = nullptr;
2313 }
2314
2315 // SynthSuperConstructorFunctionDecl - id objc_super(id obj, id super);
2316 void RewriteObjC::SynthSuperConstructorFunctionDecl() {
2317 if (SuperConstructorFunctionDecl)
2318 return;
2319 IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super");
2320 SmallVector<QualType, 16> ArgTys;
2321 QualType argT = Context->getObjCIdType();
2322 assert(!argT.isNull() && "Can't find 'id' type");
2323 ArgTys.push_back(argT);
2324 ArgTys.push_back(argT);
2325 QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2326 ArgTys);
2327 SuperConstructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2328 SourceLocation(),
2329 SourceLocation(),
2330 msgSendIdent, msgSendType,
2331 nullptr, SC_Extern);
2332 }
2333
2334 // SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
2335 void RewriteObjC::SynthMsgSendFunctionDecl() {
2336 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
2337 SmallVector<QualType, 16> ArgTys;
2338 QualType argT = Context->getObjCIdType();
2339 assert(!argT.isNull() && "Can't find 'id' type");
2340 ArgTys.push_back(argT);
2341 argT = Context->getObjCSelType();
2342 assert(!argT.isNull() && "Can't find 'SEL' type");
2343 ArgTys.push_back(argT);
2344 QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2345 ArgTys, /*variadic=*/true);
2346 MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2347 SourceLocation(),
2348 SourceLocation(),
2349 msgSendIdent, msgSendType,
2350 nullptr, SC_Extern);
2351 }
2352
2353 // SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(struct objc_super *, SEL op, ...);
2354 void RewriteObjC::SynthMsgSendSuperFunctionDecl() {
2355 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
2356 SmallVector<QualType, 16> ArgTys;
2357 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2358 SourceLocation(), SourceLocation(),
2359 &Context->Idents.get("objc_super"));
2360 QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
2361 assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
2362 ArgTys.push_back(argT);
2363 argT = Context->getObjCSelType();
2364 assert(!argT.isNull() && "Can't find 'SEL' type");
2365 ArgTys.push_back(argT);
2366 QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2367 ArgTys, /*variadic=*/true);
2368 MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2369 SourceLocation(),
2370 SourceLocation(),
2371 msgSendIdent, msgSendType,
2372 nullptr, SC_Extern);
2373 }
2374
2375 // SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
2376 void RewriteObjC::SynthMsgSendStretFunctionDecl() {
2377 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
2378 SmallVector<QualType, 16> ArgTys;
2379 QualType argT = Context->getObjCIdType();
2380 assert(!argT.isNull() && "Can't find 'id' type");
2381 ArgTys.push_back(argT);
2382 argT = Context->getObjCSelType();
2383 assert(!argT.isNull() && "Can't find 'SEL' type");
2384 ArgTys.push_back(argT);
2385 QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2386 ArgTys, /*variadic=*/true);
2387 MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2388 SourceLocation(),
2389 SourceLocation(),
2390 msgSendIdent, msgSendType,
2391 nullptr, SC_Extern);
2392 }
2393
2394 // SynthMsgSendSuperStretFunctionDecl -
2395 // id objc_msgSendSuper_stret(struct objc_super *, SEL op, ...);
2396 void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() {
2397 IdentifierInfo *msgSendIdent =
2398 &Context->Idents.get("objc_msgSendSuper_stret");
2399 SmallVector<QualType, 16> ArgTys;
2400 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2401 SourceLocation(), SourceLocation(),
2402 &Context->Idents.get("objc_super"));
2403 QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
2404 assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
2405 ArgTys.push_back(argT);
2406 argT = Context->getObjCSelType();
2407 assert(!argT.isNull() && "Can't find 'SEL' type");
2408 ArgTys.push_back(argT);
2409 QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
2410 ArgTys, /*variadic=*/true);
2411 MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2412 SourceLocation(),
2413 SourceLocation(),
2414 msgSendIdent,
2415 msgSendType, nullptr,
2416 SC_Extern);
2417 }
2418
2419 // SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
2420 void RewriteObjC::SynthMsgSendFpretFunctionDecl() {
2421 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
2422 SmallVector<QualType, 16> ArgTys;
2423 QualType argT = Context->getObjCIdType();
2424 assert(!argT.isNull() && "Can't find 'id' type");
2425 ArgTys.push_back(argT);
2426 argT = Context->getObjCSelType();
2427 assert(!argT.isNull() && "Can't find 'SEL' type");
2428 ArgTys.push_back(argT);
2429 QualType msgSendType = getSimpleFunctionType(Context->DoubleTy,
2430 ArgTys, /*variadic=*/true);
2431 MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2432 SourceLocation(),
2433 SourceLocation(),
2434 msgSendIdent, msgSendType,
2435 nullptr, SC_Extern);
2436 }
2437
2438 // SynthGetClassFunctionDecl - id objc_getClass(const char *name);
2439 void RewriteObjC::SynthGetClassFunctionDecl() {
2440 IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
2441 SmallVector<QualType, 16> ArgTys;
2442 ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2443 QualType getClassType = getSimpleFunctionType(Context->getObjCIdType(),
2444 ArgTys);
2445 GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2446 SourceLocation(),
2447 SourceLocation(),
2448 getClassIdent, getClassType,
2449 nullptr, SC_Extern);
2450 }
2451
2452 // SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
2453 void RewriteObjC::SynthGetSuperClassFunctionDecl() {
2454 IdentifierInfo *getSuperClassIdent =
2455 &Context->Idents.get("class_getSuperclass");
2456 SmallVector<QualType, 16> ArgTys;
2457 ArgTys.push_back(Context->getObjCClassType());
2458 QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
2459 ArgTys);
2460 GetSuperClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2461 SourceLocation(),
2462 SourceLocation(),
2463 getSuperClassIdent,
2464 getClassType, nullptr,
2465 SC_Extern);
2466 }
2467
2468 // SynthGetMetaClassFunctionDecl - id objc_getMetaClass(const char *name);
2469 void RewriteObjC::SynthGetMetaClassFunctionDecl() {
2470 IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
2471 SmallVector<QualType, 16> ArgTys;
2472 ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
2473 QualType getClassType = getSimpleFunctionType(Context->getObjCIdType(),
2474 ArgTys);
2475 GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
2476 SourceLocation(),
2477 SourceLocation(),
2478 getClassIdent, getClassType,
2479 nullptr, SC_Extern);
2480 }
2481
2482 Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
2483 assert(Exp != nullptr && "Expected non-null ObjCStringLiteral");
2484 QualType strType = getConstantStringStructType();
2485
2486 std::string S = "__NSConstantStringImpl_";
2487
2488 std::string tmpName = InFileName;
2489 unsigned i;
2490 for (i=0; i < tmpName.length(); i++) {
2491 char c = tmpName.at(i);
2492 // replace any non-alphanumeric characters with '_'.
2493 if (!isAlphanumeric(c))
2494 tmpName[i] = '_';
2495 }
2496 S += tmpName;
2497 S += "_";
2498 S += utostr(NumObjCStringLiterals++);
2499
2500 Preamble += "static __NSConstantStringImpl " + S;
2501 Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
2502 Preamble += "0x000007c8,"; // utf8_str
2503 // The pretty printer for StringLiteral handles escape characters properly.
2504 std::string prettyBufS;
2505 llvm::raw_string_ostream prettyBuf(prettyBufS);
2506 Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts));
2507 Preamble += prettyBuf.str();
2508 Preamble += ",";
2509 Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";
2510
2511 VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
2512 SourceLocation(), &Context->Idents.get(S),
2513 strType, nullptr, SC_Static);
2514 DeclRefExpr *DRE = new (Context)
2515 DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
2516 Expr *Unop = new (Context)
2517 UnaryOperator(DRE, UO_AddrOf, Context->getPointerType(DRE->getType()),
2518 VK_RValue, OK_Ordinary, SourceLocation(), false);
2519 // cast to NSConstantString *
2520 CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
2521 CK_CPointerToObjCPointerCast, Unop);
2522 ReplaceStmt(Exp, cast);
2523 // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
2524 return cast;
2525 }
2526
2527 // struct objc_super { struct objc_object *receiver; struct objc_class *super; };
2528 QualType RewriteObjC::getSuperStructType() {
2529 if (!SuperStructDecl) {
2530 SuperStructDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2531 SourceLocation(), SourceLocation(),
2532 &Context->Idents.get("objc_super"));
2533 QualType FieldTypes[2];
2534
2535 // struct objc_object *receiver;
2536 FieldTypes[0] = Context->getObjCIdType();
2537 // struct objc_class *super;
2538 FieldTypes[1] = Context->getObjCClassType();
2539
2540 // Create fields
2541 for (unsigned i = 0; i < 2; ++i) {
2542 SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl,
2543 SourceLocation(),
2544 SourceLocation(), nullptr,
2545 FieldTypes[i], nullptr,
2546 /*BitWidth=*/nullptr,
2547 /*Mutable=*/false,
2548 ICIS_NoInit));
2549 }
2550
2551 SuperStructDecl->completeDefinition();
2552 }
2553 return Context->getTagDeclType(SuperStructDecl);
2554 }
2555
2556 QualType RewriteObjC::getConstantStringStructType() {
2557 if (!ConstantStringDecl) {
2558 ConstantStringDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
2559 SourceLocation(), SourceLocation(),
2560 &Context->Idents.get("__NSConstantStringImpl"));
2561 QualType FieldTypes[4];
2562
2563 // struct objc_object *receiver;
2564 FieldTypes[0] = Context->getObjCIdType();
2565 // int flags;
2566 FieldTypes[1] = Context->IntTy;
2567 // char *str;
2568 FieldTypes[2] = Context->getPointerType(Context->CharTy);
2569 // long length;
2570 FieldTypes[3] = Context->LongTy;
2571
2572 // Create fields
2573 for (unsigned i = 0; i < 4; ++i) {
2574 ConstantStringDecl->addDecl(FieldDecl::Create(*Context,
2575 ConstantStringDecl,
2576 SourceLocation(),
2577 SourceLocation(), nullptr,
2578 FieldTypes[i], nullptr,
2579 /*BitWidth=*/nullptr,
2580 /*Mutable=*/true,
2581 ICIS_NoInit));
2582 }
2583
2584 ConstantStringDecl->completeDefinition();
2585 }
2586 return Context->getTagDeclType(ConstantStringDecl);
2587 }
2588
2589 CallExpr *RewriteObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
2590 QualType msgSendType,
2591 QualType returnType,
2592 SmallVectorImpl<QualType> &ArgTypes,
2593 SmallVectorImpl<Expr*> &MsgExprs,
2594 ObjCMethodDecl *Method) {
2595 // Create a reference to the objc_msgSend_stret() declaration.
2596 DeclRefExpr *STDRE =
2597 new (Context) DeclRefExpr(*Context, MsgSendStretFlavor, false,
2598 msgSendType, VK_LValue, SourceLocation());
2599 // Need to cast objc_msgSend_stret to "void *" (see above comment).
2600 CastExpr *cast = NoTypeInfoCStyleCastExpr(Context,
2601 Context->getPointerType(Context->VoidTy),
2602 CK_BitCast, STDRE);
2603 // Now do the "normal" pointer to function cast.
2604 QualType castType = getSimpleFunctionType(returnType, ArgTypes,
2605 Method ? Method->isVariadic()
2606 : false);
2607 castType = Context->getPointerType(castType);
2608 cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2609 cast);
2610
2611 // Don't forget the parens to enforce the proper binding.
2612 ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast);
2613
2614 const auto *FT = msgSendType->castAs<FunctionType>();
2615 CallExpr *STCE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2616 VK_RValue, SourceLocation());
2617 return STCE;
2618 }
2619
2620 Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
2621 SourceLocation StartLoc,
2622 SourceLocation EndLoc) {
2623 if (!SelGetUidFunctionDecl)
2624 SynthSelGetUidFunctionDecl();
2625 if (!MsgSendFunctionDecl)
2626 SynthMsgSendFunctionDecl();
2627 if (!MsgSendSuperFunctionDecl)
2628 SynthMsgSendSuperFunctionDecl();
2629 if (!MsgSendStretFunctionDecl)
2630 SynthMsgSendStretFunctionDecl();
2631 if (!MsgSendSuperStretFunctionDecl)
2632 SynthMsgSendSuperStretFunctionDecl();
2633 if (!MsgSendFpretFunctionDecl)
2634 SynthMsgSendFpretFunctionDecl();
2635 if (!GetClassFunctionDecl)
2636 SynthGetClassFunctionDecl();
2637 if (!GetSuperClassFunctionDecl)
2638 SynthGetSuperClassFunctionDecl();
2639 if (!GetMetaClassFunctionDecl)
2640 SynthGetMetaClassFunctionDecl();
2641
2642 // default to objc_msgSend().
2643 FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2644 // May need to use objc_msgSend_stret() as well.
2645 FunctionDecl *MsgSendStretFlavor = nullptr;
2646 if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
2647 QualType resultType = mDecl->getReturnType();
2648 if (resultType->isRecordType())
2649 MsgSendStretFlavor = MsgSendStretFunctionDecl;
2650 else if (resultType->isRealFloatingType())
2651 MsgSendFlavor = MsgSendFpretFunctionDecl;
2652 }
2653
2654 // Synthesize a call to objc_msgSend().
2655 SmallVector<Expr*, 8> MsgExprs;
2656 switch (Exp->getReceiverKind()) {
2657 case ObjCMessageExpr::SuperClass: {
2658 MsgSendFlavor = MsgSendSuperFunctionDecl;
2659 if (MsgSendStretFlavor)
2660 MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
2661 assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
2662
2663 ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
2664
2665 SmallVector<Expr*, 4> InitExprs;
2666
2667 // set the receiver to self, the first argument to all methods.
2668 InitExprs.push_back(
2669 NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
2670 CK_BitCast,
2671 new (Context) DeclRefExpr(*Context,
2672 CurMethodDef->getSelfDecl(),
2673 false,
2674 Context->getObjCIdType(),
2675 VK_RValue,
2676 SourceLocation()))
2677 ); // set the 'receiver'.
2678
2679 // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
2680 SmallVector<Expr*, 8> ClsExprs;
2681 ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
2682 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
2683 ClsExprs, StartLoc, EndLoc);
2684 // (Class)objc_getClass("CurrentClass")
2685 CastExpr *ArgExpr = NoTypeInfoCStyleCastExpr(Context,
2686 Context->getObjCClassType(),
2687 CK_BitCast, Cls);
2688 ClsExprs.clear();
2689 ClsExprs.push_back(ArgExpr);
2690 Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
2691 StartLoc, EndLoc);
2692 // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
2693 // To turn off a warning, type-cast to 'id'
2694 InitExprs.push_back( // set 'super class', using class_getSuperclass().
2695 NoTypeInfoCStyleCastExpr(Context,
2696 Context->getObjCIdType(),
2697 CK_BitCast, Cls));
2698 // struct objc_super
2699 QualType superType = getSuperStructType();
2700 Expr *SuperRep;
2701
2702 if (LangOpts.MicrosoftExt) {
2703 SynthSuperConstructorFunctionDecl();
2704 // Simulate a constructor call...
2705 DeclRefExpr *DRE = new (Context)
2706 DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
2707 VK_LValue, SourceLocation());
2708 SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
2709 VK_LValue, SourceLocation());
2710 // The code for super is a little tricky to prevent collision with
2711 // the structure definition in the header. The rewriter has it's own
2712 // internal definition (__rw_objc_super) that is uses. This is why
2713 // we need the cast below. For example:
2714 // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
2715 //
2716 SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
2717 Context->getPointerType(SuperRep->getType()),
2718 VK_RValue, OK_Ordinary,
2719 SourceLocation(), false);
2720 SuperRep = NoTypeInfoCStyleCastExpr(Context,
2721 Context->getPointerType(superType),
2722 CK_BitCast, SuperRep);
2723 } else {
2724 // (struct objc_super) { <exprs from above> }
2725 InitListExpr *ILE =
2726 new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
2727 SourceLocation());
2728 TypeSourceInfo *superTInfo
2729 = Context->getTrivialTypeSourceInfo(superType);
2730 SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
2731 superType, VK_LValue,
2732 ILE, false);
2733 // struct objc_super *
2734 SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
2735 Context->getPointerType(SuperRep->getType()),
2736 VK_RValue, OK_Ordinary,
2737 SourceLocation(), false);
2738 }
2739 MsgExprs.push_back(SuperRep);
2740 break;
2741 }
2742
2743 case ObjCMessageExpr::Class: {
2744 SmallVector<Expr*, 8> ClsExprs;
2745 auto *Class =
2746 Exp->getClassReceiver()->castAs<ObjCObjectType>()->getInterface();
2747 IdentifierInfo *clsName = Class->getIdentifier();
2748 ClsExprs.push_back(getStringLiteral(clsName->getName()));
2749 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2750 StartLoc, EndLoc);
2751 MsgExprs.push_back(Cls);
2752 break;
2753 }
2754
2755 case ObjCMessageExpr::SuperInstance:{
2756 MsgSendFlavor = MsgSendSuperFunctionDecl;
2757 if (MsgSendStretFlavor)
2758 MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
2759 assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
2760 ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
2761 SmallVector<Expr*, 4> InitExprs;
2762
2763 InitExprs.push_back(
2764 NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
2765 CK_BitCast,
2766 new (Context) DeclRefExpr(*Context,
2767 CurMethodDef->getSelfDecl(),
2768 false,
2769 Context->getObjCIdType(),
2770 VK_RValue, SourceLocation()))
2771 ); // set the 'receiver'.
2772
2773 // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
2774 SmallVector<Expr*, 8> ClsExprs;
2775 ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
2776 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
2777 StartLoc, EndLoc);
2778 // (Class)objc_getClass("CurrentClass")
2779 CastExpr *ArgExpr = NoTypeInfoCStyleCastExpr(Context,
2780 Context->getObjCClassType(),
2781 CK_BitCast, Cls);
2782 ClsExprs.clear();
2783 ClsExprs.push_back(ArgExpr);
2784 Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
2785 StartLoc, EndLoc);
2786
2787 // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
2788 // To turn off a warning, type-cast to 'id'
2789 InitExprs.push_back(
2790 // set 'super class', using class_getSuperclass().
2791 NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
2792 CK_BitCast, Cls));
2793 // struct objc_super
2794 QualType superType = getSuperStructType();
2795 Expr *SuperRep;
2796
2797 if (LangOpts.MicrosoftExt) {
2798 SynthSuperConstructorFunctionDecl();
2799 // Simulate a constructor call...
2800 DeclRefExpr *DRE = new (Context)
2801 DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
2802 VK_LValue, SourceLocation());
2803 SuperRep = CallExpr::Create(*Context, DRE, InitExprs, superType,
2804 VK_LValue, SourceLocation());
2805 // The code for super is a little tricky to prevent collision with
2806 // the structure definition in the header. The rewriter has it's own
2807 // internal definition (__rw_objc_super) that is uses. This is why
2808 // we need the cast below. For example:
2809 // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
2810 //
2811 SuperRep = new (Context) UnaryOperator(SuperRep, UO_AddrOf,
2812 Context->getPointerType(SuperRep->getType()),
2813 VK_RValue, OK_Ordinary,
2814 SourceLocation(), false);
2815 SuperRep = NoTypeInfoCStyleCastExpr(Context,
2816 Context->getPointerType(superType),
2817 CK_BitCast, SuperRep);
2818 } else {
2819 // (struct objc_super) { <exprs from above> }
2820 InitListExpr *ILE =
2821 new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
2822 SourceLocation());
2823 TypeSourceInfo *superTInfo
2824 = Context->getTrivialTypeSourceInfo(superType);
2825 SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
2826 superType, VK_RValue, ILE,
2827 false);
2828 }
2829 MsgExprs.push_back(SuperRep);
2830 break;
2831 }
2832
2833 case ObjCMessageExpr::Instance: {
2834 // Remove all type-casts because it may contain objc-style types; e.g.
2835 // Foo<Proto> *.
2836 Expr *recExpr = Exp->getInstanceReceiver();
2837 while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr))
2838 recExpr = CE->getSubExpr();
2839 CastKind CK = recExpr->getType()->isObjCObjectPointerType()
2840 ? CK_BitCast : recExpr->getType()->isBlockPointerType()
2841 ? CK_BlockPointerToObjCPointerCast
2842 : CK_CPointerToObjCPointerCast;
2843
2844 recExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
2845 CK, recExpr);
2846 MsgExprs.push_back(recExpr);
2847 break;
2848 }
2849 }
2850
2851 // Create a call to sel_registerName("selName"), it will be the 2nd argument.
2852 SmallVector<Expr*, 8> SelExprs;
2853 SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString()));
2854 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2855 SelExprs, StartLoc, EndLoc);
2856 MsgExprs.push_back(SelExp);
2857
2858 // Now push any user supplied arguments.
2859 for (unsigned i = 0; i < Exp->getNumArgs(); i++) {
2860 Expr *userExpr = Exp->getArg(i);
2861 // Make all implicit casts explicit...ICE comes in handy:-)
2862 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) {
2863 // Reuse the ICE type, it is exactly what the doctor ordered.
2864 QualType type = ICE->getType();
2865 if (needToScanForQualifiers(type))
2866 type = Context->getObjCIdType();
2867 // Make sure we convert "type (^)(...)" to "type (*)(...)".
2868 (void)convertBlockPointerToFunctionPointer(type);
2869 const Expr *SubExpr = ICE->IgnoreParenImpCasts();
2870 CastKind CK;
2871 if (SubExpr->getType()->isIntegralType(*Context) &&
2872 type->isBooleanType()) {
2873 CK = CK_IntegralToBoolean;
2874 } else if (type->isObjCObjectPointerType()) {
2875 if (SubExpr->getType()->isBlockPointerType()) {
2876 CK = CK_BlockPointerToObjCPointerCast;
2877 } else if (SubExpr->getType()->isPointerType()) {
2878 CK = CK_CPointerToObjCPointerCast;
2879 } else {
2880 CK = CK_BitCast;
2881 }
2882 } else {
2883 CK = CK_BitCast;
2884 }
2885
2886 userExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, userExpr);
2887 }
2888 // Make id<P...> cast into an 'id' cast.
2889 else if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(userExpr)) {
2890 if (CE->getType()->isObjCQualifiedIdType()) {
2891 while ((CE = dyn_cast<CStyleCastExpr>(userExpr)))
2892 userExpr = CE->getSubExpr();
2893 CastKind CK;
2894 if (userExpr->getType()->isIntegralType(*Context)) {
2895 CK = CK_IntegralToPointer;
2896 } else if (userExpr->getType()->isBlockPointerType()) {
2897 CK = CK_BlockPointerToObjCPointerCast;
2898 } else if (userExpr->getType()->isPointerType()) {
2899 CK = CK_CPointerToObjCPointerCast;
2900 } else {
2901 CK = CK_BitCast;
2902 }
2903 userExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
2904 CK, userExpr);
2905 }
2906 }
2907 MsgExprs.push_back(userExpr);
2908 // We've transferred the ownership to MsgExprs. For now, we *don't* null
2909 // out the argument in the original expression (since we aren't deleting
2910 // the ObjCMessageExpr). See RewritePropertyOrImplicitSetter() usage for more info.
2911 //Exp->setArg(i, 0);
2912 }
2913 // Generate the funky cast.
2914 CastExpr *cast;
2915 SmallVector<QualType, 8> ArgTypes;
2916 QualType returnType;
2917
2918 // Push 'id' and 'SEL', the 2 implicit arguments.
2919 if (MsgSendFlavor == MsgSendSuperFunctionDecl)
2920 ArgTypes.push_back(Context->getPointerType(getSuperStructType()));
2921 else
2922 ArgTypes.push_back(Context->getObjCIdType());
2923 ArgTypes.push_back(Context->getObjCSelType());
2924 if (ObjCMethodDecl *OMD = Exp->getMethodDecl()) {
2925 // Push any user argument types.
2926 for (const auto *PI : OMD->parameters()) {
2927 QualType t = PI->getType()->isObjCQualifiedIdType()
2928 ? Context->getObjCIdType()
2929 : PI->getType();
2930 // Make sure we convert "t (^)(...)" to "t (*)(...)".
2931 (void)convertBlockPointerToFunctionPointer(t);
2932 ArgTypes.push_back(t);
2933 }
2934 returnType = Exp->getType();
2935 convertToUnqualifiedObjCType(returnType);
2936 (void)convertBlockPointerToFunctionPointer(returnType);
2937 } else {
2938 returnType = Context->getObjCIdType();
2939 }
2940 // Get the type, we will need to reference it in a couple spots.
2941 QualType msgSendType = MsgSendFlavor->getType();
2942
2943 // Create a reference to the objc_msgSend() declaration.
2944 DeclRefExpr *DRE = new (Context) DeclRefExpr(
2945 *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());
2946
2947 // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
2948 // If we don't do this cast, we get the following bizarre warning/note:
2949 // xx.m:13: warning: function called through a non-compatible type
2950 // xx.m:13: note: if this code is reached, the program will abort
2951 cast = NoTypeInfoCStyleCastExpr(Context,
2952 Context->getPointerType(Context->VoidTy),
2953 CK_BitCast, DRE);
2954
2955 // Now do the "normal" pointer to function cast.
2956 // If we don't have a method decl, force a variadic cast.
2957 const ObjCMethodDecl *MD = Exp->getMethodDecl();
2958 QualType castType =
2959 getSimpleFunctionType(returnType, ArgTypes, MD ? MD->isVariadic() : true);
2960 castType = Context->getPointerType(castType);
2961 cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
2962 cast);
2963
2964 // Don't forget the parens to enforce the proper binding.
2965 ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);
2966
2967 const auto *FT = msgSendType->castAs<FunctionType>();
2968 CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
2969 VK_RValue, EndLoc);
2970 Stmt *ReplacingStmt = CE;
2971 if (MsgSendStretFlavor) {
2972 // We have the method which returns a struct/union. Must also generate
2973 // call to objc_msgSend_stret and hang both varieties on a conditional
2974 // expression which dictate which one to envoke depending on size of
2975 // method's return type.
2976
2977 CallExpr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
2978 msgSendType, returnType,
2979 ArgTypes, MsgExprs,
2980 Exp->getMethodDecl());
2981
2982 // Build sizeof(returnType)
2983 UnaryExprOrTypeTraitExpr *sizeofExpr =
2984 new (Context) UnaryExprOrTypeTraitExpr(UETT_SizeOf,
2985 Context->getTrivialTypeSourceInfo(returnType),
2986 Context->getSizeType(), SourceLocation(),
2987 SourceLocation());
2988 // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
2989 // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases.
2990 // For X86 it is more complicated and some kind of target specific routine
2991 // is needed to decide what to do.
2992 unsigned IntSize =
2993 static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
2994 IntegerLiteral *limit = IntegerLiteral::Create(*Context,
2995 llvm::APInt(IntSize, 8),
2996 Context->IntTy,
2997 SourceLocation());
2998 BinaryOperator *lessThanExpr =
2999 new (Context) BinaryOperator(sizeofExpr, limit, BO_LE, Context->IntTy,
3000 VK_RValue, OK_Ordinary, SourceLocation(),
3001 FPOptions());
3002 // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
3003 ConditionalOperator *CondExpr =
3004 new (Context) ConditionalOperator(lessThanExpr,
3005 SourceLocation(), CE,
3006 SourceLocation(), STCE,
3007 returnType, VK_RValue, OK_Ordinary);
3008 ReplacingStmt = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
3009 CondExpr);
3010 }
3011 // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
3012 return ReplacingStmt;
3013 }
3014
3015 Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
3016 Stmt *ReplacingStmt =
3017 SynthMessageExpr(Exp, Exp->getBeginLoc(), Exp->getEndLoc());
3018
3019 // Now do the actual rewrite.
3020 ReplaceStmt(Exp, ReplacingStmt);
3021
3022 // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
3023 return ReplacingStmt;
3024 }
3025
3026 // typedef struct objc_object Protocol;
3027 QualType RewriteObjC::getProtocolType() {
3028 if (!ProtocolTypeDecl) {
3029 TypeSourceInfo *TInfo
3030 = Context->getTrivialTypeSourceInfo(Context->getObjCIdType());
3031 ProtocolTypeDecl = TypedefDecl::Create(*Context, TUDecl,
3032 SourceLocation(), SourceLocation(),
3033 &Context->Idents.get("Protocol"),
3034 TInfo);
3035 }
3036 return Context->getTypeDeclType(ProtocolTypeDecl);
3037 }
3038
3039 /// RewriteObjCProtocolExpr - Rewrite a protocol expression into
3040 /// a synthesized/forward data reference (to the protocol's metadata).
3041 /// The forward references (and metadata) are generated in
3042 /// RewriteObjC::HandleTranslationUnit().
3043 Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
3044 std::string Name = "_OBJC_PROTOCOL_" + Exp->getProtocol()->getNameAsString();
3045 IdentifierInfo *ID = &Context->Idents.get(Name);
3046 VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
3047 SourceLocation(), ID, getProtocolType(),
3048 nullptr, SC_Extern);
3049 DeclRefExpr *DRE = new (Context) DeclRefExpr(
3050 *Context, VD, false, getProtocolType(), VK_LValue, SourceLocation());
3051 Expr *DerefExpr = new (Context) UnaryOperator(DRE, UO_AddrOf,
3052 Context->getPointerType(DRE->getType()),
3053 VK_RValue, OK_Ordinary, SourceLocation(), false);
3054 CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, DerefExpr->getType(),
3055 CK_BitCast,
3056 DerefExpr);
3057 ReplaceStmt(Exp, castExpr);
3058 ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
3059 // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
3060 return castExpr;
3061 }
3062
3063 bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf,
3064 const char *endBuf) {
3065 while (startBuf < endBuf) {
3066 if (*startBuf == '#') {
3067 // Skip whitespace.
3068 for (++startBuf; startBuf[0] == ' ' || startBuf[0] == '\t'; ++startBuf)
3069 ;
3070 if (!strncmp(startBuf, "if", strlen("if")) ||
3071 !strncmp(startBuf, "ifdef", strlen("ifdef")) ||
3072 !strncmp(startBuf, "ifndef", strlen("ifndef")) ||
3073 !strncmp(startBuf, "define", strlen("define")) ||
3074 !strncmp(startBuf, "undef", strlen("undef")) ||
3075 !strncmp(startBuf, "else", strlen("else")) ||
3076 !strncmp(startBuf, "elif", strlen("elif")) ||
3077 !strncmp(startBuf, "endif", strlen("endif")) ||
3078 !strncmp(startBuf, "pragma", strlen("pragma")) ||
3079 !strncmp(startBuf, "include", strlen("include")) ||
3080 !strncmp(startBuf, "import", strlen("import")) ||
3081 !strncmp(startBuf, "include_next", strlen("include_next")))
3082 return true;
3083 }
3084 startBuf++;
3085 }
3086 return false;
3087 }
3088
3089 /// RewriteObjCInternalStruct - Rewrite one internal struct corresponding to
3090 /// an objective-c class with ivars.
3091 void RewriteObjC::RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl,
3092 std::string &Result) {
3093 assert(CDecl && "Class missing in SynthesizeObjCInternalStruct");
3094 assert(CDecl->getName() != "" &&
3095 "Name missing in SynthesizeObjCInternalStruct");
3096 // Do not synthesize more than once.
3097 if (ObjCSynthesizedStructs.count(CDecl))
3098 return;
3099 ObjCInterfaceDecl *RCDecl = CDecl->getSuperClass();
3100 int NumIvars = CDecl->ivar_size();
3101 SourceLocation LocStart = CDecl->getBeginLoc();
3102 SourceLocation LocEnd = CDecl->getEndOfDefinitionLoc();
3103
3104 const char *startBuf = SM->getCharacterData(LocStart);
3105 const char *endBuf = SM->getCharacterData(LocEnd);
3106
3107 // If no ivars and no root or if its root, directly or indirectly,
3108 // have no ivars (thus not synthesized) then no need to synthesize this class.
3109 if ((!CDecl->isThisDeclarationADefinition() || NumIvars == 0) &&
3110 (!RCDecl || !ObjCSynthesizedStructs.count(RCDecl))) {
3111 endBuf += Lexer::MeasureTokenLength(LocEnd, *SM, LangOpts);
3112 ReplaceText(LocStart, endBuf-startBuf, Result);
3113 return;
3114 }
3115
3116 // FIXME: This has potential of causing problem. If
3117 // SynthesizeObjCInternalStruct is ever called recursively.
3118 Result += "\nstruct ";
3119 Result += CDecl->getNameAsString();
3120 if (LangOpts.MicrosoftExt)
3121 Result += "_IMPL";
3122
3123 if (NumIvars > 0) {
3124 const char *cursor = strchr(startBuf, '{');
3125 assert((cursor && endBuf)
3126 && "SynthesizeObjCInternalStruct - malformed @interface");
3127 // If the buffer contains preprocessor directives, we do more fine-grained
3128 // rewrites. This is intended to fix code that looks like (which occurs in
3129 // NSURL.h, for example):
3130 //
3131 // #ifdef XYZ
3132 // @interface Foo : NSObject
3133 // #else
3134 // @interface FooBar : NSObject
3135 // #endif
3136 // {
3137 // int i;
3138 // }
3139 // @end
3140 //
3141 // This clause is segregated to avoid breaking the common case.
3142 if (BufferContainsPPDirectives(startBuf, cursor)) {
3143 SourceLocation L = RCDecl ? CDecl->getSuperClassLoc() :
3144 CDecl->getAtStartLoc();
3145 const char *endHeader = SM->getCharacterData(L);
3146 endHeader += Lexer::MeasureTokenLength(L, *SM, LangOpts);
3147
3148 if (CDecl->protocol_begin() != CDecl->protocol_end()) {
3149 // advance to the end of the referenced protocols.
3150 while (endHeader < cursor && *endHeader != '>') endHeader++;
3151 endHeader++;
3152 }
3153 // rewrite the original header
3154 ReplaceText(LocStart, endHeader-startBuf, Result);
3155 } else {
3156 // rewrite the original header *without* disturbing the '{'
3157 ReplaceText(LocStart, cursor-startBuf, Result);
3158 }
3159 if (RCDecl && ObjCSynthesizedStructs.count(RCDecl)) {
3160 Result = "\n struct ";
3161 Result += RCDecl->getNameAsString();
3162 Result += "_IMPL ";
3163 Result += RCDecl->getNameAsString();
3164 Result += "_IVARS;\n";
3165
3166 // insert the super class structure definition.
3167 SourceLocation OnePastCurly =
3168 LocStart.getLocWithOffset(cursor-startBuf+1);
3169 InsertText(OnePastCurly, Result);
3170 }
3171 cursor++; // past '{'
3172
3173 // Now comment out any visibility specifiers.
3174 while (cursor < endBuf) {
3175 if (*cursor == '@') {
3176 SourceLocation atLoc = LocStart.getLocWithOffset(cursor-startBuf);
3177 // Skip whitespace.
3178 for (++cursor; cursor[0] == ' ' || cursor[0] == '\t'; ++cursor)
3179 /*scan*/;
3180
3181 // FIXME: presence of @public, etc. inside comment results in
3182 // this transformation as well, which is still correct c-code.
3183 if (!strncmp(cursor, "public", strlen("public")) ||
3184 !strncmp(cursor, "private", strlen("private")) ||
3185 !strncmp(cursor, "package", strlen("package")) ||
3186 !strncmp(cursor, "protected", strlen("protected")))
3187 InsertText(atLoc, "// ");
3188 }
3189 // FIXME: If there are cases where '<' is used in ivar declaration part
3190 // of user code, then scan the ivar list and use needToScanForQualifiers
3191 // for type checking.
3192 else if (*cursor == '<') {
3193 SourceLocation atLoc = LocStart.getLocWithOffset(cursor-startBuf);
3194 InsertText(atLoc, "/* ");
3195 cursor = strchr(cursor, '>');
3196 cursor++;
3197 atLoc = LocStart.getLocWithOffset(cursor-startBuf);
3198 InsertText(atLoc, " */");
3199 } else if (*cursor == '^') { // rewrite block specifier.
3200 SourceLocation caretLoc = LocStart.getLocWithOffset(cursor-startBuf);
3201 ReplaceText(caretLoc, 1, "*");
3202 }
3203 cursor++;
3204 }
3205 // Don't forget to add a ';'!!
3206 InsertText(LocEnd.getLocWithOffset(1), ";");
3207 } else { // we don't have any instance variables - insert super struct.
3208 endBuf += Lexer::MeasureTokenLength(LocEnd, *SM, LangOpts);
3209 Result += " {\n struct ";
3210 Result += RCDecl->getNameAsString();
3211 Result += "_IMPL ";
3212 Result += RCDecl->getNameAsString();
3213 Result += "_IVARS;\n};\n";
3214 ReplaceText(LocStart, endBuf-startBuf, Result);
3215 }
3216 // Mark this struct as having been generated.
3217 if (!ObjCSynthesizedStructs.insert(CDecl).second)
3218 llvm_unreachable("struct already synthesize- SynthesizeObjCInternalStruct");
3219 }
3220
3221 //===----------------------------------------------------------------------===//
3222 // Meta Data Emission
3223 //===----------------------------------------------------------------------===//
3224
3225 /// RewriteImplementations - This routine rewrites all method implementations
3226 /// and emits meta-data.
3227
3228 void RewriteObjC::RewriteImplementations() {
3229 int ClsDefCount = ClassImplementation.size();
3230 int CatDefCount = CategoryImplementation.size();
3231
3232 // Rewrite implemented methods
3233 for (int i = 0; i < ClsDefCount; i++)
3234 RewriteImplementationDecl(ClassImplementation[i]);
3235
3236 for (int i = 0; i < CatDefCount; i++)
3237 RewriteImplementationDecl(CategoryImplementation[i]);
3238 }
3239
3240 void RewriteObjC::RewriteByRefString(std::string &ResultStr,
3241 const std::string &Name,
3242 ValueDecl *VD, bool def) {
3243 assert(BlockByRefDeclNo.count(VD) &&
3244 "RewriteByRefString: ByRef decl missing");
3245 if (def)
3246 ResultStr += "struct ";
3247 ResultStr += "__Block_byref_" + Name +
3248 "_" + utostr(BlockByRefDeclNo[VD]) ;
3249 }
3250
3251 static bool HasLocalVariableExternalStorage(ValueDecl *VD) {
3252 if (VarDecl *Var = dyn_cast<VarDecl>(VD))
3253 return (Var->isFunctionOrMethodVarDecl() && !Var->hasLocalStorage());
3254 return false;
3255 }
3256
3257 std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i,
3258 StringRef funcName,
3259 std::string Tag) {
3260 const FunctionType *AFT = CE->getFunctionType();
3261 QualType RT = AFT->getReturnType();
3262 std::string StructRef = "struct " + Tag;
3263 std::string S = "static " + RT.getAsString(Context->getPrintingPolicy()) + " __" +
3264 funcName.str() + "_" + "block_func_" + utostr(i);
3265
3266 BlockDecl *BD = CE->getBlockDecl();
3267
3268 if (isa<FunctionNoProtoType>(AFT)) {
3269 // No user-supplied arguments. Still need to pass in a pointer to the
3270 // block (to reference imported block decl refs).
3271 S += "(" + StructRef + " *__cself)";
3272 } else if (BD->param_empty()) {
3273 S += "(" + StructRef + " *__cself)";
3274 } else {
3275 const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
3276 assert(FT && "SynthesizeBlockFunc: No function proto");
3277 S += '(';
3278 // first add the implicit argument.
3279 S += StructRef + " *__cself, ";
3280 std::string ParamStr;
3281 for (BlockDecl::param_iterator AI = BD->param_begin(),
3282 E = BD->param_end(); AI != E; ++AI) {
3283 if (AI != BD->param_begin()) S += ", ";
3284 ParamStr = (*AI)->getNameAsString();
3285 QualType QT = (*AI)->getType();
3286 (void)convertBlockPointerToFunctionPointer(QT);
3287 QT.getAsStringInternal(ParamStr, Context->getPrintingPolicy());
3288 S += ParamStr;
3289 }
3290 if (FT->isVariadic()) {
3291 if (!BD->param_empty()) S += ", ";
3292 S += "...";
3293 }
3294 S += ')';
3295 }
3296 S += " {\n";
3297
3298 // Create local declarations to avoid rewriting all closure decl ref exprs.
3299 // First, emit a declaration for all "by ref" decls.
3300 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
3301 E = BlockByRefDecls.end(); I != E; ++I) {
3302 S += " ";
3303 std::string Name = (*I)->getNameAsString();
3304 std::string TypeString;
3305 RewriteByRefString(TypeString, Name, (*I));
3306 TypeString += " *";
3307 Name = TypeString + Name;
3308 S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n";
3309 }
3310 // Next, emit a declaration for all "by copy" declarations.
3311 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
3312 E = BlockByCopyDecls.end(); I != E; ++I) {
3313 S += " ";
3314 // Handle nested closure invocation. For example:
3315 //
3316 // void (^myImportedClosure)(void);
3317 // myImportedClosure = ^(void) { setGlobalInt(x + y); };
3318 //
3319 // void (^anotherClosure)(void);
3320 // anotherClosure = ^(void) {
3321 // myImportedClosure(); // import and invoke the closure
3322 // };
3323 //
3324 if (isTopLevelBlockPointerType((*I)->getType())) {
3325 RewriteBlockPointerTypeVariable(S, (*I));
3326 S += " = (";
3327 RewriteBlockPointerType(S, (*I)->getType());
3328 S += ")";
3329 S += "__cself->" + (*I)->getNameAsString() + "; // bound by copy\n";
3330 }
3331 else {
3332 std::string Name = (*I)->getNameAsString();
3333 QualType QT = (*I)->getType();
3334 if (HasLocalVariableExternalStorage(*I))
3335 QT = Context->getPointerType(QT);
3336 QT.getAsStringInternal(Name, Context->getPrintingPolicy());
3337 S += Name + " = __cself->" +
3338 (*I)->getNameAsString() + "; // bound by copy\n";
3339 }
3340 }
3341 std::string RewrittenStr = RewrittenBlockExprs[CE];
3342 const char *cstr = RewrittenStr.c_str();
3343 while (*cstr++ != '{') ;
3344 S += cstr;
3345 S += "\n";
3346 return S;
3347 }
3348
3349 std::string RewriteObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
3350 StringRef funcName,
3351 std::string Tag) {
3352 std::string StructRef = "struct " + Tag;
3353 std::string S = "static void __";
3354
3355 S += funcName;
3356 S += "_block_copy_" + utostr(i);
3357 S += "(" + StructRef;
3358 S += "*dst, " + StructRef;
3359 S += "*src) {";
3360 for (ValueDecl *VD : ImportedBlockDecls) {
3361 S += "_Block_object_assign((void*)&dst->";
3362 S += VD->getNameAsString();
3363 S += ", (void*)src->";
3364 S += VD->getNameAsString();
3365 if (BlockByRefDeclsPtrSet.count(VD))
3366 S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
3367 else if (VD->getType()->isBlockPointerType())
3368 S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
3369 else
3370 S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
3371 }
3372 S += "}\n";
3373
3374 S += "\nstatic void __";
3375 S += funcName;
3376 S += "_block_dispose_" + utostr(i);
3377 S += "(" + StructRef;
3378 S += "*src) {";
3379 for (ValueDecl *VD : ImportedBlockDecls) {
3380 S += "_Block_object_dispose((void*)src->";
3381 S += VD->getNameAsString();
3382 if (BlockByRefDeclsPtrSet.count(VD))
3383 S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
3384 else if (VD->getType()->isBlockPointerType())
3385 S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
3386 else
3387 S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
3388 }
3389 S += "}\n";
3390 return S;
3391 }
3392
3393 std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag,
3394 std::string Desc) {
3395 std::string S = "\nstruct " + Tag;
3396 std::string Constructor = " " + Tag;
3397
3398 S += " {\n struct __block_impl impl;\n";
3399 S += " struct " + Desc;
3400 S += "* Desc;\n";
3401
3402 Constructor += "(void *fp, "; // Invoke function pointer.
3403 Constructor += "struct " + Desc; // Descriptor pointer.
3404 Constructor += " *desc";
3405
3406 if (BlockDeclRefs.size()) {
3407 // Output all "by copy" declarations.
3408 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
3409 E = BlockByCopyDecls.end(); I != E; ++I) {
3410 S += " ";
3411 std::string FieldName = (*I)->getNameAsString();
3412 std::string ArgName = "_" + FieldName;
3413 // Handle nested closure invocation. For example:
3414 //
3415 // void (^myImportedBlock)(void);
3416 // myImportedBlock = ^(void) { setGlobalInt(x + y); };
3417 //
3418 // void (^anotherBlock)(void);
3419 // anotherBlock = ^(void) {
3420 // myImportedBlock(); // import and invoke the closure
3421 // };
3422 //
3423 if (isTopLevelBlockPointerType((*I)->getType())) {
3424 S += "struct __block_impl *";
3425 Constructor += ", void *" + ArgName;
3426 } else {
3427 QualType QT = (*I)->getType();
3428 if (HasLocalVariableExternalStorage(*I))
3429 QT = Context->getPointerType(QT);
3430 QT.getAsStringInternal(FieldName, Context->getPrintingPolicy());
3431 QT.getAsStringInternal(ArgName, Context->getPrintingPolicy());
3432 Constructor += ", " + ArgName;
3433 }
3434 S += FieldName + ";\n";
3435 }
3436 // Output all "by ref" declarations.
3437 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
3438 E = BlockByRefDecls.end(); I != E; ++I) {
3439 S += " ";
3440 std::string FieldName = (*I)->getNameAsString();
3441 std::string ArgName = "_" + FieldName;
3442 {
3443 std::string TypeString;
3444 RewriteByRefString(TypeString, FieldName, (*I));
3445 TypeString += " *";
3446 FieldName = TypeString + FieldName;
3447 ArgName = TypeString + ArgName;
3448 Constructor += ", " + ArgName;
3449 }
3450 S += FieldName + "; // by ref\n";
3451 }
3452 // Finish writing the constructor.
3453 Constructor += ", int flags=0)";
3454 // Initialize all "by copy" arguments.
3455 bool firsTime = true;
3456 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
3457 E = BlockByCopyDecls.end(); I != E; ++I) {
3458 std::string Name = (*I)->getNameAsString();
3459 if (firsTime) {
3460 Constructor += " : ";
3461 firsTime = false;
3462 }
3463 else
3464 Constructor += ", ";
3465 if (isTopLevelBlockPointerType((*I)->getType()))
3466 Constructor += Name + "((struct __block_impl *)_" + Name + ")";
3467 else
3468 Constructor += Name + "(_" + Name + ")";
3469 }
3470 // Initialize all "by ref" arguments.
3471 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
3472 E = BlockByRefDecls.end(); I != E; ++I) {
3473 std::string Name = (*I)->getNameAsString();
3474 if (firsTime) {
3475 Constructor += " : ";
3476 firsTime = false;
3477 }
3478 else
3479 Constructor += ", ";
3480 Constructor += Name + "(_" + Name + "->__forwarding)";
3481 }
3482
3483 Constructor += " {\n";
3484 if (GlobalVarDecl)
3485 Constructor += " impl.isa = &_NSConcreteGlobalBlock;\n";
3486 else
3487 Constructor += " impl.isa = &_NSConcreteStackBlock;\n";
3488 Constructor += " impl.Flags = flags;\n impl.FuncPtr = fp;\n";
3489
3490 Constructor += " Desc = desc;\n";
3491 } else {
3492 // Finish writing the constructor.
3493 Constructor += ", int flags=0) {\n";
3494 if (GlobalVarDecl)
3495 Constructor += " impl.isa = &_NSConcreteGlobalBlock;\n";
3496 else
3497 Constructor += " impl.isa = &_NSConcreteStackBlock;\n";
3498 Constructor += " impl.Flags = flags;\n impl.FuncPtr = fp;\n";
3499 Constructor += " Desc = desc;\n";
3500 }
3501 Constructor += " ";
3502 Constructor += "}\n";
3503 S += Constructor;
3504 S += "};\n";
3505 return S;
3506 }
3507
3508 std::string RewriteObjC::SynthesizeBlockDescriptor(std::string DescTag,
3509 std::string ImplTag, int i,
3510 StringRef FunName,
3511 unsigned hasCopy) {
3512 std::string S = "\nstatic struct " + DescTag;
3513
3514 S += " {\n unsigned long reserved;\n";
3515 S += " unsigned long Block_size;\n";
3516 if (hasCopy) {
3517 S += " void (*copy)(struct ";
3518 S += ImplTag; S += "*, struct ";
3519 S += ImplTag; S += "*);\n";
3520
3521 S += " void (*dispose)(struct ";
3522 S += ImplTag; S += "*);\n";
3523 }
3524 S += "} ";
3525
3526 S += DescTag + "_DATA = { 0, sizeof(struct ";
3527 S += ImplTag + ")";
3528 if (hasCopy) {
3529 S += ", __" + FunName.str() + "_block_copy_" + utostr(i);
3530 S += ", __" + FunName.str() + "_block_dispose_" + utostr(i);
3531 }
3532 S += "};\n";
3533 return S;
3534 }
3535
3536 void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart,
3537 StringRef FunName) {
3538 // Insert declaration for the function in which block literal is used.
3539 if (CurFunctionDeclToDeclareForBlock && !Blocks.empty())
3540 RewriteBlockLiteralFunctionDecl(CurFunctionDeclToDeclareForBlock);
3541 bool RewriteSC = (GlobalVarDecl &&
3542 !Blocks.empty() &&
3543 GlobalVarDecl->getStorageClass() == SC_Static &&
3544 GlobalVarDecl->getType().getCVRQualifiers());
3545 if (RewriteSC) {
3546 std::string SC(" void __");
3547 SC += GlobalVarDecl->getNameAsString();
3548 SC += "() {}";
3549 InsertText(FunLocStart, SC);
3550 }
3551
3552 // Insert closures that were part of the function.
3553 for (unsigned i = 0, count=0; i < Blocks.size(); i++) {
3554 CollectBlockDeclRefInfo(Blocks[i]);
3555 // Need to copy-in the inner copied-in variables not actually used in this
3556 // block.
3557 for (int j = 0; j < InnerDeclRefsCount[i]; j++) {
3558 DeclRefExpr *Exp = InnerDeclRefs[count++];
3559 ValueDecl *VD = Exp->getDecl();
3560 BlockDeclRefs.push_back(Exp);
3561 if (!VD->hasAttr<BlocksAttr>() && !BlockByCopyDeclsPtrSet.count(VD)) {
3562 BlockByCopyDeclsPtrSet.insert(VD);
3563 BlockByCopyDecls.push_back(VD);
3564 }
3565 if (VD->hasAttr<BlocksAttr>() && !BlockByRefDeclsPtrSet.count(VD)) {
3566 BlockByRefDeclsPtrSet.insert(VD);
3567 BlockByRefDecls.push_back(VD);
3568 }
3569 // imported objects in the inner blocks not used in the outer
3570 // blocks must be copied/disposed in the outer block as well.
3571 if (VD->hasAttr<BlocksAttr>() ||
3572 VD->getType()->isObjCObjectPointerType() ||
3573 VD->getType()->isBlockPointerType())
3574 ImportedBlockDecls.insert(VD);
3575 }
3576
3577 std::string ImplTag = "__" + FunName.str() + "_block_impl_" + utostr(i);
3578 std::string DescTag = "__" + FunName.str() + "_block_desc_" + utostr(i);
3579
3580 std::string CI = SynthesizeBlockImpl(Blocks[i], ImplTag, DescTag);
3581
3582 InsertText(FunLocStart, CI);
3583
3584 std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, ImplTag);
3585
3586 InsertText(FunLocStart, CF);
3587
3588 if (ImportedBlockDecls.size()) {
3589 std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, ImplTag);
3590 InsertText(FunLocStart, HF);
3591 }
3592 std::string BD = SynthesizeBlockDescriptor(DescTag, ImplTag, i, FunName,
3593 ImportedBlockDecls.size() > 0);
3594 InsertText(FunLocStart, BD);
3595
3596 BlockDeclRefs.clear();
3597 BlockByRefDecls.clear();
3598 BlockByRefDeclsPtrSet.clear();
3599 BlockByCopyDecls.clear();
3600 BlockByCopyDeclsPtrSet.clear();
3601 ImportedBlockDecls.clear();
3602 }
3603 if (RewriteSC) {
3604 // Must insert any 'const/volatile/static here. Since it has been
3605 // removed as result of rewriting of block literals.
3606 std::string SC;
3607 if (GlobalVarDecl->getStorageClass() == SC_Static)
3608 SC = "static ";
3609 if (GlobalVarDecl->getType().isConstQualified())
3610 SC += "const ";
3611 if (GlobalVarDecl->getType().isVolatileQualified())
3612 SC += "volatile ";
3613 if (GlobalVarDecl->getType().isRestrictQualified())
3614 SC += "restrict ";
3615 InsertText(FunLocStart, SC);
3616 }
3617
3618 Blocks.clear();
3619 InnerDeclRefsCount.clear();
3620 InnerDeclRefs.clear();
3621 RewrittenBlockExprs.clear();
3622 }
3623
3624 void RewriteObjC::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) {
3625 SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
3626 StringRef FuncName = FD->getName();
3627
3628 SynthesizeBlockLiterals(FunLocStart, FuncName);
3629 }
3630
3631 static void BuildUniqueMethodName(std::string &Name,
3632 ObjCMethodDecl *MD) {
3633 ObjCInterfaceDecl *IFace = MD->getClassInterface();
3634 Name = IFace->getName();
3635 Name += "__" + MD->getSelector().getAsString();
3636 // Convert colons to underscores.
3637 std::string::size_type loc = 0;
3638 while ((loc = Name.find(':', loc)) != std::string::npos)
3639 Name.replace(loc, 1, "_");
3640 }
3641
3642 void RewriteObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) {
3643 // fprintf(stderr,"In InsertBlockLiteralsWitinMethod\n");
3644 // SourceLocation FunLocStart = MD->getBeginLoc();
3645 SourceLocation FunLocStart = MD->getBeginLoc();
3646 std::string FuncName;
3647 BuildUniqueMethodName(FuncName, MD);
3648 SynthesizeBlockLiterals(FunLocStart, FuncName);
3649 }
3650
3651 void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) {
3652 for (Stmt *SubStmt : S->children())
3653 if (SubStmt) {
3654 if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt))
3655 GetBlockDeclRefExprs(CBE->getBody());
3656 else
3657 GetBlockDeclRefExprs(SubStmt);
3658 }
3659 // Handle specific things.
3660 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S))
3661 if (DRE->refersToEnclosingVariableOrCapture() ||
3662 HasLocalVariableExternalStorage(DRE->getDecl()))
3663 // FIXME: Handle enums.
3664 BlockDeclRefs.push_back(DRE);
3665 }
3666
3667 void RewriteObjC::GetInnerBlockDeclRefExprs(Stmt *S,
3668 SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs,
3669 llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts) {
3670 for (Stmt *SubStmt : S->children())
3671 if (SubStmt) {
3672 if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) {
3673 InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl()));
3674 GetInnerBlockDeclRefExprs(CBE->getBody(),
3675 InnerBlockDeclRefs,
3676 InnerContexts);
3677 }
3678 else
3679 GetInnerBlockDeclRefExprs(SubStmt, InnerBlockDeclRefs, InnerContexts);
3680 }
3681 // Handle specific things.
3682 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) {
3683 if (DRE->refersToEnclosingVariableOrCapture() ||
3684 HasLocalVariableExternalStorage(DRE->getDecl())) {
3685 if (!InnerContexts.count(DRE->getDecl()->getDeclContext()))
3686 InnerBlockDeclRefs.push_back(DRE);
3687 if (VarDecl *Var = cast<VarDecl>(DRE->getDecl()))
3688 if (Var->isFunctionOrMethodVarDecl())
3689 ImportedLocalExternalDecls.insert(Var);
3690 }
3691 }
3692 }
3693
3694 /// convertFunctionTypeOfBlocks - This routine converts a function type
3695 /// whose result type may be a block pointer or whose argument type(s)
3696 /// might be block pointers to an equivalent function type replacing
3697 /// all block pointers to function pointers.
3698 QualType RewriteObjC::convertFunctionTypeOfBlocks(const FunctionType *FT) {
3699 const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT);
3700 // FTP will be null for closures that don't take arguments.
3701 // Generate a funky cast.
3702 SmallVector<QualType, 8> ArgTypes;
3703 QualType Res = FT->getReturnType();
3704 bool HasBlockType = convertBlockPointerToFunctionPointer(Res);
3705
3706 if (FTP) {
3707 for (auto &I : FTP->param_types()) {
3708 QualType t = I;
3709 // Make sure we convert "t (^)(...)" to "t (*)(...)".
3710 if (convertBlockPointerToFunctionPointer(t))
3711 HasBlockType = true;
3712 ArgTypes.push_back(t);
3713 }
3714 }
3715 QualType FuncType;
3716 // FIXME. Does this work if block takes no argument but has a return type
3717 // which is of block type?
3718 if (HasBlockType)
3719 FuncType = getSimpleFunctionType(Res, ArgTypes);
3720 else FuncType = QualType(FT, 0);
3721 return FuncType;
3722 }
3723
3724 Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
3725 // Navigate to relevant type information.
3726 const BlockPointerType *CPT = nullptr;
3727
3728 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(BlockExp)) {
3729 CPT = DRE->getType()->getAs<BlockPointerType>();
3730 } else if (const MemberExpr *MExpr = dyn_cast<MemberExpr>(BlockExp)) {
3731 CPT = MExpr->getType()->getAs<BlockPointerType>();
3732 }
3733 else if (const ParenExpr *PRE = dyn_cast<ParenExpr>(BlockExp)) {
3734 return SynthesizeBlockCall(Exp, PRE->getSubExpr());
3735 }
3736 else if (const ImplicitCastExpr *IEXPR = dyn_cast<ImplicitCastExpr>(BlockExp))
3737 CPT = IEXPR->getType()->getAs<BlockPointerType>();
3738 else if (const ConditionalOperator *CEXPR =
3739 dyn_cast<ConditionalOperator>(BlockExp)) {
3740 Expr *LHSExp = CEXPR->getLHS();
3741 Stmt *LHSStmt = SynthesizeBlockCall(Exp, LHSExp);
3742 Expr *RHSExp = CEXPR->getRHS();
3743 Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp);
3744 Expr *CONDExp = CEXPR->getCond();
3745 ConditionalOperator *CondExpr =
3746 new (Context) ConditionalOperator(CONDExp,
3747 SourceLocation(), cast<Expr>(LHSStmt),
3748 SourceLocation(), cast<Expr>(RHSStmt),
3749 Exp->getType(), VK_RValue, OK_Ordinary);
3750 return CondExpr;
3751 } else if (const ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(BlockExp)) {
3752 CPT = IRE->getType()->getAs<BlockPointerType>();
3753 } else if (const PseudoObjectExpr *POE
3754 = dyn_cast<PseudoObjectExpr>(BlockExp)) {
3755 CPT = POE->getType()->castAs<BlockPointerType>();
3756 } else {
3757 assert(false && "RewriteBlockClass: Bad type");
3758 }
3759 assert(CPT && "RewriteBlockClass: Bad type");
3760 const FunctionType *FT = CPT->getPointeeType()->getAs<FunctionType>();
3761 assert(FT && "RewriteBlockClass: Bad type");
3762 const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT);
3763 // FTP will be null for closures that don't take arguments.
3764
3765 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
3766 SourceLocation(), SourceLocation(),
3767 &Context->Idents.get("__block_impl"));
3768 QualType PtrBlock = Context->getPointerType(Context->getTagDeclType(RD));
3769
3770 // Generate a funky cast.
3771 SmallVector<QualType, 8> ArgTypes;
3772
3773 // Push the block argument type.
3774 ArgTypes.push_back(PtrBlock);
3775 if (FTP) {
3776 for (auto &I : FTP->param_types()) {
3777 QualType t = I;
3778 // Make sure we convert "t (^)(...)" to "t (*)(...)".
3779 if (!convertBlockPointerToFunctionPointer(t))
3780 convertToUnqualifiedObjCType(t);
3781 ArgTypes.push_back(t);
3782 }
3783 }
3784 // Now do the pointer to function cast.
3785 QualType PtrToFuncCastType = getSimpleFunctionType(Exp->getType(), ArgTypes);
3786
3787 PtrToFuncCastType = Context->getPointerType(PtrToFuncCastType);
3788
3789 CastExpr *BlkCast = NoTypeInfoCStyleCastExpr(Context, PtrBlock,
3790 CK_BitCast,
3791 const_cast<Expr*>(BlockExp));
3792 // Don't forget the parens to enforce the proper binding.
3793 ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
3794 BlkCast);
3795 //PE->dump();
3796
3797 FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
3798 SourceLocation(),
3799 &Context->Idents.get("FuncPtr"),
3800 Context->VoidPtrTy, nullptr,
3801 /*BitWidth=*/nullptr, /*Mutable=*/true,
3802 ICIS_NoInit);
3803 MemberExpr *ME = MemberExpr::CreateImplicit(
3804 *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary);
3805
3806 CastExpr *FunkCast = NoTypeInfoCStyleCastExpr(Context, PtrToFuncCastType,
3807 CK_BitCast, ME);
3808 PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), FunkCast);
3809
3810 SmallVector<Expr*, 8> BlkExprs;
3811 // Add the implicit argument.
3812 BlkExprs.push_back(BlkCast);
3813 // Add the user arguments.
3814 for (CallExpr::arg_iterator I = Exp->arg_begin(),
3815 E = Exp->arg_end(); I != E; ++I) {
3816 BlkExprs.push_back(*I);
3817 }
3818 CallExpr *CE = CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(),
3819 VK_RValue, SourceLocation());
3820 return CE;
3821 }
3822
3823 // We need to return the rewritten expression to handle cases where the
3824 // BlockDeclRefExpr is embedded in another expression being rewritten.
3825 // For example:
3826 //
3827 // int main() {
3828 // __block Foo *f;
3829 // __block int i;
3830 //
3831 // void (^myblock)() = ^() {
3832 // [f test]; // f is a BlockDeclRefExpr embedded in a message (which is being rewritten).
3833 // i = 77;
3834 // };
3835 //}
3836 Stmt *RewriteObjC::RewriteBlockDeclRefExpr(DeclRefExpr *DeclRefExp) {
3837 // Rewrite the byref variable into BYREFVAR->__forwarding->BYREFVAR
3838 // for each DeclRefExp where BYREFVAR is name of the variable.
3839 ValueDecl *VD = DeclRefExp->getDecl();
3840 bool isArrow = DeclRefExp->refersToEnclosingVariableOrCapture() ||
3841 HasLocalVariableExternalStorage(DeclRefExp->getDecl());
3842
3843 FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(),
3844 SourceLocation(),
3845 &Context->Idents.get("__forwarding"),
3846 Context->VoidPtrTy, nullptr,
3847 /*BitWidth=*/nullptr, /*Mutable=*/true,
3848 ICIS_NoInit);
3849 MemberExpr *ME =
3850 MemberExpr::CreateImplicit(*Context, DeclRefExp, isArrow, FD,
3851 FD->getType(), VK_LValue, OK_Ordinary);
3852
3853 StringRef Name = VD->getName();
3854 FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), SourceLocation(),
3855 &Context->Idents.get(Name),
3856 Context->VoidPtrTy, nullptr,
3857 /*BitWidth=*/nullptr, /*Mutable=*/true,
3858 ICIS_NoInit);
3859 ME = MemberExpr::CreateImplicit(*Context, ME, true, FD, DeclRefExp->getType(),
3860 VK_LValue, OK_Ordinary);
3861
3862 // Need parens to enforce precedence.
3863 ParenExpr *PE = new (Context) ParenExpr(DeclRefExp->getExprLoc(),
3864 DeclRefExp->getExprLoc(),
3865 ME);
3866 ReplaceStmt(DeclRefExp, PE);
3867 return PE;
3868 }
3869
3870 // Rewrites the imported local variable V with external storage
3871 // (static, extern, etc.) as *V
3872 //
3873 Stmt *RewriteObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) {
3874 ValueDecl *VD = DRE->getDecl();
3875 if (VarDecl *Var = dyn_cast<VarDecl>(VD))
3876 if (!ImportedLocalExternalDecls.count(Var))
3877 return DRE;
3878 Expr *Exp = new (Context) UnaryOperator(DRE, UO_Deref, DRE->getType(),
3879 VK_LValue, OK_Ordinary,
3880 DRE->getLocation(), false);
3881 // Need parens to enforce precedence.
3882 ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
3883 Exp);
3884 ReplaceStmt(DRE, PE);
3885 return PE;
3886 }
3887
3888 void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) {
3889 SourceLocation LocStart = CE->getLParenLoc();
3890 SourceLocation LocEnd = CE->getRParenLoc();
3891
3892 // Need to avoid trying to rewrite synthesized casts.
3893 if (LocStart.isInvalid())
3894 return;
3895 // Need to avoid trying to rewrite casts contained in macros.
3896 if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd))
3897 return;
3898
3899 const char *startBuf = SM->getCharacterData(LocStart);
3900 const char *endBuf = SM->getCharacterData(LocEnd);
3901 QualType QT = CE->getType();
3902 const Type* TypePtr = QT->getAs<Type>();
3903 if (isa<TypeOfExprType>(TypePtr)) {
3904 const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
3905 QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType();
3906 std::string TypeAsString = "(";
3907 RewriteBlockPointerType(TypeAsString, QT);
3908 TypeAsString += ")";
3909 ReplaceText(LocStart, endBuf-startBuf+1, TypeAsString);
3910 return;
3911 }
3912 // advance the location to startArgList.
3913 const char *argPtr = startBuf;
3914
3915 while (*argPtr++ && (argPtr < endBuf)) {
3916 switch (*argPtr) {
3917 case '^':
3918 // Replace the '^' with '*'.
3919 LocStart = LocStart.getLocWithOffset(argPtr-startBuf);
3920 ReplaceText(LocStart, 1, "*");
3921 break;
3922 }
3923 }
3924 }
3925
3926 void RewriteObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) {
3927 SourceLocation DeclLoc = FD->getLocation();
3928 unsigned parenCount = 0;
3929
3930 // We have 1 or more arguments that have closure pointers.
3931 const char *startBuf = SM->getCharacterData(DeclLoc);
3932 const char *startArgList = strchr(startBuf, '(');
3933
3934 assert((*startArgList == '(') && "Rewriter fuzzy parser confused");
3935
3936 parenCount++;
3937 // advance the location to startArgList.
3938 DeclLoc = DeclLoc.getLocWithOffset(startArgList-startBuf);
3939 assert((DeclLoc.isValid()) && "Invalid DeclLoc");
3940
3941 const char *argPtr = startArgList;
3942
3943 while (*argPtr++ && parenCount) {
3944 switch (*argPtr) {
3945 case '^':
3946 // Replace the '^' with '*'.
3947 DeclLoc = DeclLoc.getLocWithOffset(argPtr-startArgList);
3948 ReplaceText(DeclLoc, 1, "*");
3949 break;
3950 case '(':
3951 parenCount++;
3952 break;
3953 case ')':
3954 parenCount--;
3955 break;
3956 }
3957 }
3958 }
3959
3960 bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) {
3961 const FunctionProtoType *FTP;
3962 const PointerType *PT = QT->getAs<PointerType>();
3963 if (PT) {
3964 FTP = PT->getPointeeType()->getAs<FunctionProtoType>();
3965 } else {
3966 const BlockPointerType *BPT = QT->getAs<BlockPointerType>();
3967 assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type");
3968 FTP = BPT->getPointeeType()->getAs<FunctionProtoType>();
3969 }
3970 if (FTP) {
3971 for (const auto &I : FTP->param_types())
3972 if (isTopLevelBlockPointerType(I))
3973 return true;
3974 }
3975 return false;
3976 }
3977
3978 bool RewriteObjC::PointerTypeTakesAnyObjCQualifiedType(QualType QT) {
3979 const FunctionProtoType *FTP;
3980 const PointerType *PT = QT->getAs<PointerType>();
3981 if (PT) {
3982 FTP = PT->getPointeeType()->getAs<FunctionProtoType>();
3983 } else {
3984 const BlockPointerType *BPT = QT->getAs<BlockPointerType>();
3985 assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type");
3986 FTP = BPT->getPointeeType()->getAs<FunctionProtoType>();
3987 }
3988 if (FTP) {
3989 for (const auto &I : FTP->param_types()) {
3990 if (I->isObjCQualifiedIdType())
3991 return true;
3992 if (I->isObjCObjectPointerType() &&
3993 I->getPointeeType()->isObjCQualifiedInterfaceType())
3994 return true;
3995 }
3996
3997 }
3998 return false;
3999 }
4000
4001 void RewriteObjC::GetExtentOfArgList(const char *Name, const char *&LParen,
4002 const char *&RParen) {
4003 const char *argPtr = strchr(Name, '(');
4004 assert((*argPtr == '(') && "Rewriter fuzzy parser confused");
4005
4006 LParen = argPtr; // output the start.
4007 argPtr++; // skip past the left paren.
4008 unsigned parenCount = 1;
4009
4010 while (*argPtr && parenCount) {
4011 switch (*argPtr) {
4012 case '(': parenCount++; break;
4013 case ')': parenCount--; break;
4014 default: break;
4015 }
4016 if (parenCount) argPtr++;
4017 }
4018 assert((*argPtr == ')') && "Rewriter fuzzy parser confused");
4019 RParen = argPtr; // output the end
4020 }
4021
4022 void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) {
4023 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
4024 RewriteBlockPointerFunctionArgs(FD);
4025 return;
4026 }
4027 // Handle Variables and Typedefs.
4028 SourceLocation DeclLoc = ND->getLocation();
4029 QualType DeclT;
4030 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
4031 DeclT = VD->getType();
4032 else if (TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(ND))
4033 DeclT = TDD->getUnderlyingType();
4034 else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND))
4035 DeclT = FD->getType();
4036 else
4037 llvm_unreachable("RewriteBlockPointerDecl(): Decl type not yet handled");
4038
4039 const char *startBuf = SM->getCharacterData(DeclLoc);
4040 const char *endBuf = startBuf;
4041 // scan backward (from the decl location) for the end of the previous decl.
4042 while (*startBuf != '^' && *startBuf != ';' && startBuf != MainFileStart)
4043 startBuf--;
4044 SourceLocation Start = DeclLoc.getLocWithOffset(startBuf-endBuf);
4045 std::string buf;
4046 unsigned OrigLength=0;
4047 // *startBuf != '^' if we are dealing with a pointer to function that
4048 // may take block argument types (which will be handled below).
4049 if (*startBuf == '^') {
4050 // Replace the '^' with '*', computing a negative offset.
4051 buf = '*';
4052 startBuf++;
4053 OrigLength++;
4054 }
4055 while (*startBuf != ')') {
4056 buf += *startBuf;
4057 startBuf++;
4058 OrigLength++;
4059 }
4060 buf += ')';
4061 OrigLength++;
4062
4063 if (PointerTypeTakesAnyBlockArguments(DeclT) ||
4064 PointerTypeTakesAnyObjCQualifiedType(DeclT)) {
4065 // Replace the '^' with '*' for arguments.
4066 // Replace id<P> with id/*<>*/
4067 DeclLoc = ND->getLocation();
4068 startBuf = SM->getCharacterData(DeclLoc);
4069 const char *argListBegin, *argListEnd;
4070 GetExtentOfArgList(startBuf, argListBegin, argListEnd);
4071 while (argListBegin < argListEnd) {
4072 if (*argListBegin == '^')
4073 buf += '*';
4074 else if (*argListBegin == '<') {
4075 buf += "/*";
4076 buf += *argListBegin++;
4077 OrigLength++;
4078 while (*argListBegin != '>') {
4079 buf += *argListBegin++;
4080 OrigLength++;
4081 }
4082 buf += *argListBegin;
4083 buf += "*/";
4084 }
4085 else
4086 buf += *argListBegin;
4087 argListBegin++;
4088 OrigLength++;
4089 }
4090 buf += ')';
4091 OrigLength++;
4092 }
4093 ReplaceText(Start, OrigLength, buf);
4094 }
4095
4096 /// SynthesizeByrefCopyDestroyHelper - This routine synthesizes:
4097 /// void __Block_byref_id_object_copy(struct Block_byref_id_object *dst,
4098 /// struct Block_byref_id_object *src) {
4099 /// _Block_object_assign (&_dest->object, _src->object,
4100 /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT
4101 /// [|BLOCK_FIELD_IS_WEAK]) // object
4102 /// _Block_object_assign(&_dest->object, _src->object,
4103 /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK
4104 /// [|BLOCK_FIELD_IS_WEAK]) // block
4105 /// }
4106 /// And:
4107 /// void __Block_byref_id_object_dispose(struct Block_byref_id_object *_src) {
4108 /// _Block_object_dispose(_src->object,
4109 /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT
4110 /// [|BLOCK_FIELD_IS_WEAK]) // object
4111 /// _Block_object_dispose(_src->object,
4112 /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK
4113 /// [|BLOCK_FIELD_IS_WEAK]) // block
4114 /// }
4115
4116 std::string RewriteObjC::SynthesizeByrefCopyDestroyHelper(VarDecl *VD,
4117 int flag) {
4118 std::string S;
4119 if (CopyDestroyCache.count(flag))
4120 return S;
4121 CopyDestroyCache.insert(flag);
4122 S = "static void __Block_byref_id_object_copy_";
4123 S += utostr(flag);
4124 S += "(void *dst, void *src) {\n";
4125
4126 // offset into the object pointer is computed as:
4127 // void * + void* + int + int + void* + void *
4128 unsigned IntSize =
4129 static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
4130 unsigned VoidPtrSize =
4131 static_cast<unsigned>(Context->getTypeSize(Context->VoidPtrTy));
4132
4133 unsigned offset = (VoidPtrSize*4 + IntSize + IntSize)/Context->getCharWidth();
4134 S += " _Block_object_assign((char*)dst + ";
4135 S += utostr(offset);
4136 S += ", *(void * *) ((char*)src + ";
4137 S += utostr(offset);
4138 S += "), ";
4139 S += utostr(flag);
4140 S += ");\n}\n";
4141
4142 S += "static void __Block_byref_id_object_dispose_";
4143 S += utostr(flag);
4144 S += "(void *src) {\n";
4145 S += " _Block_object_dispose(*(void * *) ((char*)src + ";
4146 S += utostr(offset);
4147 S += "), ";
4148 S += utostr(flag);
4149 S += ");\n}\n";
4150 return S;
4151 }
4152
4153 /// RewriteByRefVar - For each __block typex ND variable this routine transforms
4154 /// the declaration into:
4155 /// struct __Block_byref_ND {
4156 /// void *__isa; // NULL for everything except __weak pointers
4157 /// struct __Block_byref_ND *__forwarding;
4158 /// int32_t __flags;
4159 /// int32_t __size;
4160 /// void *__Block_byref_id_object_copy; // If variable is __block ObjC object
4161 /// void *__Block_byref_id_object_dispose; // If variable is __block ObjC object
4162 /// typex ND;
4163 /// };
4164 ///
4165 /// It then replaces declaration of ND variable with:
4166 /// struct __Block_byref_ND ND = {__isa=0B, __forwarding=&ND, __flags=some_flag,
4167 /// __size=sizeof(struct __Block_byref_ND),
4168 /// ND=initializer-if-any};
4169 ///
4170 ///
4171 void RewriteObjC::RewriteByRefVar(VarDecl *ND) {
4172 // Insert declaration for the function in which block literal is
4173 // used.
4174 if (CurFunctionDeclToDeclareForBlock)
4175 RewriteBlockLiteralFunctionDecl(CurFunctionDeclToDeclareForBlock);
4176 int flag = 0;
4177 int isa = 0;
4178 SourceLocation DeclLoc = ND->getTypeSpecStartLoc();
4179 if (DeclLoc.isInvalid())
4180 // If type location is missing, it is because of missing type (a warning).
4181 // Use variable's location which is good for this case.
4182 DeclLoc = ND->getLocation();
4183 const char *startBuf = SM->getCharacterData(DeclLoc);
4184 SourceLocation X = ND->getEndLoc();
4185 X = SM->getExpansionLoc(X);
4186 const char *endBuf = SM->getCharacterData(X);
4187 std::string Name(ND->getNameAsString());
4188 std::string ByrefType;
4189 RewriteByRefString(ByrefType, Name, ND, true);
4190 ByrefType += " {\n";
4191 ByrefType += " void *__isa;\n";
4192 RewriteByRefString(ByrefType, Name, ND);
4193 ByrefType += " *__forwarding;\n";
4194 ByrefType += " int __flags;\n";
4195 ByrefType += " int __size;\n";
4196 // Add void *__Block_byref_id_object_copy;
4197 // void *__Block_byref_id_object_dispose; if needed.
4198 QualType Ty = ND->getType();
4199 bool HasCopyAndDispose = Context->BlockRequiresCopying(Ty, ND);
4200 if (HasCopyAndDispose) {
4201 ByrefType += " void (*__Block_byref_id_object_copy)(void*, void*);\n";
4202 ByrefType += " void (*__Block_byref_id_object_dispose)(void*);\n";
4203 }
4204
4205 QualType T = Ty;
4206 (void)convertBlockPointerToFunctionPointer(T);
4207 T.getAsStringInternal(Name, Context->getPrintingPolicy());
4208
4209 ByrefType += " " + Name + ";\n";
4210 ByrefType += "};\n";
4211 // Insert this type in global scope. It is needed by helper function.
4212 SourceLocation FunLocStart;
4213 if (CurFunctionDef)
4214 FunLocStart = CurFunctionDef->getTypeSpecStartLoc();
4215 else {
4216 assert(CurMethodDef && "RewriteByRefVar - CurMethodDef is null");
4217 FunLocStart = CurMethodDef->getBeginLoc();
4218 }
4219 InsertText(FunLocStart, ByrefType);
4220 if (Ty.isObjCGCWeak()) {
4221 flag |= BLOCK_FIELD_IS_WEAK;
4222 isa = 1;
4223 }
4224
4225 if (HasCopyAndDispose) {
4226 flag = BLOCK_BYREF_CALLER;
4227 QualType Ty = ND->getType();
4228 // FIXME. Handle __weak variable (BLOCK_FIELD_IS_WEAK) as well.
4229 if (Ty->isBlockPointerType())
4230 flag |= BLOCK_FIELD_IS_BLOCK;
4231 else
4232 flag |= BLOCK_FIELD_IS_OBJECT;
4233 std::string HF = SynthesizeByrefCopyDestroyHelper(ND, flag);
4234 if (!HF.empty())
4235 InsertText(FunLocStart, HF);
4236 }
4237
4238 // struct __Block_byref_ND ND =
4239 // {0, &ND, some_flag, __size=sizeof(struct __Block_byref_ND),
4240 // initializer-if-any};
4241 bool hasInit = (ND->getInit() != nullptr);
4242 unsigned flags = 0;
4243 if (HasCopyAndDispose)
4244 flags |= BLOCK_HAS_COPY_DISPOSE;
4245 Name = ND->getNameAsString();
4246 ByrefType.clear();
4247 RewriteByRefString(ByrefType, Name, ND);
4248 std::string ForwardingCastType("(");
4249 ForwardingCastType += ByrefType + " *)";
4250 if (!hasInit) {
4251 ByrefType += " " + Name + " = {(void*)";
4252 ByrefType += utostr(isa);
4253 ByrefType += "," + ForwardingCastType + "&" + Name + ", ";
4254 ByrefType += utostr(flags);
4255 ByrefType += ", ";
4256 ByrefType += "sizeof(";
4257 RewriteByRefString(ByrefType, Name, ND);
4258 ByrefType += ")";
4259 if (HasCopyAndDispose) {
4260 ByrefType += ", __Block_byref_id_object_copy_";
4261 ByrefType += utostr(flag);
4262 ByrefType += ", __Block_byref_id_object_dispose_";
4263 ByrefType += utostr(flag);
4264 }
4265 ByrefType += "};\n";
4266 unsigned nameSize = Name.size();
4267 // for block or function pointer declaration. Name is already
4268 // part of the declaration.
4269 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType())
4270 nameSize = 1;
4271 ReplaceText(DeclLoc, endBuf-startBuf+nameSize, ByrefType);
4272 }
4273 else {
4274 SourceLocation startLoc;
4275 Expr *E = ND->getInit();
4276 if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E))
4277 startLoc = ECE->getLParenLoc();
4278 else
4279 startLoc = E->getBeginLoc();
4280 startLoc = SM->getExpansionLoc(startLoc);
4281 endBuf = SM->getCharacterData(startLoc);
4282 ByrefType += " " + Name;
4283 ByrefType += " = {(void*)";
4284 ByrefType += utostr(isa);
4285 ByrefType += "," + ForwardingCastType + "&" + Name + ", ";
4286 ByrefType += utostr(flags);
4287 ByrefType += ", ";
4288 ByrefType += "sizeof(";
4289 RewriteByRefString(ByrefType, Name, ND);
4290 ByrefType += "), ";
4291 if (HasCopyAndDispose) {
4292 ByrefType += "__Block_byref_id_object_copy_";
4293 ByrefType += utostr(flag);
4294 ByrefType += ", __Block_byref_id_object_dispose_";
4295 ByrefType += utostr(flag);
4296 ByrefType += ", ";
4297 }
4298 ReplaceText(DeclLoc, endBuf-startBuf, ByrefType);
4299
4300 // Complete the newly synthesized compound expression by inserting a right
4301 // curly brace before the end of the declaration.
4302 // FIXME: This approach avoids rewriting the initializer expression. It
4303 // also assumes there is only one declarator. For example, the following
4304 // isn't currently supported by this routine (in general):
4305 //
4306 // double __block BYREFVAR = 1.34, BYREFVAR2 = 1.37;
4307 //
4308 const char *startInitializerBuf = SM->getCharacterData(startLoc);
4309 const char *semiBuf = strchr(startInitializerBuf, ';');
4310 assert((*semiBuf == ';') && "RewriteByRefVar: can't find ';'");
4311 SourceLocation semiLoc =
4312 startLoc.getLocWithOffset(semiBuf-startInitializerBuf);
4313
4314 InsertText(semiLoc, "}");
4315 }
4316 }
4317
4318 void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) {
4319 // Add initializers for any closure decl refs.
4320 GetBlockDeclRefExprs(Exp->getBody());
4321 if (BlockDeclRefs.size()) {
4322 // Unique all "by copy" declarations.
4323 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
4324 if (!BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>()) {
4325 if (!BlockByCopyDeclsPtrSet.count(BlockDeclRefs[i]->getDecl())) {
4326 BlockByCopyDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl());
4327 BlockByCopyDecls.push_back(BlockDeclRefs[i]->getDecl());
4328 }
4329 }
4330 // Unique all "by ref" declarations.
4331 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
4332 if (BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>()) {
4333 if (!BlockByRefDeclsPtrSet.count(BlockDeclRefs[i]->getDecl())) {
4334 BlockByRefDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl());
4335 BlockByRefDecls.push_back(BlockDeclRefs[i]->getDecl());
4336 }
4337 }
4338 // Find any imported blocks...they will need special attention.
4339 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
4340 if (BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() ||
4341 BlockDeclRefs[i]->getType()->isObjCObjectPointerType() ||
4342 BlockDeclRefs[i]->getType()->isBlockPointerType())
4343 ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
4344 }
4345 }
4346
4347 FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(StringRef name) {
4348 IdentifierInfo *ID = &Context->Idents.get(name);
4349 QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy);
4350 return FunctionDecl::Create(*Context, TUDecl, SourceLocation(),
4351 SourceLocation(), ID, FType, nullptr, SC_Extern,
4352 false, false);
4353 }
4354
4355 Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp,
4356 const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs) {
4357 const BlockDecl *block = Exp->getBlockDecl();
4358 Blocks.push_back(Exp);
4359
4360 CollectBlockDeclRefInfo(Exp);
4361
4362 // Add inner imported variables now used in current block.
4363 int countOfInnerDecls = 0;
4364 if (!InnerBlockDeclRefs.empty()) {
4365 for (unsigned i = 0; i < InnerBlockDeclRefs.size(); i++) {
4366 DeclRefExpr *Exp = InnerBlockDeclRefs[i];
4367 ValueDecl *VD = Exp->getDecl();
4368 if (!VD->hasAttr<BlocksAttr>() && !BlockByCopyDeclsPtrSet.count(VD)) {
4369 // We need to save the copied-in variables in nested
4370 // blocks because it is needed at the end for some of the API generations.
4371 // See SynthesizeBlockLiterals routine.
4372 InnerDeclRefs.push_back(Exp); countOfInnerDecls++;
4373 BlockDeclRefs.push_back(Exp);
4374 BlockByCopyDeclsPtrSet.insert(VD);
4375 BlockByCopyDecls.push_back(VD);
4376 }
4377 if (VD->hasAttr<BlocksAttr>() && !BlockByRefDeclsPtrSet.count(VD)) {
4378 InnerDeclRefs.push_back(Exp); countOfInnerDecls++;
4379 BlockDeclRefs.push_back(Exp);
4380 BlockByRefDeclsPtrSet.insert(VD);
4381 BlockByRefDecls.push_back(VD);
4382 }
4383 }
4384 // Find any imported blocks...they will need special attention.
4385 for (unsigned i = 0; i < InnerBlockDeclRefs.size(); i++)
4386 if (InnerBlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() ||
4387 InnerBlockDeclRefs[i]->getType()->isObjCObjectPointerType() ||
4388 InnerBlockDeclRefs[i]->getType()->isBlockPointerType())
4389 ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl());
4390 }
4391 InnerDeclRefsCount.push_back(countOfInnerDecls);
4392
4393 std::string FuncName;
4394
4395 if (CurFunctionDef)
4396 FuncName = CurFunctionDef->getNameAsString();
4397 else if (CurMethodDef)
4398 BuildUniqueMethodName(FuncName, CurMethodDef);
4399 else if (GlobalVarDecl)
4400 FuncName = std::string(GlobalVarDecl->getNameAsString());
4401
4402 std::string BlockNumber = utostr(Blocks.size()-1);
4403
4404 std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber;
4405 std::string Func = "__" + FuncName + "_block_func_" + BlockNumber;
4406
4407 // Get a pointer to the function type so we can cast appropriately.
4408 QualType BFT = convertFunctionTypeOfBlocks(Exp->getFunctionType());
4409 QualType FType = Context->getPointerType(BFT);
4410
4411 FunctionDecl *FD;
4412 Expr *NewRep;
4413
4414 // Simulate a constructor call...
4415 FD = SynthBlockInitFunctionDecl(Tag);
4416 DeclRefExpr *DRE = new (Context)
4417 DeclRefExpr(*Context, FD, false, FType, VK_RValue, SourceLocation());
4418
4419 SmallVector<Expr*, 4> InitExprs;
4420
4421 // Initialize the block function.
4422 FD = SynthBlockInitFunctionDecl(Func);
4423 DeclRefExpr *Arg = new (Context) DeclRefExpr(
4424 *Context, FD, false, FD->getType(), VK_LValue, SourceLocation());
4425 CastExpr *castExpr =
4426 NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, CK_BitCast, Arg);
4427 InitExprs.push_back(castExpr);
4428
4429 // Initialize the block descriptor.
4430 std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA";
4431
4432 VarDecl *NewVD = VarDecl::Create(
4433 *Context, TUDecl, SourceLocation(), SourceLocation(),
4434 &Context->Idents.get(DescData), Context->VoidPtrTy, nullptr, SC_Static);
4435 UnaryOperator *DescRefExpr = new (Context) UnaryOperator(
4436 new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy,
4437 VK_LValue, SourceLocation()),
4438 UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_RValue,
4439 OK_Ordinary, SourceLocation(), false);
4440 InitExprs.push_back(DescRefExpr);
4441
4442 // Add initializers for any closure decl refs.
4443 if (BlockDeclRefs.size()) {
4444 Expr *Exp;
4445 // Output all "by copy" declarations.
4446 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
4447 E = BlockByCopyDecls.end(); I != E; ++I) {
4448 if (isObjCType((*I)->getType())) {
4449 // FIXME: Conform to ABI ([[obj retain] autorelease]).
4450 FD = SynthBlockInitFunctionDecl((*I)->getName());
4451 Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(),
4452 VK_LValue, SourceLocation());
4453 if (HasLocalVariableExternalStorage(*I)) {
4454 QualType QT = (*I)->getType();
4455 QT = Context->getPointerType(QT);
4456 Exp = new (Context) UnaryOperator(Exp, UO_AddrOf, QT, VK_RValue,
4457 OK_Ordinary, SourceLocation(),
4458 false);
4459 }
4460 } else if (isTopLevelBlockPointerType((*I)->getType())) {
4461 FD = SynthBlockInitFunctionDecl((*I)->getName());
4462 Arg = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(),
4463 VK_LValue, SourceLocation());
4464 Exp = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, CK_BitCast,
4465 Arg);
4466 } else {
4467 FD = SynthBlockInitFunctionDecl((*I)->getName());
4468 Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(),
4469 VK_LValue, SourceLocation());
4470 if (HasLocalVariableExternalStorage(*I)) {
4471 QualType QT = (*I)->getType();
4472 QT = Context->getPointerType(QT);
4473 Exp = new (Context) UnaryOperator(Exp, UO_AddrOf, QT, VK_RValue,
4474 OK_Ordinary, SourceLocation(),
4475 false);
4476 }
4477 }
4478 InitExprs.push_back(Exp);
4479 }
4480 // Output all "by ref" declarations.
4481 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
4482 E = BlockByRefDecls.end(); I != E; ++I) {
4483 ValueDecl *ND = (*I);
4484 std::string Name(ND->getNameAsString());
4485 std::string RecName;
4486 RewriteByRefString(RecName, Name, ND, true);
4487 IdentifierInfo *II = &Context->Idents.get(RecName.c_str()
4488 + sizeof("struct"));
4489 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
4490 SourceLocation(), SourceLocation(),
4491 II);
4492 assert(RD && "SynthBlockInitExpr(): Can't find RecordDecl");
4493 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
4494
4495 FD = SynthBlockInitFunctionDecl((*I)->getName());
4496 Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(),
4497 VK_LValue, SourceLocation());
4498 bool isNestedCapturedVar = false;
4499 if (block)
4500 for (const auto &CI : block->captures()) {
4501 const VarDecl *variable = CI.getVariable();
4502 if (variable == ND && CI.isNested()) {
4503 assert (CI.isByRef() &&
4504 "SynthBlockInitExpr - captured block variable is not byref");
4505 isNestedCapturedVar = true;
4506 break;
4507 }
4508 }
4509 // captured nested byref variable has its address passed. Do not take
4510 // its address again.
4511 if (!isNestedCapturedVar)
4512 Exp = new (Context) UnaryOperator(
4513 Exp, UO_AddrOf, Context->getPointerType(Exp->getType()), VK_RValue,
4514 OK_Ordinary, SourceLocation(), false);
4515 Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp);
4516 InitExprs.push_back(Exp);
4517 }
4518 }
4519 if (ImportedBlockDecls.size()) {
4520 // generate BLOCK_HAS_COPY_DISPOSE(have helper funcs) | BLOCK_HAS_DESCRIPTOR
4521 int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR);
4522 unsigned IntSize =
4523 static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
4524 Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag),
4525 Context->IntTy, SourceLocation());
4526 InitExprs.push_back(FlagExp);
4527 }
4528 NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue,
4529 SourceLocation());
4530 NewRep = new (Context) UnaryOperator(
4531 NewRep, UO_AddrOf, Context->getPointerType(NewRep->getType()), VK_RValue,
4532 OK_Ordinary, SourceLocation(), false);
4533 NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast,
4534 NewRep);
4535 BlockDeclRefs.clear();
4536 BlockByRefDecls.clear();
4537 BlockByRefDeclsPtrSet.clear();
4538 BlockByCopyDecls.clear();
4539 BlockByCopyDeclsPtrSet.clear();
4540 ImportedBlockDecls.clear();
4541 return NewRep;
4542 }
4543
4544 bool RewriteObjC::IsDeclStmtInForeachHeader(DeclStmt *DS) {
4545 if (const ObjCForCollectionStmt * CS =
4546 dyn_cast<ObjCForCollectionStmt>(Stmts.back()))
4547 return CS->getElement() == DS;
4548 return false;
4549 }
4550
4551 //===----------------------------------------------------------------------===//
4552 // Function Body / Expression rewriting
4553 //===----------------------------------------------------------------------===//
4554
4555 Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
4556 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
4557 isa<DoStmt>(S) || isa<ForStmt>(S))
4558 Stmts.push_back(S);
4559 else if (isa<ObjCForCollectionStmt>(S)) {
4560 Stmts.push_back(S);
4561 ObjCBcLabelNo.push_back(++BcLabelCount);
4562 }
4563
4564 // Pseudo-object operations and ivar references need special
4565 // treatment because we're going to recursively rewrite them.
4566 if (PseudoObjectExpr *PseudoOp = dyn_cast<PseudoObjectExpr>(S)) {
4567 if (isa<BinaryOperator>(PseudoOp->getSyntacticForm())) {
4568 return RewritePropertyOrImplicitSetter(PseudoOp);
4569 } else {
4570 return RewritePropertyOrImplicitGetter(PseudoOp);
4571 }
4572 } else if (ObjCIvarRefExpr *IvarRefExpr = dyn_cast<ObjCIvarRefExpr>(S)) {
4573 return RewriteObjCIvarRefExpr(IvarRefExpr);
4574 }
4575
4576 SourceRange OrigStmtRange = S->getSourceRange();
4577
4578 // Perform a bottom up rewrite of all children.
4579 for (Stmt *&childStmt : S->children())
4580 if (childStmt) {
4581 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt);
4582 if (newStmt) {
4583 childStmt = newStmt;
4584 }
4585 }
4586
4587 if (BlockExpr *BE = dyn_cast<BlockExpr>(S)) {
4588 SmallVector<DeclRefExpr *, 8> InnerBlockDeclRefs;
4589 llvm::SmallPtrSet<const DeclContext *, 8> InnerContexts;
4590 InnerContexts.insert(BE->getBlockDecl());
4591 ImportedLocalExternalDecls.clear();
4592 GetInnerBlockDeclRefExprs(BE->getBody(),
4593 InnerBlockDeclRefs, InnerContexts);
4594 // Rewrite the block body in place.
4595 Stmt *SaveCurrentBody = CurrentBody;
4596 CurrentBody = BE->getBody();
4597 PropParentMap = nullptr;
4598 // block literal on rhs of a property-dot-sytax assignment
4599 // must be replaced by its synthesize ast so getRewrittenText
4600 // works as expected. In this case, what actually ends up on RHS
4601 // is the blockTranscribed which is the helper function for the
4602 // block literal; as in: self.c = ^() {[ace ARR];};
4603 bool saveDisableReplaceStmt = DisableReplaceStmt;
4604 DisableReplaceStmt = false;
4605 RewriteFunctionBodyOrGlobalInitializer(BE->getBody());
4606 DisableReplaceStmt = saveDisableReplaceStmt;
4607 CurrentBody = SaveCurrentBody;
4608 PropParentMap = nullptr;
4609 ImportedLocalExternalDecls.clear();
4610 // Now we snarf the rewritten text and stash it away for later use.
4611 std::string Str = Rewrite.getRewrittenText(BE->getSourceRange());
4612 RewrittenBlockExprs[BE] = Str;
4613
4614 Stmt *blockTranscribed = SynthBlockInitExpr(BE, InnerBlockDeclRefs);
4615
4616 //blockTranscribed->dump();
4617 ReplaceStmt(S, blockTranscribed);
4618 return blockTranscribed;
4619 }
4620 // Handle specific things.
4621 if (ObjCEncodeExpr *AtEncode = dyn_cast<ObjCEncodeExpr>(S))
4622 return RewriteAtEncode(AtEncode);
4623
4624 if (ObjCSelectorExpr *AtSelector = dyn_cast<ObjCSelectorExpr>(S))
4625 return RewriteAtSelector(AtSelector);
4626
4627 if (ObjCStringLiteral *AtString = dyn_cast<ObjCStringLiteral>(S))
4628 return RewriteObjCStringLiteral(AtString);
4629
4630 if (ObjCMessageExpr *MessExpr = dyn_cast<ObjCMessageExpr>(S)) {
4631 #if 0
4632 // Before we rewrite it, put the original message expression in a comment.
4633 SourceLocation startLoc = MessExpr->getBeginLoc();
4634 SourceLocation endLoc = MessExpr->getEndLoc();
4635
4636 const char *startBuf = SM->getCharacterData(startLoc);
4637 const char *endBuf = SM->getCharacterData(endLoc);
4638
4639 std::string messString;
4640 messString += "// ";
4641 messString.append(startBuf, endBuf-startBuf+1);
4642 messString += "\n";
4643
4644 // FIXME: Missing definition of
4645 // InsertText(clang::SourceLocation, char const*, unsigned int).
4646 // InsertText(startLoc, messString);
4647 // Tried this, but it didn't work either...
4648 // ReplaceText(startLoc, 0, messString.c_str(), messString.size());
4649 #endif
4650 return RewriteMessageExpr(MessExpr);
4651 }
4652
4653 if (ObjCAtTryStmt *StmtTry = dyn_cast<ObjCAtTryStmt>(S))
4654 return RewriteObjCTryStmt(StmtTry);
4655
4656 if (ObjCAtSynchronizedStmt *StmtTry = dyn_cast<ObjCAtSynchronizedStmt>(S))
4657 return RewriteObjCSynchronizedStmt(StmtTry);
4658
4659 if (ObjCAtThrowStmt *StmtThrow = dyn_cast<ObjCAtThrowStmt>(S))
4660 return RewriteObjCThrowStmt(StmtThrow);
4661
4662 if (ObjCProtocolExpr *ProtocolExp = dyn_cast<ObjCProtocolExpr>(S))
4663 return RewriteObjCProtocolExpr(ProtocolExp);
4664
4665 if (ObjCForCollectionStmt *StmtForCollection =
4666 dyn_cast<ObjCForCollectionStmt>(S))
4667 return RewriteObjCForCollectionStmt(StmtForCollection,
4668 OrigStmtRange.getEnd());
4669 if (BreakStmt *StmtBreakStmt =
4670 dyn_cast<BreakStmt>(S))
4671 return RewriteBreakStmt(StmtBreakStmt);
4672 if (ContinueStmt *StmtContinueStmt =
4673 dyn_cast<ContinueStmt>(S))
4674 return RewriteContinueStmt(StmtContinueStmt);
4675
4676 // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls
4677 // and cast exprs.
4678 if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
4679 // FIXME: What we're doing here is modifying the type-specifier that
4680 // precedes the first Decl. In the future the DeclGroup should have
4681 // a separate type-specifier that we can rewrite.
4682 // NOTE: We need to avoid rewriting the DeclStmt if it is within
4683 // the context of an ObjCForCollectionStmt. For example:
4684 // NSArray *someArray;
4685 // for (id <FooProtocol> index in someArray) ;
4686 // This is because RewriteObjCForCollectionStmt() does textual rewriting
4687 // and it depends on the original text locations/positions.
4688 if (Stmts.empty() || !IsDeclStmtInForeachHeader(DS))
4689 RewriteObjCQualifiedInterfaceTypes(*DS->decl_begin());
4690
4691 // Blocks rewrite rules.
4692 for (auto *SD : DS->decls()) {
4693 if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) {
4694 if (isTopLevelBlockPointerType(ND->getType()))
4695 RewriteBlockPointerDecl(ND);
4696 else if (ND->getType()->isFunctionPointerType())
4697 CheckFunctionPointerDecl(ND->getType(), ND);
4698 if (VarDecl *VD = dyn_cast<VarDecl>(SD)) {
4699 if (VD->hasAttr<BlocksAttr>()) {
4700 static unsigned uniqueByrefDeclCount = 0;
4701 assert(!BlockByRefDeclNo.count(ND) &&
4702 "RewriteFunctionBodyOrGlobalInitializer: Duplicate byref decl");
4703 BlockByRefDeclNo[ND] = uniqueByrefDeclCount++;
4704 RewriteByRefVar(VD);
4705 }
4706 else
4707 RewriteTypeOfDecl(VD);
4708 }
4709 }
4710 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) {
4711 if (isTopLevelBlockPointerType(TD->getUnderlyingType()))
4712 RewriteBlockPointerDecl(TD);
4713 else if (TD->getUnderlyingType()->isFunctionPointerType())
4714 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
4715 }
4716 }
4717 }
4718
4719 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S))
4720 RewriteObjCQualifiedInterfaceTypes(CE);
4721
4722 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
4723 isa<DoStmt>(S) || isa<ForStmt>(S)) {
4724 assert(!Stmts.empty() && "Statement stack is empty");
4725 assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) ||
4726 isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back()))
4727 && "Statement stack mismatch");
4728 Stmts.pop_back();
4729 }
4730 // Handle blocks rewriting.
4731 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) {
4732 ValueDecl *VD = DRE->getDecl();
4733 if (VD->hasAttr<BlocksAttr>())
4734 return RewriteBlockDeclRefExpr(DRE);
4735 if (HasLocalVariableExternalStorage(VD))
4736 return RewriteLocalVariableExternalStorage(DRE);
4737 }
4738
4739 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
4740 if (CE->getCallee()->getType()->isBlockPointerType()) {
4741 Stmt *BlockCall = SynthesizeBlockCall(CE, CE->getCallee());
4742 ReplaceStmt(S, BlockCall);
4743 return BlockCall;
4744 }
4745 }
4746 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) {
4747 RewriteCastExpr(CE);
4748 }
4749 #if 0
4750 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) {
4751 CastExpr *Replacement = new (Context) CastExpr(ICE->getType(),
4752 ICE->getSubExpr(),
4753 SourceLocation());
4754 // Get the new text.
4755 std::string SStr;
4756 llvm::raw_string_ostream Buf(SStr);
4757 Replacement->printPretty(Buf);
4758 const std::string &Str = Buf.str();
4759
4760 printf("CAST = %s\n", &Str[0]);
4761 InsertText(ICE->getSubExpr()->getBeginLoc(), Str);
4762 delete S;
4763 return Replacement;
4764 }
4765 #endif
4766 // Return this stmt unmodified.
4767 return S;
4768 }
4769
4770 void RewriteObjC::RewriteRecordBody(RecordDecl *RD) {
4771 for (auto *FD : RD->fields()) {
4772 if (isTopLevelBlockPointerType(FD->getType()))
4773 RewriteBlockPointerDecl(FD);
4774 if (FD->getType()->isObjCQualifiedIdType() ||
4775 FD->getType()->isObjCQualifiedInterfaceType())
4776 RewriteObjCQualifiedInterfaceTypes(FD);
4777 }
4778 }
4779
4780 /// HandleDeclInMainFile - This is called for each top-level decl defined in the
4781 /// main file of the input.
4782 void RewriteObjC::HandleDeclInMainFile(Decl *D) {
4783 switch (D->getKind()) {
4784 case Decl::Function: {
4785 FunctionDecl *FD = cast<FunctionDecl>(D);
4786 if (FD->isOverloadedOperator())
4787 return;
4788
4789 // Since function prototypes don't have ParmDecl's, we check the function
4790 // prototype. This enables us to rewrite function declarations and
4791 // definitions using the same code.
4792 RewriteBlocksInFunctionProtoType(FD->getType(), FD);
4793
4794 if (!FD->isThisDeclarationADefinition())
4795 break;
4796
4797 // FIXME: If this should support Obj-C++, support CXXTryStmt
4798 if (CompoundStmt *Body = dyn_cast_or_null<CompoundStmt>(FD->getBody())) {
4799 CurFunctionDef = FD;
4800 CurFunctionDeclToDeclareForBlock = FD;
4801 CurrentBody = Body;
4802 Body =
4803 cast_or_null<CompoundStmt>(RewriteFunctionBodyOrGlobalInitializer(Body));
4804 FD->setBody(Body);
4805 CurrentBody = nullptr;
4806 if (PropParentMap) {
4807 delete PropParentMap;
4808 PropParentMap = nullptr;
4809 }
4810 // This synthesizes and inserts the block "impl" struct, invoke function,
4811 // and any copy/dispose helper functions.
4812 InsertBlockLiteralsWithinFunction(FD);
4813 CurFunctionDef = nullptr;
4814 CurFunctionDeclToDeclareForBlock = nullptr;
4815 }
4816 break;
4817 }
4818 case Decl::ObjCMethod: {
4819 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D);
4820 if (CompoundStmt *Body = MD->getCompoundBody()) {
4821 CurMethodDef = MD;
4822 CurrentBody = Body;
4823 Body =
4824 cast_or_null<CompoundStmt>(RewriteFunctionBodyOrGlobalInitializer(Body));
4825 MD->setBody(Body);
4826 CurrentBody = nullptr;
4827 if (PropParentMap) {
4828 delete PropParentMap;
4829 PropParentMap = nullptr;
4830 }
4831 InsertBlockLiteralsWithinMethod(MD);
4832 CurMethodDef = nullptr;
4833 }
4834 break;
4835 }
4836 case Decl::ObjCImplementation: {
4837 ObjCImplementationDecl *CI = cast<ObjCImplementationDecl>(D);
4838 ClassImplementation.push_back(CI);
4839 break;
4840 }
4841 case Decl::ObjCCategoryImpl: {
4842 ObjCCategoryImplDecl *CI = cast<ObjCCategoryImplDecl>(D);
4843 CategoryImplementation.push_back(CI);
4844 break;
4845 }
4846 case Decl::Var: {
4847 VarDecl *VD = cast<VarDecl>(D);
4848 RewriteObjCQualifiedInterfaceTypes(VD);
4849 if (isTopLevelBlockPointerType(VD->getType()))
4850 RewriteBlockPointerDecl(VD);
4851 else if (VD->getType()->isFunctionPointerType()) {
4852 CheckFunctionPointerDecl(VD->getType(), VD);
4853 if (VD->getInit()) {
4854 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) {
4855 RewriteCastExpr(CE);
4856 }
4857 }
4858 } else if (VD->getType()->isRecordType()) {
4859 RecordDecl *RD = VD->getType()->castAs<RecordType>()->getDecl();
4860 if (RD->isCompleteDefinition())
4861 RewriteRecordBody(RD);
4862 }
4863 if (VD->getInit()) {
4864 GlobalVarDecl = VD;
4865 CurrentBody = VD->getInit();
4866 RewriteFunctionBodyOrGlobalInitializer(VD->getInit());
4867 CurrentBody = nullptr;
4868 if (PropParentMap) {
4869 delete PropParentMap;
4870 PropParentMap = nullptr;
4871 }
4872 SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), VD->getName());
4873 GlobalVarDecl = nullptr;
4874
4875 // This is needed for blocks.
4876 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) {
4877 RewriteCastExpr(CE);
4878 }
4879 }
4880 break;
4881 }
4882 case Decl::TypeAlias:
4883 case Decl::Typedef: {
4884 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
4885 if (isTopLevelBlockPointerType(TD->getUnderlyingType()))
4886 RewriteBlockPointerDecl(TD);
4887 else if (TD->getUnderlyingType()->isFunctionPointerType())
4888 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
4889 }
4890 break;
4891 }
4892 case Decl::CXXRecord:
4893 case Decl::Record: {
4894 RecordDecl *RD = cast<RecordDecl>(D);
4895 if (RD->isCompleteDefinition())
4896 RewriteRecordBody(RD);
4897 break;
4898 }
4899 default:
4900 break;
4901 }
4902 // Nothing yet.
4903 }
4904
4905 void RewriteObjC::HandleTranslationUnit(ASTContext &C) {
4906 if (Diags.hasErrorOccurred())
4907 return;
4908
4909 RewriteInclude();
4910
4911 // Here's a great place to add any extra declarations that may be needed.
4912 // Write out meta data for each @protocol(<expr>).
4913 for (ObjCProtocolDecl *ProtDecl : ProtocolExprDecls)
4914 RewriteObjCProtocolMetaData(ProtDecl, "", "", Preamble);
4915
4916 InsertText(SM->getLocForStartOfFile(MainFileID), Preamble, false);
4917 if (ClassImplementation.size() || CategoryImplementation.size())
4918 RewriteImplementations();
4919
4920 // Get the buffer corresponding to MainFileID. If we haven't changed it, then
4921 // we are done.
4922 if (const RewriteBuffer *RewriteBuf =
4923 Rewrite.getRewriteBufferFor(MainFileID)) {
4924 //printf("Changed:\n");
4925 *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end());
4926 } else {
4927 llvm::errs() << "No changes\n";
4928 }
4929
4930 if (ClassImplementation.size() || CategoryImplementation.size() ||
4931 ProtocolExprDecls.size()) {
4932 // Rewrite Objective-c meta data*
4933 std::string ResultStr;
4934 RewriteMetaDataIntoBuffer(ResultStr);
4935 // Emit metadata.
4936 *OutFile << ResultStr;
4937 }
4938 OutFile->flush();
4939 }
4940
4941 void RewriteObjCFragileABI::Initialize(ASTContext &context) {
4942 InitializeCommon(context);
4943
4944 // declaring objc_selector outside the parameter list removes a silly
4945 // scope related warning...
4946 if (IsHeader)
4947 Preamble = "#pragma once\n";
4948 Preamble += "struct objc_selector; struct objc_class;\n";
4949 Preamble += "struct __rw_objc_super { struct objc_object *object; ";
4950 Preamble += "struct objc_object *superClass; ";
4951 if (LangOpts.MicrosoftExt) {
4952 // Add a constructor for creating temporary objects.
4953 Preamble += "__rw_objc_super(struct objc_object *o, struct objc_object *s) "
4954 ": ";
4955 Preamble += "object(o), superClass(s) {} ";
4956 }
4957 Preamble += "};\n";
4958 Preamble += "#ifndef _REWRITER_typedef_Protocol\n";
4959 Preamble += "typedef struct objc_object Protocol;\n";
4960 Preamble += "#define _REWRITER_typedef_Protocol\n";
4961 Preamble += "#endif\n";
4962 if (LangOpts.MicrosoftExt) {
4963 Preamble += "#define __OBJC_RW_DLLIMPORT extern \"C\" __declspec(dllimport)\n";
4964 Preamble += "#define __OBJC_RW_STATICIMPORT extern \"C\"\n";
4965 } else
4966 Preamble += "#define __OBJC_RW_DLLIMPORT extern\n";
4967 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSend";
4968 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
4969 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSendSuper";
4970 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n";
4971 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object* objc_msgSend_stret";
4972 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
4973 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object* objc_msgSendSuper_stret";
4974 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n";
4975 Preamble += "__OBJC_RW_DLLIMPORT double objc_msgSend_fpret";
4976 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
4977 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_getClass";
4978 Preamble += "(const char *);\n";
4979 Preamble += "__OBJC_RW_DLLIMPORT struct objc_class *class_getSuperclass";
4980 Preamble += "(struct objc_class *);\n";
4981 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_getMetaClass";
4982 Preamble += "(const char *);\n";
4983 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_throw(struct objc_object *);\n";
4984 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_try_enter(void *);\n";
4985 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_try_exit(void *);\n";
4986 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_exception_extract(void *);\n";
4987 Preamble += "__OBJC_RW_DLLIMPORT int objc_exception_match";
4988 Preamble += "(struct objc_class *, struct objc_object *);\n";
4989 // @synchronized hooks.
4990 Preamble += "__OBJC_RW_DLLIMPORT int objc_sync_enter(struct objc_object *);\n";
4991 Preamble += "__OBJC_RW_DLLIMPORT int objc_sync_exit(struct objc_object *);\n";
4992 Preamble += "__OBJC_RW_DLLIMPORT Protocol *objc_getProtocol(const char *);\n";
4993 Preamble += "#ifndef __FASTENUMERATIONSTATE\n";
4994 Preamble += "struct __objcFastEnumerationState {\n\t";
4995 Preamble += "unsigned long state;\n\t";
4996 Preamble += "void **itemsPtr;\n\t";
4997 Preamble += "unsigned long *mutationsPtr;\n\t";
4998 Preamble += "unsigned long extra[5];\n};\n";
4999 Preamble += "__OBJC_RW_DLLIMPORT void objc_enumerationMutation(struct objc_object *);\n";
5000 Preamble += "#define __FASTENUMERATIONSTATE\n";
5001 Preamble += "#endif\n";
5002 Preamble += "#ifndef __NSCONSTANTSTRINGIMPL\n";
5003 Preamble += "struct __NSConstantStringImpl {\n";
5004 Preamble += " int *isa;\n";
5005 Preamble += " int flags;\n";
5006 Preamble += " char *str;\n";
5007 Preamble += " long length;\n";
5008 Preamble += "};\n";
5009 Preamble += "#ifdef CF_EXPORT_CONSTANT_STRING\n";
5010 Preamble += "extern \"C\" __declspec(dllexport) int __CFConstantStringClassReference[];\n";
5011 Preamble += "#else\n";
5012 Preamble += "__OBJC_RW_DLLIMPORT int __CFConstantStringClassReference[];\n";
5013 Preamble += "#endif\n";
5014 Preamble += "#define __NSCONSTANTSTRINGIMPL\n";
5015 Preamble += "#endif\n";
5016 // Blocks preamble.
5017 Preamble += "#ifndef BLOCK_IMPL\n";
5018 Preamble += "#define BLOCK_IMPL\n";
5019 Preamble += "struct __block_impl {\n";
5020 Preamble += " void *isa;\n";
5021 Preamble += " int Flags;\n";
5022 Preamble += " int Reserved;\n";
5023 Preamble += " void *FuncPtr;\n";
5024 Preamble += "};\n";
5025 Preamble += "// Runtime copy/destroy helper functions (from Block_private.h)\n";
5026 Preamble += "#ifdef __OBJC_EXPORT_BLOCKS\n";
5027 Preamble += "extern \"C\" __declspec(dllexport) "
5028 "void _Block_object_assign(void *, const void *, const int);\n";
5029 Preamble += "extern \"C\" __declspec(dllexport) void _Block_object_dispose(const void *, const int);\n";
5030 Preamble += "extern \"C\" __declspec(dllexport) void *_NSConcreteGlobalBlock[32];\n";
5031 Preamble += "extern \"C\" __declspec(dllexport) void *_NSConcreteStackBlock[32];\n";
5032 Preamble += "#else\n";
5033 Preamble += "__OBJC_RW_DLLIMPORT void _Block_object_assign(void *, const void *, const int);\n";
5034 Preamble += "__OBJC_RW_DLLIMPORT void _Block_object_dispose(const void *, const int);\n";
5035 Preamble += "__OBJC_RW_DLLIMPORT void *_NSConcreteGlobalBlock[32];\n";
5036 Preamble += "__OBJC_RW_DLLIMPORT void *_NSConcreteStackBlock[32];\n";
5037 Preamble += "#endif\n";
5038 Preamble += "#endif\n";
5039 if (LangOpts.MicrosoftExt) {
5040 Preamble += "#undef __OBJC_RW_DLLIMPORT\n";
5041 Preamble += "#undef __OBJC_RW_STATICIMPORT\n";
5042 Preamble += "#ifndef KEEP_ATTRIBUTES\n"; // We use this for clang tests.
5043 Preamble += "#define __attribute__(X)\n";
5044 Preamble += "#endif\n";
5045 Preamble += "#define __weak\n";
5046 }
5047 else {
5048 Preamble += "#define __block\n";
5049 Preamble += "#define __weak\n";
5050 }
5051 // NOTE! Windows uses LLP64 for 64bit mode. So, cast pointer to long long
5052 // as this avoids warning in any 64bit/32bit compilation model.
5053 Preamble += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)\n";
5054 }
5055
5056 /// RewriteIvarOffsetComputation - This routine synthesizes computation of
5057 /// ivar offset.
5058 void RewriteObjCFragileABI::RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,
5059 std::string &Result) {
5060 if (ivar->isBitField()) {
5061 // FIXME: The hack below doesn't work for bitfields. For now, we simply
5062 // place all bitfields at offset 0.
5063 Result += "0";
5064 } else {
5065 Result += "__OFFSETOFIVAR__(struct ";
5066 Result += ivar->getContainingInterface()->getNameAsString();
5067 if (LangOpts.MicrosoftExt)
5068 Result += "_IMPL";
5069 Result += ", ";
5070 Result += ivar->getNameAsString();
5071 Result += ")";
5072 }
5073 }
5074
5075 /// RewriteObjCProtocolMetaData - Rewrite protocols meta-data.
5076 void RewriteObjCFragileABI::RewriteObjCProtocolMetaData(
5077 ObjCProtocolDecl *PDecl, StringRef prefix,
5078 StringRef ClassName, std::string &Result) {
5079 static bool objc_protocol_methods = false;
5080
5081 // Output struct protocol_methods holder of method selector and type.
5082 if (!objc_protocol_methods && PDecl->hasDefinition()) {
5083 /* struct protocol_methods {
5084 SEL _cmd;
5085 char *method_types;
5086 }
5087 */
5088 Result += "\nstruct _protocol_methods {\n";
5089 Result += "\tstruct objc_selector *_cmd;\n";
5090 Result += "\tchar *method_types;\n";
5091 Result += "};\n";
5092
5093 objc_protocol_methods = true;
5094 }
5095 // Do not synthesize the protocol more than once.
5096 if (ObjCSynthesizedProtocols.count(PDecl->getCanonicalDecl()))
5097 return;
5098
5099 if (ObjCProtocolDecl *Def = PDecl->getDefinition())
5100 PDecl = Def;
5101
5102 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) {
5103 unsigned NumMethods = std::distance(PDecl->instmeth_begin(),
5104 PDecl->instmeth_end());
5105 /* struct _objc_protocol_method_list {
5106 int protocol_method_count;
5107 struct protocol_methods protocols[];
5108 }
5109 */
5110 Result += "\nstatic struct {\n";
5111 Result += "\tint protocol_method_count;\n";
5112 Result += "\tstruct _protocol_methods protocol_methods[";
5113 Result += utostr(NumMethods);
5114 Result += "];\n} _OBJC_PROTOCOL_INSTANCE_METHODS_";
5115 Result += PDecl->getNameAsString();
5116 Result += " __attribute__ ((used, section (\"__OBJC, __cat_inst_meth\")))= "
5117 "{\n\t" + utostr(NumMethods) + "\n";
5118
5119 // Output instance methods declared in this protocol.
5120 for (ObjCProtocolDecl::instmeth_iterator
5121 I = PDecl->instmeth_begin(), E = PDecl->instmeth_end();
5122 I != E; ++I) {
5123 if (I == PDecl->instmeth_begin())
5124 Result += "\t ,{{(struct objc_selector *)\"";
5125 else
5126 Result += "\t ,{(struct objc_selector *)\"";
5127 Result += (*I)->getSelector().getAsString();
5128 std::string MethodTypeString = Context->getObjCEncodingForMethodDecl(*I);
5129 Result += "\", \"";
5130 Result += MethodTypeString;
5131 Result += "\"}\n";
5132 }
5133 Result += "\t }\n};\n";
5134 }
5135
5136 // Output class methods declared in this protocol.
5137 unsigned NumMethods = std::distance(PDecl->classmeth_begin(),
5138 PDecl->classmeth_end());
5139 if (NumMethods > 0) {
5140 /* struct _objc_protocol_method_list {
5141 int protocol_method_count;
5142 struct protocol_methods protocols[];
5143 }
5144 */
5145 Result += "\nstatic struct {\n";
5146 Result += "\tint protocol_method_count;\n";
5147 Result += "\tstruct _protocol_methods protocol_methods[";
5148 Result += utostr(NumMethods);
5149 Result += "];\n} _OBJC_PROTOCOL_CLASS_METHODS_";
5150 Result += PDecl->getNameAsString();
5151 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= "
5152 "{\n\t";
5153 Result += utostr(NumMethods);
5154 Result += "\n";
5155
5156 // Output instance methods declared in this protocol.
5157 for (ObjCProtocolDecl::classmeth_iterator
5158 I = PDecl->classmeth_begin(), E = PDecl->classmeth_end();
5159 I != E; ++I) {
5160 if (I == PDecl->classmeth_begin())
5161 Result += "\t ,{{(struct objc_selector *)\"";
5162 else
5163 Result += "\t ,{(struct objc_selector *)\"";
5164 Result += (*I)->getSelector().getAsString();
5165 std::string MethodTypeString = Context->getObjCEncodingForMethodDecl(*I);
5166 Result += "\", \"";
5167 Result += MethodTypeString;
5168 Result += "\"}\n";
5169 }
5170 Result += "\t }\n};\n";
5171 }
5172
5173 // Output:
5174 /* struct _objc_protocol {
5175 // Objective-C 1.0 extensions
5176 struct _objc_protocol_extension *isa;
5177 char *protocol_name;
5178 struct _objc_protocol **protocol_list;
5179 struct _objc_protocol_method_list *instance_methods;
5180 struct _objc_protocol_method_list *class_methods;
5181 };
5182 */
5183 static bool objc_protocol = false;
5184 if (!objc_protocol) {
5185 Result += "\nstruct _objc_protocol {\n";
5186 Result += "\tstruct _objc_protocol_extension *isa;\n";
5187 Result += "\tchar *protocol_name;\n";
5188 Result += "\tstruct _objc_protocol **protocol_list;\n";
5189 Result += "\tstruct _objc_protocol_method_list *instance_methods;\n";
5190 Result += "\tstruct _objc_protocol_method_list *class_methods;\n";
5191 Result += "};\n";
5192
5193 objc_protocol = true;
5194 }
5195
5196 Result += "\nstatic struct _objc_protocol _OBJC_PROTOCOL_";
5197 Result += PDecl->getNameAsString();
5198 Result += " __attribute__ ((used, section (\"__OBJC, __protocol\")))= "
5199 "{\n\t0, \"";
5200 Result += PDecl->getNameAsString();
5201 Result += "\", 0, ";
5202 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) {
5203 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_INSTANCE_METHODS_";
5204 Result += PDecl->getNameAsString();
5205 Result += ", ";
5206 }
5207 else
5208 Result += "0, ";
5209 if (PDecl->classmeth_begin() != PDecl->classmeth_end()) {
5210 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_CLASS_METHODS_";
5211 Result += PDecl->getNameAsString();
5212 Result += "\n";
5213 }
5214 else
5215 Result += "0\n";
5216 Result += "};\n";
5217
5218 // Mark this protocol as having been generated.
5219 if (!ObjCSynthesizedProtocols.insert(PDecl->getCanonicalDecl()).second)
5220 llvm_unreachable("protocol already synthesized");
5221 }
5222
5223 void RewriteObjCFragileABI::RewriteObjCProtocolListMetaData(
5224 const ObjCList<ObjCProtocolDecl> &Protocols,
5225 StringRef prefix, StringRef ClassName,
5226 std::string &Result) {
5227 if (Protocols.empty()) return;
5228
5229 for (unsigned i = 0; i != Protocols.size(); i++)
5230 RewriteObjCProtocolMetaData(Protocols[i], prefix, ClassName, Result);
5231
5232 // Output the top lovel protocol meta-data for the class.
5233 /* struct _objc_protocol_list {
5234 struct _objc_protocol_list *next;
5235 int protocol_count;
5236 struct _objc_protocol *class_protocols[];
5237 }
5238 */
5239 Result += "\nstatic struct {\n";
5240 Result += "\tstruct _objc_protocol_list *next;\n";
5241 Result += "\tint protocol_count;\n";
5242 Result += "\tstruct _objc_protocol *class_protocols[";
5243 Result += utostr(Protocols.size());
5244 Result += "];\n} _OBJC_";
5245 Result += prefix;
5246 Result += "_PROTOCOLS_";
5247 Result += ClassName;
5248 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= "
5249 "{\n\t0, ";
5250 Result += utostr(Protocols.size());
5251 Result += "\n";
5252
5253 Result += "\t,{&_OBJC_PROTOCOL_";
5254 Result += Protocols[0]->getNameAsString();
5255 Result += " \n";
5256
5257 for (unsigned i = 1; i != Protocols.size(); i++) {
5258 Result += "\t ,&_OBJC_PROTOCOL_";
5259 Result += Protocols[i]->getNameAsString();
5260 Result += "\n";
5261 }
5262 Result += "\t }\n};\n";
5263 }
5264
5265 void RewriteObjCFragileABI::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
5266 std::string &Result) {
5267 ObjCInterfaceDecl *CDecl = IDecl->getClassInterface();
5268
5269 // Explicitly declared @interface's are already synthesized.
5270 if (CDecl->isImplicitInterfaceDecl()) {
5271 // FIXME: Implementation of a class with no @interface (legacy) does not
5272 // produce correct synthesis as yet.
5273 RewriteObjCInternalStruct(CDecl, Result);
5274 }
5275
5276 // Build _objc_ivar_list metadata for classes ivars if needed
5277 unsigned NumIvars = !IDecl->ivar_empty()
5278 ? IDecl->ivar_size()
5279 : (CDecl ? CDecl->ivar_size() : 0);
5280 if (NumIvars > 0) {
5281 static bool objc_ivar = false;
5282 if (!objc_ivar) {
5283 /* struct _objc_ivar {
5284 char *ivar_name;
5285 char *ivar_type;
5286 int ivar_offset;
5287 };
5288 */
5289 Result += "\nstruct _objc_ivar {\n";
5290 Result += "\tchar *ivar_name;\n";
5291 Result += "\tchar *ivar_type;\n";
5292 Result += "\tint ivar_offset;\n";
5293 Result += "};\n";
5294
5295 objc_ivar = true;
5296 }
5297
5298 /* struct {
5299 int ivar_count;
5300 struct _objc_ivar ivar_list[nIvars];
5301 };
5302 */
5303 Result += "\nstatic struct {\n";
5304 Result += "\tint ivar_count;\n";
5305 Result += "\tstruct _objc_ivar ivar_list[";
5306 Result += utostr(NumIvars);
5307 Result += "];\n} _OBJC_INSTANCE_VARIABLES_";
5308 Result += IDecl->getNameAsString();
5309 Result += " __attribute__ ((used, section (\"__OBJC, __instance_vars\")))= "
5310 "{\n\t";
5311 Result += utostr(NumIvars);
5312 Result += "\n";
5313
5314 ObjCInterfaceDecl::ivar_iterator IVI, IVE;
5315 SmallVector<ObjCIvarDecl *, 8> IVars;
5316 if (!IDecl->ivar_empty()) {
5317 for (auto *IV : IDecl->ivars())
5318 IVars.push_back(IV);
5319 IVI = IDecl->ivar_begin();
5320 IVE = IDecl->ivar_end();
5321 } else {
5322 IVI = CDecl->ivar_begin();
5323 IVE = CDecl->ivar_end();
5324 }
5325 Result += "\t,{{\"";
5326 Result += IVI->getNameAsString();
5327 Result += "\", \"";
5328 std::string TmpString, StrEncoding;
5329 Context->getObjCEncodingForType(IVI->getType(), TmpString, *IVI);
5330 QuoteDoublequotes(TmpString, StrEncoding);
5331 Result += StrEncoding;
5332 Result += "\", ";
5333 RewriteIvarOffsetComputation(*IVI, Result);
5334 Result += "}\n";
5335 for (++IVI; IVI != IVE; ++IVI) {
5336 Result += "\t ,{\"";
5337 Result += IVI->getNameAsString();
5338 Result += "\", \"";
5339 std::string TmpString, StrEncoding;
5340 Context->getObjCEncodingForType(IVI->getType(), TmpString, *IVI);
5341 QuoteDoublequotes(TmpString, StrEncoding);
5342 Result += StrEncoding;
5343 Result += "\", ";
5344 RewriteIvarOffsetComputation(*IVI, Result);
5345 Result += "}\n";
5346 }
5347
5348 Result += "\t }\n};\n";
5349 }
5350
5351 // Build _objc_method_list for class's instance methods if needed
5352 SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instance_methods());
5353
5354 // If any of our property implementations have associated getters or
5355 // setters, produce metadata for them as well.
5356 for (const auto *Prop : IDecl->property_impls()) {
5357 if (Prop->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
5358 continue;
5359 if (!Prop->getPropertyIvarDecl())
5360 continue;
5361 ObjCPropertyDecl *PD = Prop->getPropertyDecl();
5362 if (!PD)
5363 continue;
5364 if (ObjCMethodDecl *Getter = Prop->getGetterMethodDecl())
5365 if (!Getter->isDefined())
5366 InstanceMethods.push_back(Getter);
5367 if (PD->isReadOnly())
5368 continue;
5369 if (ObjCMethodDecl *Setter = Prop->getSetterMethodDecl())
5370 if (!Setter->isDefined())
5371 InstanceMethods.push_back(Setter);
5372 }
5373 RewriteObjCMethodsMetaData(InstanceMethods.begin(), InstanceMethods.end(),
5374 true, "", IDecl->getName(), Result);
5375
5376 // Build _objc_method_list for class's class methods if needed
5377 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(),
5378 false, "", IDecl->getName(), Result);
5379
5380 // Protocols referenced in class declaration?
5381 RewriteObjCProtocolListMetaData(CDecl->getReferencedProtocols(),
5382 "CLASS", CDecl->getName(), Result);
5383
5384 // Declaration of class/meta-class metadata
5385 /* struct _objc_class {
5386 struct _objc_class *isa; // or const char *root_class_name when metadata
5387 const char *super_class_name;
5388 char *name;
5389 long version;
5390 long info;
5391 long instance_size;
5392 struct _objc_ivar_list *ivars;
5393 struct _objc_method_list *methods;
5394 struct objc_cache *cache;
5395 struct objc_protocol_list *protocols;
5396 const char *ivar_layout;
5397 struct _objc_class_ext *ext;
5398 };
5399 */
5400 static bool objc_class = false;
5401 if (!objc_class) {
5402 Result += "\nstruct _objc_class {\n";
5403 Result += "\tstruct _objc_class *isa;\n";
5404 Result += "\tconst char *super_class_name;\n";
5405 Result += "\tchar *name;\n";
5406 Result += "\tlong version;\n";
5407 Result += "\tlong info;\n";
5408 Result += "\tlong instance_size;\n";
5409 Result += "\tstruct _objc_ivar_list *ivars;\n";
5410 Result += "\tstruct _objc_method_list *methods;\n";
5411 Result += "\tstruct objc_cache *cache;\n";
5412 Result += "\tstruct _objc_protocol_list *protocols;\n";
5413 Result += "\tconst char *ivar_layout;\n";
5414 Result += "\tstruct _objc_class_ext *ext;\n";
5415 Result += "};\n";
5416 objc_class = true;
5417 }
5418
5419 // Meta-class metadata generation.
5420 ObjCInterfaceDecl *RootClass = nullptr;
5421 ObjCInterfaceDecl *SuperClass = CDecl->getSuperClass();
5422 while (SuperClass) {
5423 RootClass = SuperClass;
5424 SuperClass = SuperClass->getSuperClass();
5425 }
5426 SuperClass = CDecl->getSuperClass();
5427
5428 Result += "\nstatic struct _objc_class _OBJC_METACLASS_";
5429 Result += CDecl->getNameAsString();
5430 Result += " __attribute__ ((used, section (\"__OBJC, __meta_class\")))= "
5431 "{\n\t(struct _objc_class *)\"";
5432 Result += (RootClass ? RootClass->getNameAsString() : CDecl->getNameAsString());
5433 Result += "\"";
5434
5435 if (SuperClass) {
5436 Result += ", \"";
5437 Result += SuperClass->getNameAsString();
5438 Result += "\", \"";
5439 Result += CDecl->getNameAsString();
5440 Result += "\"";
5441 }
5442 else {
5443 Result += ", 0, \"";
5444 Result += CDecl->getNameAsString();
5445 Result += "\"";
5446 }
5447 // Set 'ivars' field for root class to 0. ObjC1 runtime does not use it.
5448 // 'info' field is initialized to CLS_META(2) for metaclass
5449 Result += ", 0,2, sizeof(struct _objc_class), 0";
5450 if (IDecl->classmeth_begin() != IDecl->classmeth_end()) {
5451 Result += "\n\t, (struct _objc_method_list *)&_OBJC_CLASS_METHODS_";
5452 Result += IDecl->getNameAsString();
5453 Result += "\n";
5454 }
5455 else
5456 Result += ", 0\n";
5457 if (CDecl->protocol_begin() != CDecl->protocol_end()) {
5458 Result += "\t,0, (struct _objc_protocol_list *)&_OBJC_CLASS_PROTOCOLS_";
5459 Result += CDecl->getNameAsString();
5460 Result += ",0,0\n";
5461 }
5462 else
5463 Result += "\t,0,0,0,0\n";
5464 Result += "};\n";
5465
5466 // class metadata generation.
5467 Result += "\nstatic struct _objc_class _OBJC_CLASS_";
5468 Result += CDecl->getNameAsString();
5469 Result += " __attribute__ ((used, section (\"__OBJC, __class\")))= "
5470 "{\n\t&_OBJC_METACLASS_";
5471 Result += CDecl->getNameAsString();
5472 if (SuperClass) {
5473 Result += ", \"";
5474 Result += SuperClass->getNameAsString();
5475 Result += "\", \"";
5476 Result += CDecl->getNameAsString();
5477 Result += "\"";
5478 }
5479 else {
5480 Result += ", 0, \"";
5481 Result += CDecl->getNameAsString();
5482 Result += "\"";
5483 }
5484 // 'info' field is initialized to CLS_CLASS(1) for class
5485 Result += ", 0,1";
5486 if (!ObjCSynthesizedStructs.count(CDecl))
5487 Result += ",0";
5488 else {
5489 // class has size. Must synthesize its size.
5490 Result += ",sizeof(struct ";
5491 Result += CDecl->getNameAsString();
5492 if (LangOpts.MicrosoftExt)
5493 Result += "_IMPL";
5494 Result += ")";
5495 }
5496 if (NumIvars > 0) {
5497 Result += ", (struct _objc_ivar_list *)&_OBJC_INSTANCE_VARIABLES_";
5498 Result += CDecl->getNameAsString();
5499 Result += "\n\t";
5500 }
5501 else
5502 Result += ",0";
5503 if (IDecl->instmeth_begin() != IDecl->instmeth_end()) {
5504 Result += ", (struct _objc_method_list *)&_OBJC_INSTANCE_METHODS_";
5505 Result += CDecl->getNameAsString();
5506 Result += ", 0\n\t";
5507 }
5508 else
5509 Result += ",0,0";
5510 if (CDecl->protocol_begin() != CDecl->protocol_end()) {
5511 Result += ", (struct _objc_protocol_list*)&_OBJC_CLASS_PROTOCOLS_";
5512 Result += CDecl->getNameAsString();
5513 Result += ", 0,0\n";
5514 }
5515 else
5516 Result += ",0,0,0\n";
5517 Result += "};\n";
5518 }
5519
5520 void RewriteObjCFragileABI::RewriteMetaDataIntoBuffer(std::string &Result) {
5521 int ClsDefCount = ClassImplementation.size();
5522 int CatDefCount = CategoryImplementation.size();
5523
5524 // For each implemented class, write out all its meta data.
5525 for (int i = 0; i < ClsDefCount; i++)
5526 RewriteObjCClassMetaData(ClassImplementation[i], Result);
5527
5528 // For each implemented category, write out all its meta data.
5529 for (int i = 0; i < CatDefCount; i++)
5530 RewriteObjCCategoryImplDecl(CategoryImplementation[i], Result);
5531
5532 // Write objc_symtab metadata
5533 /*
5534 struct _objc_symtab
5535 {
5536 long sel_ref_cnt;
5537 SEL *refs;
5538 short cls_def_cnt;
5539 short cat_def_cnt;
5540 void *defs[cls_def_cnt + cat_def_cnt];
5541 };
5542 */
5543
5544 Result += "\nstruct _objc_symtab {\n";
5545 Result += "\tlong sel_ref_cnt;\n";
5546 Result += "\tSEL *refs;\n";
5547 Result += "\tshort cls_def_cnt;\n";
5548 Result += "\tshort cat_def_cnt;\n";
5549 Result += "\tvoid *defs[" + utostr(ClsDefCount + CatDefCount)+ "];\n";
5550 Result += "};\n\n";
5551
5552 Result += "static struct _objc_symtab "
5553 "_OBJC_SYMBOLS __attribute__((used, section (\"__OBJC, __symbols\")))= {\n";
5554 Result += "\t0, 0, " + utostr(ClsDefCount)
5555 + ", " + utostr(CatDefCount) + "\n";
5556 for (int i = 0; i < ClsDefCount; i++) {
5557 Result += "\t,&_OBJC_CLASS_";
5558 Result += ClassImplementation[i]->getNameAsString();
5559 Result += "\n";
5560 }
5561
5562 for (int i = 0; i < CatDefCount; i++) {
5563 Result += "\t,&_OBJC_CATEGORY_";
5564 Result += CategoryImplementation[i]->getClassInterface()->getNameAsString();
5565 Result += "_";
5566 Result += CategoryImplementation[i]->getNameAsString();
5567 Result += "\n";
5568 }
5569
5570 Result += "};\n\n";
5571
5572 // Write objc_module metadata
5573
5574 /*
5575 struct _objc_module {
5576 long version;
5577 long size;
5578 const char *name;
5579 struct _objc_symtab *symtab;
5580 }
5581 */
5582
5583 Result += "\nstruct _objc_module {\n";
5584 Result += "\tlong version;\n";
5585 Result += "\tlong size;\n";
5586 Result += "\tconst char *name;\n";
5587 Result += "\tstruct _objc_symtab *symtab;\n";
5588 Result += "};\n\n";
5589 Result += "static struct _objc_module "
5590 "_OBJC_MODULES __attribute__ ((used, section (\"__OBJC, __module_info\")))= {\n";
5591 Result += "\t" + utostr(OBJC_ABI_VERSION) +
5592 ", sizeof(struct _objc_module), \"\", &_OBJC_SYMBOLS\n";
5593 Result += "};\n\n";
5594
5595 if (LangOpts.MicrosoftExt) {
5596 if (ProtocolExprDecls.size()) {
5597 Result += "#pragma section(\".objc_protocol$B\",long,read,write)\n";
5598 Result += "#pragma data_seg(push, \".objc_protocol$B\")\n";
5599 for (ObjCProtocolDecl *ProtDecl : ProtocolExprDecls) {
5600 Result += "static struct _objc_protocol *_POINTER_OBJC_PROTOCOL_";
5601 Result += ProtDecl->getNameAsString();
5602 Result += " = &_OBJC_PROTOCOL_";
5603 Result += ProtDecl->getNameAsString();
5604 Result += ";\n";
5605 }
5606 Result += "#pragma data_seg(pop)\n\n";
5607 }
5608 Result += "#pragma section(\".objc_module_info$B\",long,read,write)\n";
5609 Result += "#pragma data_seg(push, \".objc_module_info$B\")\n";
5610 Result += "static struct _objc_module *_POINTER_OBJC_MODULES = ";
5611 Result += "&_OBJC_MODULES;\n";
5612 Result += "#pragma data_seg(pop)\n\n";
5613 }
5614 }
5615
5616 /// RewriteObjCCategoryImplDecl - Rewrite metadata for each category
5617 /// implementation.
5618 void RewriteObjCFragileABI::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl,
5619 std::string &Result) {
5620 ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface();
5621 // Find category declaration for this implementation.
5622 ObjCCategoryDecl *CDecl
5623 = ClassDecl->FindCategoryDeclaration(IDecl->getIdentifier());
5624
5625 std::string FullCategoryName = ClassDecl->getNameAsString();
5626 FullCategoryName += '_';
5627 FullCategoryName += IDecl->getNameAsString();
5628
5629 // Build _objc_method_list for class's instance methods if needed
5630 SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instance_methods());
5631
5632 // If any of our property implementations have associated getters or
5633 // setters, produce metadata for them as well.
5634 for (const auto *Prop : IDecl->property_impls()) {
5635 if (Prop->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
5636 continue;
5637 if (!Prop->getPropertyIvarDecl())
5638 continue;
5639 ObjCPropertyDecl *PD = Prop->getPropertyDecl();
5640 if (!PD)
5641 continue;
5642 if (ObjCMethodDecl *Getter = Prop->getGetterMethodDecl())
5643 InstanceMethods.push_back(Getter);
5644 if (PD->isReadOnly())
5645 continue;
5646 if (ObjCMethodDecl *Setter = Prop->getSetterMethodDecl())
5647 InstanceMethods.push_back(Setter);
5648 }
5649 RewriteObjCMethodsMetaData(InstanceMethods.begin(), InstanceMethods.end(),
5650 true, "CATEGORY_", FullCategoryName, Result);
5651
5652 // Build _objc_method_list for class's class methods if needed
5653 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(),
5654 false, "CATEGORY_", FullCategoryName, Result);
5655
5656 // Protocols referenced in class declaration?
5657 // Null CDecl is case of a category implementation with no category interface
5658 if (CDecl)
5659 RewriteObjCProtocolListMetaData(CDecl->getReferencedProtocols(), "CATEGORY",
5660 FullCategoryName, Result);
5661 /* struct _objc_category {
5662 char *category_name;
5663 char *class_name;
5664 struct _objc_method_list *instance_methods;
5665 struct _objc_method_list *class_methods;
5666 struct _objc_protocol_list *protocols;
5667 // Objective-C 1.0 extensions
5668 uint32_t size; // sizeof (struct _objc_category)
5669 struct _objc_property_list *instance_properties; // category's own
5670 // @property decl.
5671 };
5672 */
5673
5674 static bool objc_category = false;
5675 if (!objc_category) {
5676 Result += "\nstruct _objc_category {\n";
5677 Result += "\tchar *category_name;\n";
5678 Result += "\tchar *class_name;\n";
5679 Result += "\tstruct _objc_method_list *instance_methods;\n";
5680 Result += "\tstruct _objc_method_list *class_methods;\n";
5681 Result += "\tstruct _objc_protocol_list *protocols;\n";
5682 Result += "\tunsigned int size;\n";
5683 Result += "\tstruct _objc_property_list *instance_properties;\n";
5684 Result += "};\n";
5685 objc_category = true;
5686 }
5687 Result += "\nstatic struct _objc_category _OBJC_CATEGORY_";
5688 Result += FullCategoryName;
5689 Result += " __attribute__ ((used, section (\"__OBJC, __category\")))= {\n\t\"";
5690 Result += IDecl->getNameAsString();
5691 Result += "\"\n\t, \"";
5692 Result += ClassDecl->getNameAsString();
5693 Result += "\"\n";
5694
5695 if (IDecl->instmeth_begin() != IDecl->instmeth_end()) {
5696 Result += "\t, (struct _objc_method_list *)"
5697 "&_OBJC_CATEGORY_INSTANCE_METHODS_";
5698 Result += FullCategoryName;
5699 Result += "\n";
5700 }
5701 else
5702 Result += "\t, 0\n";
5703 if (IDecl->classmeth_begin() != IDecl->classmeth_end()) {
5704 Result += "\t, (struct _objc_method_list *)"
5705 "&_OBJC_CATEGORY_CLASS_METHODS_";
5706 Result += FullCategoryName;
5707 Result += "\n";
5708 }
5709 else
5710 Result += "\t, 0\n";
5711
5712 if (CDecl && CDecl->protocol_begin() != CDecl->protocol_end()) {
5713 Result += "\t, (struct _objc_protocol_list *)&_OBJC_CATEGORY_PROTOCOLS_";
5714 Result += FullCategoryName;
5715 Result += "\n";
5716 }
5717 else
5718 Result += "\t, 0\n";
5719 Result += "\t, sizeof(struct _objc_category), 0\n};\n";
5720 }
5721
5722 // RewriteObjCMethodsMetaData - Rewrite methods metadata for instance or
5723 /// class methods.
5724 template<typename MethodIterator>
5725 void RewriteObjCFragileABI::RewriteObjCMethodsMetaData(MethodIterator MethodBegin,
5726 MethodIterator MethodEnd,
5727 bool IsInstanceMethod,
5728 StringRef prefix,
5729 StringRef ClassName,
5730 std::string &Result) {
5731 if (MethodBegin == MethodEnd) return;
5732
5733 if (!objc_impl_method) {
5734 /* struct _objc_method {
5735 SEL _cmd;
5736 char *method_types;
5737 void *_imp;
5738 }
5739 */
5740 Result += "\nstruct _objc_method {\n";
5741 Result += "\tSEL _cmd;\n";
5742 Result += "\tchar *method_types;\n";
5743 Result += "\tvoid *_imp;\n";
5744 Result += "};\n";
5745
5746 objc_impl_method = true;
5747 }
5748
5749 // Build _objc_method_list for class's methods if needed
5750
5751 /* struct {
5752 struct _objc_method_list *next_method;
5753 int method_count;
5754 struct _objc_method method_list[];
5755 }
5756 */
5757 unsigned NumMethods = std::distance(MethodBegin, MethodEnd);
5758 Result += "\nstatic struct {\n";
5759 Result += "\tstruct _objc_method_list *next_method;\n";
5760 Result += "\tint method_count;\n";
5761 Result += "\tstruct _objc_method method_list[";
5762 Result += utostr(NumMethods);
5763 Result += "];\n} _OBJC_";
5764 Result += prefix;
5765 Result += IsInstanceMethod ? "INSTANCE" : "CLASS";
5766 Result += "_METHODS_";
5767 Result += ClassName;
5768 Result += " __attribute__ ((used, section (\"__OBJC, __";
5769 Result += IsInstanceMethod ? "inst" : "cls";
5770 Result += "_meth\")))= ";
5771 Result += "{\n\t0, " + utostr(NumMethods) + "\n";
5772
5773 Result += "\t,{{(SEL)\"";
5774 Result += (*MethodBegin)->getSelector().getAsString();
5775 std::string MethodTypeString =
5776 Context->getObjCEncodingForMethodDecl(*MethodBegin);
5777 Result += "\", \"";
5778 Result += MethodTypeString;
5779 Result += "\", (void *)";
5780 Result += MethodInternalNames[*MethodBegin];
5781 Result += "}\n";
5782 for (++MethodBegin; MethodBegin != MethodEnd; ++MethodBegin) {
5783 Result += "\t ,{(SEL)\"";
5784 Result += (*MethodBegin)->getSelector().getAsString();
5785 std::string MethodTypeString =
5786 Context->getObjCEncodingForMethodDecl(*MethodBegin);
5787 Result += "\", \"";
5788 Result += MethodTypeString;
5789 Result += "\", (void *)";
5790 Result += MethodInternalNames[*MethodBegin];
5791 Result += "}\n";
5792 }
5793 Result += "\t }\n};\n";
5794 }
5795
5796 Stmt *RewriteObjCFragileABI::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) {
5797 SourceRange OldRange = IV->getSourceRange();
5798 Expr *BaseExpr = IV->getBase();
5799
5800 // Rewrite the base, but without actually doing replaces.
5801 {
5802 DisableReplaceStmtScope S(*this);
5803 BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr));
5804 IV->setBase(BaseExpr);
5805 }
5806
5807 ObjCIvarDecl *D = IV->getDecl();
5808
5809 Expr *Replacement = IV;
5810 if (CurMethodDef) {
5811 if (BaseExpr->getType()->isObjCObjectPointerType()) {
5812 const ObjCInterfaceType *iFaceDecl =
5813 dyn_cast<ObjCInterfaceType>(BaseExpr->getType()->getPointeeType());
5814 assert(iFaceDecl && "RewriteObjCIvarRefExpr - iFaceDecl is null");
5815 // lookup which class implements the instance variable.
5816 ObjCInterfaceDecl *clsDeclared = nullptr;
5817 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(),
5818 clsDeclared);
5819 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class");
5820
5821 // Synthesize an explicit cast to gain access to the ivar.
5822 std::string RecName = clsDeclared->getIdentifier()->getName();
5823 RecName += "_IMPL";
5824 IdentifierInfo *II = &Context->Idents.get(RecName);
5825 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
5826 SourceLocation(), SourceLocation(),
5827 II);
5828 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
5829 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
5830 CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, castT,
5831 CK_BitCast,
5832 IV->getBase());
5833 // Don't forget the parens to enforce the proper binding.
5834 ParenExpr *PE = new (Context) ParenExpr(OldRange.getBegin(),
5835 OldRange.getEnd(),
5836 castExpr);
5837 if (IV->isFreeIvar() &&
5838 declaresSameEntity(CurMethodDef->getClassInterface(),
5839 iFaceDecl->getDecl())) {
5840 MemberExpr *ME = MemberExpr::CreateImplicit(
5841 *Context, PE, true, D, D->getType(), VK_LValue, OK_Ordinary);
5842 Replacement = ME;
5843 } else {
5844 IV->setBase(PE);
5845 }
5846 }
5847 } else { // we are outside a method.
5848 assert(!IV->isFreeIvar() && "Cannot have a free standing ivar outside a method");
5849
5850 // Explicit ivar refs need to have a cast inserted.
5851 // FIXME: consider sharing some of this code with the code above.
5852 if (BaseExpr->getType()->isObjCObjectPointerType()) {
5853 const ObjCInterfaceType *iFaceDecl =
5854 dyn_cast<ObjCInterfaceType>(BaseExpr->getType()->getPointeeType());
5855 // lookup which class implements the instance variable.
5856 ObjCInterfaceDecl *clsDeclared = nullptr;
5857 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(),
5858 clsDeclared);
5859 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class");
5860
5861 // Synthesize an explicit cast to gain access to the ivar.
5862 std::string RecName = clsDeclared->getIdentifier()->getName();
5863 RecName += "_IMPL";
5864 IdentifierInfo *II = &Context->Idents.get(RecName);
5865 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
5866 SourceLocation(), SourceLocation(),
5867 II);
5868 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
5869 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
5870 CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, castT,
5871 CK_BitCast,
5872 IV->getBase());
5873 // Don't forget the parens to enforce the proper binding.
5874 ParenExpr *PE = new (Context) ParenExpr(
5875 IV->getBase()->getBeginLoc(), IV->getBase()->getEndLoc(), castExpr);
5876 // Cannot delete IV->getBase(), since PE points to it.
5877 // Replace the old base with the cast. This is important when doing
5878 // embedded rewrites. For example, [newInv->_container addObject:0].
5879 IV->setBase(PE);
5880 }
5881 }
5882
5883 ReplaceStmtWithRange(IV, Replacement, OldRange);
5884 return Replacement;
5885 }
5886
5887 #endif // CLANG_ENABLE_OBJC_REWRITER
clang::PseudoObjectExpr::getNumSemanticExprs
unsigned getNumSemanticExprs() const
Definition: Expr.h:5779
clang::SourceManager::getLocForStartOfFile
SourceLocation getLocForStartOfFile(FileID FID) const
Return the source location corresponding to the first byte of the specified file. ...
Definition: SourceManager.h:1109
clang::ObjCMessageExpr::SuperInstance
The receiver is the instance of the superclass object.
Definition: ExprObjC.h:1107
clang::Builtin::ID
ID
Definition: Builtins.h:46
clang::BlockExpr::getBlockDecl
const BlockDecl * getBlockDecl() const
Definition: Expr.h:5593
Rewriter.h
clang::CanQual::withConst
QualType withConst() const
Retrieves a version of this type with const applied.
Definition: CanonicalType.h:161
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1783
clang::ObjCMessageExpr::Instance
The receiver is an object instance.
Definition: ExprObjC.h:1101
clang::PseudoObjectExpr::getSyntacticForm
Expr * getSyntacticForm()
Return the syntactic form of this expression, i.e.
Definition: Expr.h:5759
clang::DiagnosticsEngine::hasErrorOccurred
bool hasErrorOccurred() const
Definition: Diagnostic.h:753
clang::SourceLocation::getLocWithOffset
SourceLocation getLocWithOffset(int Offset) const
Return a source location with the specified offset from this SourceLocation.
Definition: SourceLocation.h:132
clang::BlockExpr::getFunctionType
const FunctionProtoType * getFunctionType() const
getFunctionType - Return the underlying function type for this block.
Definition: Expr.cpp:2370
clang::ASTContext::getObjCIdType
QualType getObjCIdType() const
Represents the Objective-CC id type.
Definition: ASTContext.h:1874
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
clang::ASTContext::VoidPtrTy
CanQualType VoidPtrTy
Definition: ASTContext.h:1044
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2627
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:654
clang::Type::isBlockPointerType
bool isBlockPointerType() const
Definition: Type.h:6512
clang::Type::isArrayType
bool isArrayType() const
Definition: Type.h:6570
clang::FunctionDecl::isOverloadedOperator
bool isOverloadedOperator() const
Whether this function declaration represents an C++ overloaded operator, e.g., "operator+".
Definition: Decl.h:2525
clang::ObjCMessageExpr::getSelector
Selector getSelector() const
Definition: ExprObjC.cpp:337
clang::ObjCMethodDecl::getClassInterface
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1155
clang::ASTConsumer
ASTConsumer - This is an abstract interface that should be implemented by clients that read ASTs...
Definition: ASTConsumer.h:33
clang::ParentMap
Definition: ParentMap.h:20
clang::ObjCInterfaceDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Determine whether this particular declaration of this class is actually also a definition.
Definition: DeclObjC.h:1544
AST.h
clang::ObjCPropertyImplDecl::getPropertyIvarDecl
ObjCIvarDecl * getPropertyIvarDecl() const
Definition: DeclObjC.h:2846
clang::ObjCAtCatchStmt::getRParenLoc
SourceLocation getRParenLoc() const
Definition: StmtObjC.h:107
clang::ObjCProtocolExpr::getProtocol
ObjCProtocolDecl * getProtocol() const
Definition: ExprObjC.h:519
clang::Stmt
Stmt - This represents one statement.
Definition: Stmt.h:66
clang::ObjCCategoryDecl::getReferencedProtocols
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:2363
clang::ObjCAtTryStmt::getFinallyStmt
const ObjCAtFinallyStmt * getFinallyStmt() const
Retrieve the @finally statement, if any.
Definition: StmtObjC.h:235
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3422
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
clang::ObjCInterfaceDecl::getSuperClassLoc
SourceLocation getSuperClassLoc() const
Retrieve the starting location of the superclass.
Definition: DeclObjC.cpp:357
clang::Type::isRealFloatingType
bool isRealFloatingType() const
Floating point categories.
Definition: Type.cpp:2021
clang::VarDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:1029
Base
clang::BlockDecl::param_empty
bool param_empty() const
Definition: Decl.h:4134
SourceManager.h
Defines the SourceManager interface.
clang::ObjCPropertyImplDecl::Dynamic
Definition: DeclObjC.h:2777
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6594
clang::DeclGroupRef::end
iterator end()
Definition: DeclGroup.h:105
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
clang::FunctionProtoType::isVariadic
bool isVariadic() const
Whether this function prototype is variadic.
Definition: Type.h:4086
clang::Decl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:421
clang::BlockCall
Definition: CallEvent.h:532
clang::BlockDecl::param_end
param_iterator param_end()
Definition: Decl.h:4136
llvm::DenseSet
Definition: Sema.h:71
clang::ParenExpr
ParenExpr - This represents a parethesized expression, e.g.
Definition: Expr.h:1994
clang::SourceManager::getCharacterData
const char * getCharacterData(SourceLocation SL, bool *Invalid=nullptr) const
Return a pointer to the start of the specified location in the appropriate spelling MemoryBuffer...
Definition: SourceManager.cpp:1126
clang::IntegerLiteral
Definition: Expr.h:1446
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1450
clang::ObjCAtThrowStmt
Represents Objective-C&#39;s @throw statement.
Definition: StmtObjC.h:332
IsHeaderFile
static bool IsHeaderFile(const std::string &Filename)
Definition: RewriteObjC.cpp:563
clang::ASTContext::LongTy
CanQualType LongTy
Definition: ASTContext.h:1025
clang::CanQual::getUnqualifiedType
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Definition: CanonicalType.h:618
clang::DiagnosticsEngine::Report
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1300
clang::Type::getAsObjCInterfacePointerType
const ObjCObjectPointerType * getAsObjCInterfacePointerType() const
Definition: Type.cpp:1667
clang::QualType::isRestrictQualified
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition: Type.h:6320
clang::ObjCInterfaceDecl::protocol_begin
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:1384
clang::RecordDecl::completeDefinition
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition: Decl.cpp:4434
clang::Decl::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:425
clang::CStyleCastExpr::getLParenLoc
SourceLocation getLParenLoc() const
Definition: Expr.h:3397
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6227
clang::ObjCContainerDecl::instmeth_end
instmeth_iterator instmeth_end() const
Definition: DeclObjC.h:1076
clang::FPOptions
Floating point control options.
Definition: LangOptions.h:357
clang::XRayInstrKind::Function
constexpr XRayInstrMask Function
Definition: XRayInstr.h:38
clang::FunctionDecl::Create
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=CSK_unspecified, Expr *TrailingRequiresClause=nullptr)
Definition: Decl.h:1955
distance
float __ovld __cnfn distance(float p0, float p1)
Returns the distance between p0 and p1.
clang::BlockDecl::param_iterator
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:4131
clang::TagDecl::isCompleteDefinition
bool isCompleteDefinition() const
Return true if this decl has its body fully specified.
Definition: Decl.h:3324
clang::SourceManager::getBufferData
StringRef getBufferData(FileID FID, bool *Invalid=nullptr) const
Return a StringRef to the source buffer data for the specified FileID.
Definition: SourceManager.cpp:702
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:820
clang::CompoundLiteralExpr
CompoundLiteralExpr - [C99 6.5.2.5].
Definition: Expr.h:3077
clang::SC_Static
Definition: Specifiers.h:239
clang::FunctionProtoType::getNumParams
unsigned getNumParams() const
Definition: Type.h:3964
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
clang::FunctionProtoType::ExtProtoInfo
Extra information about a function prototype.
Definition: Type.h:3837
clang::MemberExpr::CreateImplicit
static MemberExpr * CreateImplicit(const ASTContext &C, Expr *Base, bool IsArrow, ValueDecl *MemberDecl, QualType T, ExprValueKind VK, ExprObjectKind OK)
Create an implicit MemberExpr, with no location, qualifier, template arguments, and so on...
Definition: Expr.h:2897
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
clang::ObjCMessageExpr::getLeftLoc
SourceLocation getLeftLoc() const
Definition: ExprObjC.h:1416
clang::RewriteBuffer
RewriteBuffer - As code is rewritten, SourceBuffer&#39;s from the original input with modifications get a...
Definition: RewriteBuffer.h:25
clang::Rewriter::getRewrittenText
std::string getRewrittenText(CharSourceRange Range) const
getRewrittenText - Return the rewritten form of the text in the specified range.
Definition: Rewriter.cpp:184
clang::ASTContext::getObjCClassType
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1896
clang::PrintingPolicy
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:47
clang::ObjCContainerDecl::class_methods
classmeth_range class_methods() const
Definition: DeclObjC.h:1085
clang::index::SymbolKind::Class
clang::CodeGen::BLOCK_IS_GLOBAL
Definition: CGBlocks.h:59
clang::NamedDecl::getIdentifier
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition: Decl.h:244
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3748
clang::ObjCProtocolDecl::getCanonicalDecl
ObjCProtocolDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C protocol.
Definition: DeclObjC.h:2264
clang::ObjCContainerDecl::instance_properties
instprop_range instance_properties() const
Definition: DeclObjC.h:1017
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:57
clang::QualType::IgnoreParens
QualType IgnoreParens() const
Returns the specified type after dropping any outer-level parentheses.
Definition: Type.h:973
clang::ObjCObjectType
Represents a class type in Objective C.
Definition: Type.h:5694
clang::RecordDecl::Create
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:4387
clang::BlockPointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2731
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:3963
clang::Stmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:275
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2729
clang::ObjCPropertyImplDecl::getSetterMethodDecl
ObjCMethodDecl * getSetterMethodDecl() const
Definition: DeclObjC.h:2871
std
Definition: Format.h:2445
clang::ObjCMessageExpr::Create
static ObjCMessageExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, SourceLocation LBracLoc, SourceLocation SuperLoc, bool IsInstanceSuper, QualType SuperType, Selector Sel, ArrayRef< SourceLocation > SelLocs, ObjCMethodDecl *Method, ArrayRef< Expr *> Args, SourceLocation RBracLoc, bool isImplicit)
Create a message send to super.
Definition: ExprObjC.cpp:206
clang::ObjCContainerDecl::instance_methods
instmeth_range instance_methods() const
Definition: DeclObjC.h:1068
clang::ObjCStringLiteral::getString
StringLiteral * getString()
Definition: ExprObjC.h:62
clang::ObjCMethodDecl::isDefined
bool isDefined() const
Definition: DeclObjC.h:449
clang::ObjCImplementationDecl::getNameAsString
std::string getNameAsString() const
Get the name of the class associated with this interface.
Definition: DeclObjC.h:2695
clang::CStyleCastExpr::getRParenLoc
SourceLocation getRParenLoc() const
Definition: Expr.h:3400
clang::CodeGen::BLOCK_HAS_COPY_DISPOSE
Definition: CGBlocks.h:57
clang::ObjCInterfaceDecl::protocol_end
protocol_iterator protocol_end() const
Definition: DeclObjC.h:1395
clang::Rewriter::ReplaceText
bool ReplaceText(SourceLocation Start, unsigned OrigLength, StringRef NewStr)
ReplaceText - This method replaces a range of characters in the input buffer with a new string...
Definition: Rewriter.cpp:320
clang::LangOptions
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:53
clang::Type::isObjCQualifiedClassType
bool isObjCQualifiedClassType() const
Definition: Type.h:6645
llvm::SmallVectorImpl
Definition: LLVM.h:36
clang::ASTContext::Idents
IdentifierTable & Idents
Definition: ASTContext.h:580
clang::VK_RValue
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:125
clang::ObjCSelectorExpr::getSelector
Selector getSelector() const
Definition: ExprObjC.h:467
clang::ObjCAtCatchStmt
Represents Objective-C&#39;s @catch statement.
Definition: StmtObjC.h:77
clang::InitListExpr
Describes an C or C++ initializer list.
Definition: Expr.h:4403
clang::FieldDecl::isBitField
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2807
clang::ObjCPropertyImplDecl::getGetterMethodDecl
ObjCMethodDecl * getGetterMethodDecl() const
Definition: DeclObjC.h:2868
clang::FunctionDecl::getBody
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition: Decl.cpp:2894
clang::ObjCAtThrowStmt::getThrowExpr
const Expr * getThrowExpr() const
Definition: StmtObjC.h:344
clang::ObjCContainerDecl::instmeth_iterator
filtered_decl_iterator< ObjCMethodDecl, &ObjCMethodDecl::isInstanceMethod > instmeth_iterator
Definition: DeclObjC.h:1065
clang::ObjCImplementationDecl::ivar_size
unsigned ivar_size() const
Definition: DeclObjC.h:2727
clang::Expr::getValueKind
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:414
clang::SourceManager::getExpansionLoc
SourceLocation getExpansionLoc(SourceLocation Loc) const
Given a SourceLocation object Loc, return the expansion location referenced by the ID...
Definition: SourceManager.h:1159
clang::ObjCPropertyDecl::getPropertyAttributes
PropertyAttributeKind getPropertyAttributes() const
Definition: DeclObjC.h:853
clang::Stmt::children
child_range children()
Definition: Stmt.cpp:224
clang::DiagnosticsEngine
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
clang::TypeOfExprType
Represents a typeof (or typeof) expression (a GCC extension).
Definition: Type.h:4300
clang::ASTContext::getPrintingPolicy
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:671
clang::TypeDecl
Represents a declaration of a type.
Definition: Decl.h:3029
clang::BinaryOperator
A builtin binary operation expression such as "x + y" or "x <= y".
Definition: Expr.h:3434
clang::QualType::isVolatileQualified
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6326
clang::ObjCPropertyDecl::OBJC_PR_nonatomic
Definition: DeclObjC.h:753
clang::CreateObjCRewriter
std::unique_ptr< ASTConsumer > CreateObjCRewriter(const std::string &InFile, std::unique_ptr< raw_ostream > OS, DiagnosticsEngine &Diags, const LangOptions &LOpts, bool SilenceRewriteMacroWarning)
Definition: RewriteObjC.cpp:592
clang::DeclGroupRef::begin
iterator begin()
Definition: DeclGroup.h:99
clang::ObjCAtTryStmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtObjC.h:252
clang::transformer::name
RangeSelector name(std::string ID)
Given a node with a "name", (like NamedDecl, DeclRefExpr or CxxCtorInitializer) selects the name&#39;s to...
Definition: RangeSelector.cpp:186
clang::ObjCPropertyDecl::isReadOnly
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
Definition: DeclObjC.h:876
Diagnostic.h
Defines the Diagnostic-related interfaces.
clang::ObjCStringLiteral
ObjCStringLiteral, used for Objective-C string literals i.e.
Definition: ExprObjC.h:50
clang::ObjCProtocolDecl::getDefinition
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition: DeclObjC.h:2224
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1166
clang::CastExpr
CastExpr - Base class for type casts, including both implicit casts (ImplicitCastExpr) and explicit c...
Definition: Expr.h:3150
clang::ObjCMethodDecl::getCompoundBody
CompoundStmt * getCompoundBody()
Definition: DeclObjC.h:523
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2078
clang::ast_matchers::castExpr
const internal::VariadicDynCastAllOfMatcher< Stmt, CastExpr > castExpr
Matches any cast nodes of Clang&#39;s AST.
Definition: ASTMatchersInternal.cpp:806
clang::VarDecl::Create
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1980
clang::IntegerLiteral::Create
static IntegerLiteral * Create(const ASTContext &C, const llvm::APInt &V, QualType type, SourceLocation l)
Returns a new integer literal with value &#39;V&#39; and type &#39;type&#39;.
Definition: Expr.cpp:928
clang::OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:141
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1186
clang::LinkageSpecDecl
Represents a linkage specification.
Definition: DeclCXX.h:2778
clang::ObjCMethodDecl::getReturnType
QualType getReturnType() const
Definition: DeclObjC.h:324
llvm::ArrayRef
Definition: LLVM.h:31
clang::DeclaratorDecl::getTypeSpecStartLoc
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1817
clang::BlockExpr::getBody
const Stmt * getBody() const
Definition: Expr.cpp:2379
clang::ObjCContainerDecl::getAtStartLoc
SourceLocation getAtStartLoc() const
Definition: DeclObjC.h:1129
clang::ASTContext::getObjCEncodingForMethodDecl
std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, bool Extended=false) const
Emit the encoded type for the method declaration Decl into S.
Definition: ASTContext.cpp:6603
clang::CallExpr::arg_end
arg_iterator arg_end()
Definition: Expr.h:2747
clang::ObjCIvarRefExpr::getDecl
ObjCIvarDecl * getDecl()
Definition: ExprObjC.h:576
clang::ObjCAtTryStmt::getCatchStmt
const ObjCAtCatchStmt * getCatchStmt(unsigned I) const
Retrieve a @catch statement.
Definition: StmtObjC.h:217
clang::ObjCPropertyImplDecl
ObjCPropertyImplDecl - Represents implementation declaration of a property in a class or category imp...
Definition: DeclObjC.h:2773
clang::ObjCForCollectionStmt::getBody
Stmt * getBody()
Definition: StmtObjC.h:38
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:542
clang::ConditionalOperator
ConditionalOperator - The ?: ternary operator.
Definition: Expr.h:3732
CharInfo.h
clang::CompoundStmt
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:1332
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
clang::CastKind
CastKind
CastKind - The kind of operation required for a conversion.
Definition: OperationKinds.h:20
clang::ImplicitCastExpr::Create
static ImplicitCastExpr * Create(const ASTContext &Context, QualType T, CastKind Kind, Expr *Operand, const CXXCastPath *BasePath, ExprValueKind Cat)
Definition: Expr.cpp:1993
Filename
StringRef Filename
Definition: Format.cpp:1825
clang::UnaryExprOrTypeTraitExpr
UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated) expression operand...
Definition: Expr.h:2372
ASTConsumers.h
clang::DeclRefExpr::getLocation
SourceLocation getLocation() const
Definition: Expr.h:1255
clang::ObjCListBase::empty
bool empty() const
Definition: DeclObjC.h:71
clang::ObjCMethodDecl::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclObjC.cpp:991
clang::ASTContext::getTrivialTypeSourceInfo
TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const
Allocate a TypeSourceInfo where all locations have been initialized to a given location, which defaults to the empty location.
Definition: ASTContext.cpp:2816
clang::ObjCInterfaceDecl::ivar_size
unsigned ivar_size() const
Definition: DeclObjC.h:1490
clang::ArrayType::Normal
Definition: Type.h:2896
clang::ObjCProtocolDecl::hasDefinition
bool hasDefinition() const
Determine whether this protocol has a definition.
Definition: DeclObjC.h:2212
clang::CodeGen::BLOCK_HAS_CXX_OBJ
Definition: CGBlocks.h:58
clang::StringLiteral::Create
static StringLiteral * Create(const ASTContext &Ctx, StringRef Str, StringKind Kind, bool Pascal, QualType Ty, const SourceLocation *Loc, unsigned NumConcatenated)
This is the "fully general" constructor that allows representation of strings formed from multiple co...
Definition: Expr.cpp:1084
clang::CallExpr::Create
static CallExpr * Create(const ASTContext &Ctx, Expr *Fn, ArrayRef< Expr *> Args, QualType Ty, ExprValueKind VK, SourceLocation RParenLoc, unsigned MinNumArgs=0, ADLCallKind UsesADL=NotADL)
Create a call expression.
Definition: Expr.cpp:1384
clang::BlockDecl
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4037
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
clang::Expr
This represents one expression.
Definition: Expr.h:108
clang::ObjCImplementationDecl::ivar_end
ivar_iterator ivar_end() const
Definition: DeclObjC.h:2723
ParentMap.h
clang::ObjCInterfaceDecl::ivar_begin
ivar_iterator ivar_begin() const
Definition: DeclObjC.h:1474
clang::Lexer::MeasureTokenLength
static unsigned MeasureTokenLength(SourceLocation Loc, const SourceManager &SM, const LangOptions &LangOpts)
MeasureTokenLength - Relex the token at the specified location and return its length in bytes in the ...
Definition: Lexer.cpp:444
clang::CodeGen::BLOCK_BYREF_CALLER
Definition: CGBlocks.h:104
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
clang::BlockExpr
BlockExpr - Adaptor class for mixing a BlockDecl with expressions.
Definition: Expr.h:5579
clang::FunctionDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:2071
clang::ObjCProtocolDecl::isThisDeclarationADefinition
bool isThisDeclarationADefinition() const
Determine whether this particular declaration is also the definition.
Definition: DeclObjC.h:2235
clang::ObjCMessageExpr::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: ExprObjC.h:1453
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:558
clang::ASTContext::getTagDeclType
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl...
Definition: ASTContext.cpp:5244
clang::CodeGen::BLOCK_BYREF_CURRENT_MAX
Definition: CGBlocks.h:106
clang::ObjCAtSynchronizedStmt::getSynchBody
const CompoundStmt * getSynchBody() const
Definition: StmtObjC.h:297
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:438
clang::SourceManager::isWrittenInMainFile
bool isWrittenInMainFile(SourceLocation Loc) const
Returns true if the spelling location for the given location is in the main file buffer.
Definition: SourceManager.h:1470
clang::ObjCAtSynchronizedStmt
Represents Objective-C&#39;s @synchronized statement.
Definition: StmtObjC.h:277
clang::ObjCInterfaceDecl::getSuperClass
ObjCInterfaceDecl * getSuperClass() const
Definition: DeclObjC.cpp:337
clang::ObjCSelectorExpr
ObjCSelectorExpr used for @selector in Objective-C.
Definition: ExprObjC.h:454
Lexer.h
clang::isAlphanumeric
LLVM_READONLY bool isAlphanumeric(unsigned char c)
Return true if this character is an ASCII letter or digit: [a-zA-Z0-9].
Definition: CharInfo.h:117
clang::ObjCForCollectionStmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtObjC.h:57
clang::DeclRefExpr::refersToEnclosingVariableOrCapture
bool refersToEnclosingVariableOrCapture() const
Does this DeclRefExpr refer to an enclosing local or a captured variable?
Definition: Expr.h:1377
clang::QualType::getAsStringInternal
void getAsStringInternal(std::string &Str, const PrintingPolicy &Policy) const
Definition: TypePrinter.cpp:1909
IdentifierTable.h
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
clang::Expr::getType
QualType getType() const
Definition: Expr.h:137
clang::ObjCInterfaceDecl::lookupInstanceVariable
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:620
clang::ObjCImplDecl::property_impls
propimpl_range property_impls() const
Definition: DeclObjC.h:2481
clang::ObjCAtTryStmt::getTryBody
const Stmt * getTryBody() const
Retrieve the @try body.
Definition: StmtObjC.h:208
clang::ObjCEncodeExpr::getEncodedType
QualType getEncodedType() const
Definition: ExprObjC.h:428
clang::isa
bool isa(CodeGen::Address addr)
Definition: Address.h:111
clang::ObjCMessageExpr
An expression that sends a message to the given Objective-C object or class.
Definition: ExprObjC.h:950
clang::ASTContext::getObjCInterfaceType
QualType getObjCInterfaceType(const ObjCInterfaceDecl *Decl, ObjCInterfaceDecl *PrevDecl=nullptr) const
getObjCInterfaceType - Return the unique reference to the type for the specified ObjC interface decl...
Definition: ASTContext.cpp:5003
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:217
clang::UnaryOperator
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2046
clang::ObjCMethodDecl::isInstanceMethod
bool isInstanceMethod() const
Definition: DeclObjC.h:423
clang::ASTContext::getFunctionType
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
Definition: ASTContext.h:1401
clang::ObjCMessageExpr::getReceiverKind
ReceiverKind getReceiverKind() const
Determine the kind of receiver that this message is being sent to.
Definition: ExprObjC.h:1234
clang::Rewriter::getRangeSize
int getRangeSize(SourceRange Range, RewriteOptions opts=RewriteOptions()) const
getRangeSize - Return the size in bytes of the specified range if they are in the same file...
Definition: Rewriter.cpp:175
ASTConsumer.h
clang::ObjCIvarRefExpr::setBase
void setBase(Expr *base)
Definition: ExprObjC.h:582
clang::DeclRefExpr::getDecl
ValueDecl * getDecl()
Definition: Expr.h:1247
clang::ObjCMethodDecl::getSelector
Selector getSelector() const
Definition: DeclObjC.h:322
clang::ASTContext::getTypeDeclType
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1417
clang::ObjCSubstitutionContext::Result
The result type of a method or function.
clang::SourceManager::getExpansionLineNumber
unsigned getExpansionLineNumber(SourceLocation Loc, bool *Invalid=nullptr) const
Definition: SourceManager.cpp:1377
clang::ObjCPropertyImplDecl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclObjC.h:2834
clang::CStyleCastExpr
CStyleCastExpr - An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++ [expr.cast]), which uses the syntax (Type)expr.
Definition: Expr.h:3371
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
clang::ObjCMethodDecl::getSelfDecl
ImplicitParamDecl * getSelfDecl() const
Definition: DeclObjC.h:415
clang::ObjCAtCatchStmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtObjC.h:110
clang::SkipFunctionBodiesScope::Preamble
SM
const SourceManager & SM
Definition: Format.cpp:1685
clang::CompoundStmt::getEndLoc
SourceLocation getEndLoc() const
Definition: Stmt.h:1437
clang::ObjCMessageExpr::getArg
Expr * getArg(unsigned Arg)
getArg - Return the specified argument.
Definition: ExprObjC.h:1395
clang::TypeOfExprType::getUnderlyingExpr
Expr * getUnderlyingExpr() const
Definition: Type.h:4309
clang::Stmt::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: Stmt.cpp:288
clang::QualType::getCVRQualifiers
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6289
getIvarAccessString
static std::string getIvarAccessString(ObjCIvarDecl *OID)
Definition: RewriteObjC.cpp:756
clang::ObjCMethodDecl::setBody
void setBody(Stmt *B)
Definition: DeclObjC.h:524
clang::QualType::isConstQualified
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6315
clang::BlockDecl::param_begin
param_iterator param_begin()
Definition: Decl.h:4135
clang::CodeGen::BLOCK_FIELD_IS_WEAK
Definition: CGBlocks.h:101
clang::ObjCMessageExpr::getNumArgs
unsigned getNumArgs() const
Return the number of actual arguments in this message, not counting the receiver. ...
Definition: ExprObjC.h:1382
clang::Selector::getAsString
std::string getAsString() const
Derive the full selector name (e.g.
Definition: IdentifierTable.cpp:469
clang::TTK_Struct
The "struct" keyword.
Definition: Type.h:5189
Kind
Kind
Definition: ChrootChecker.cpp:29
Attr.h
clang::Rewriter::setSourceMgr
void setSourceMgr(SourceManager &SM, const LangOptions &LO)
Definition: Rewriter.h:72
clang::PseudoObjectExpr
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5715
clang::FunctionProtoType::param_types
param_type_range param_types() const
Definition: Type.h:4119
clang::ObjCImplementationDecl::ivar_begin
ivar_iterator ivar_begin() const
Definition: DeclObjC.h:2719
clang::ObjCContainerDecl::classmeth_end
classmeth_iterator classmeth_end() const
Definition: DeclObjC.h:1093
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::ObjCInterfaceType::getDecl
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition: Type.h:5908
clang::IdentifierTable::get
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Definition: IdentifierTable.h:529
clang::FunctionType::getReturnType
QualType getReturnType() const
Definition: Type.h:3680
clang::ObjCInterfaceDecl::ivar_end
ivar_iterator ivar_end() const
Definition: DeclObjC.h:1482
clang::ObjCAtCatchStmt::getCatchBody
const Stmt * getCatchBody() const
Definition: StmtObjC.h:93
clang::ObjCInterfaceType
Interfaces are the core concept in Objective-C for object oriented design.
Definition: Type.h:5894
clang::NamedDecl::getNameAsString
std::string getNameAsString() const
Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...
Definition: Decl.h:266
clang::DeclStmt
DeclStmt - Adaptor class for mixing declarations with statements and expressions. ...
Definition: Stmt.h:1225
clang::ObjCList< ObjCProtocolDecl >
clang::ASTContext::getObjCSelType
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C &#39;SEL&#39; type.
Definition: ASTContext.h:1884
clang::Rewriter::getRewriteBufferFor
const RewriteBuffer * getRewriteBufferFor(FileID FID) const
getRewriteBufferFor - Return the rewrite buffer for the specified FileID.
Definition: Rewriter.h:198
clang::ObjCMethodDecl::getBody
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition: DeclObjC.cpp:855
clang::ASTContext::getBaseElementType
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Definition: ASTContext.cpp:5822
clang::Type::isIntegralType
bool isIntegralType(const ASTContext &Ctx) const
Determine whether this type is an integral type.
Definition: Type.cpp:1844
clang::Rewriter::InsertText
bool InsertText(SourceLocation Loc, StringRef Str, bool InsertAfter=true, bool indentNewLines=false)
InsertText - Insert the specified string at the specified location in the original buffer...
Definition: Rewriter.cpp:255
HasLocalVariableExternalStorage
static bool HasLocalVariableExternalStorage(ValueDecl *VD)
Definition: RewriteObjC.cpp:3251
clang::CodeGen::BLOCK_FIELD_IS_OBJECT
Definition: CGBlocks.h:95
clang::ObjCMessageExpr::getSuperLoc
SourceLocation getSuperLoc() const
Retrieve the location of the &#39;super&#39; keyword for a class or instance message to &#39;super&#39;, otherwise an invalid source location.
Definition: ExprObjC.h:1301
clang::ObjCCategoryDecl
ObjCCategoryDecl - Represents a category declaration.
Definition: DeclObjC.h:2294
clang::ASTContext::VoidTy
CanQualType VoidTy
Definition: ASTContext.h:1016
clang::DeclStmt::decl_begin
decl_iterator decl_begin()
Definition: Stmt.h:1279
clang::ObjCProtocolExpr
ObjCProtocolExpr used for protocol expression in Objective-C.
Definition: ExprObjC.h:503
llvm::SmallVector
Definition: LLVM.h:35
clang::Type::isObjCObjectPointerType
bool isObjCObjectPointerType() const
Definition: Type.h:6618
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:741
clang::CodeGen::BLOCK_FIELD_IS_BLOCK
Definition: CGBlocks.h:97
clang::ImplicitCastExpr
ImplicitCastExpr - Allows us to explicitly represent implicit type conversions, which have no direct ...
Definition: Expr.h:3274
clang::ObjCMessageExpr::isImplicit
bool isImplicit() const
Indicates whether the message send was implicitly generated by the implementation.
Definition: ExprObjC.h:1230
clang::DiagnosticsEngine::getCustomDiagID
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition: Diagnostic.h:782
clang::ObjCInterfaceDecl::isImplicitInterfaceDecl
bool isImplicitInterfaceDecl() const
isImplicitInterfaceDecl - check that this is an implicitly declared ObjCInterfaceDecl node...
Definition: DeclObjC.h:1907
clang::ObjCMessageExpr::getMethodDecl
const ObjCMethodDecl * getMethodDecl() const
Definition: ExprObjC.h:1356
clang::ObjCPropertyDecl::OBJC_PR_copy
Definition: DeclObjC.h:752
clang::ContinueStmt::getBeginLoc
SourceLocation getBeginLoc() const
Definition: Stmt.h:2581
clang::ObjCContainerDecl::classmeth_begin
classmeth_iterator classmeth_begin() const
Definition: DeclObjC.h:1089
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:224
clang::ASTContext::getObjCInstanceType
QualType getObjCInstanceType()
Retrieve the Objective-C "instancetype" type, if already known; otherwise, returns a NULL type;...
Definition: ASTContext.h:1755
clang::ObjCForCollectionStmt::getElement
Stmt * getElement()
Definition: StmtObjC.h:34
clang::IdentifierInfo::getName
StringRef getName() const
Return the actual identifier string.
Definition: IdentifierTable.h:155
clang::DeclContext::decl_iterator
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1990
clang::ObjCMessageExpr::getInstanceReceiver
Expr * getInstanceReceiver()
Returns the object expression (receiver) for an instance message, or null for a message that is not a...
Definition: ExprObjC.h:1260
clang::QualType::isObjCGCWeak
bool isObjCGCWeak() const
true when Type is objc&#39;s weak.
Definition: Type.h:1070
clang::TypedefNameDecl
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:3071
clang::PseudoObjectExpr::getResultExpr
Expr * getResultExpr()
Return the result-bearing expression, or null if there is none.
Definition: Expr.h:5770
clang::FileID
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
Definition: SourceLocation.h:38
clang::frontend::RewriteObjC
ObjC->C Rewriter.
Definition: FrontendOptions.h:120
clang::ASTContext::CharTy
CanQualType CharTy
Definition: ASTContext.h:1018
clang::SourceManager::getBuffer
const llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
Definition: SourceManager.h:984
clang::FunctionDecl::setBody
void setBody(Stmt *B)
Definition: Decl.cpp:2906
clang::ObjCImplDecl::getClassInterface
const ObjCInterfaceDecl * getClassInterface() const
Definition: DeclObjC.h:2454
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::Type::isObjCQualifiedInterfaceType
bool isObjCQualifiedInterfaceType() const
Definition: Type.cpp:1635
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:106
clang::ObjCImplementationDecl::ivars
ivar_range ivars() const
Definition: DeclObjC.h:2717
clang::BlockDecl::captures
ArrayRef< Capture > captures() const
Definition: Decl.h:4164
scanToNextArgument
static void scanToNextArgument(const char *&argRef)
Definition: RewriteObjC.cpp:2051
clang::ObjCPropertyImplDecl::getPropertyImplementation
Kind getPropertyImplementation() const
Definition: DeclObjC.h:2842
clang::ObjCPropertyDecl::getAtLoc
SourceLocation getAtLoc() const
Definition: DeclObjC.h:834
clang::ObjCMessageExpr::getSuperType
QualType getSuperType() const
Retrieve the type referred to by &#39;super&#39;.
Definition: ExprObjC.h:1336
clang::SC_Extern
Definition: Specifiers.h:238
RewriteOneForwardClassDecl
static void RewriteOneForwardClassDecl(ObjCInterfaceDecl *ForwardDecl, std::string &typedefString)
Definition: RewriteObjC.cpp:890
type
clang::ObjCInterfaceDecl::getReferencedProtocols
const ObjCProtocolList & getReferencedProtocols() const
Definition: DeclObjC.h:1355
clang::VarDecl::getInit
const Expr * getInit() const
Definition: Decl.h:1229
clang::SourceManager::getMainFileID
FileID getMainFileID() const
Returns the FileID of the main source file.
Definition: SourceManager.h:807
clang::ObjCAtSynchronizedStmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtObjC.h:313
printf
int printf(__constant const char *st,...) __attribute__((format(printf
clang::DeclGroupRef
Definition: DeclGroup.h:51
clang::ObjCPropertyDecl::OBJC_PR_retain
Definition: DeclObjC.h:751
clang::QualType::getAsString
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition: Type.h:990
clang::Decl::getKind
Kind getKind() const
Definition: DeclBase.h:432
clang::Type::isBooleanType
bool isBooleanType() const
Definition: Type.h:6894
clang::ObjCListBase::size
unsigned size() const
Definition: DeclObjC.h:70
clang::ASTContext::getFunctionNoProtoType
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like &#39;int()&#39;.
Definition: ASTContext.cpp:3836
clang::cast
U cast(CodeGen::Address addr)
Definition: Address.h:108
clang::ObjCAtSynchronizedStmt::getSynchExpr
const Expr * getSynchExpr() const
Definition: StmtObjC.h:305
clang::ObjCIvarDecl::getContainingInterface
const ObjCInterfaceDecl * getContainingInterface() const
Return the class interface that this ivar is logically contained in; this is either the interface whe...
Definition: DeclObjC.cpp:1815
clang::CodeGen::BLOCK_FIELD_IS_BYREF
Definition: CGBlocks.h:99
clang::StringLiteral::Ascii
Definition: Expr.h:1733
clang::DeclContext::specific_decl_iterator
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:2053
scanForProtocolRefs
static bool scanForProtocolRefs(const char *startBuf, const char *endBuf, const char *&startRef, const char *&endRef)
Definition: RewriteObjC.cpp:2034
clang::Expr::IgnoreParenImpCasts
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2990
clang::DiagnosticsEngine::Warning
Definition: Diagnostic.h:156
clang::ObjCMessageExpr::getClassReceiver
QualType getClassReceiver() const
Returns the type of a class message send, or NULL if the message is not a class message.
Definition: ExprObjC.h:1279
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:5951
clang::StringLiteral::getByteLength
unsigned getByteLength() const
Definition: Expr.h:1822
clang::BlockPointerType
Pointer to a block type.
Definition: Type.h:2716
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2566
clang::Expr::IgnoreImplicit
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2978
clang::ObjCForCollectionStmt::getRParenLoc
SourceLocation getRParenLoc() const
Definition: StmtObjC.h:54
BuildUniqueMethodName
static void BuildUniqueMethodName(std::string &Name, ObjCMethodDecl *MD)
Definition: RewriteObjC.cpp:3631
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
clang::Stmt::CastIterator
Iterator for iterating over Stmt * arrays that contain only T *.
Definition: Stmt.h:1064
clang::ObjCForCollectionStmt
Represents Objective-C&#39;s collection statement.
Definition: StmtObjC.h:23
clang::CallExpr::arg_begin
arg_iterator arg_begin()
Definition: Expr.h:2744
clang::ObjCEncodeExpr
ObjCEncodeExpr, used for @encode in Objective-C.
Definition: ExprObjC.h:407
clang::ObjCAtCatchStmt::hasEllipsis
bool hasEllipsis() const
Definition: StmtObjC.h:113
clang::CStyleCastExpr::Create
static CStyleCastExpr * Create(const ASTContext &Context, QualType T, ExprValueKind VK, CastKind K, Expr *Op, const CXXCastPath *BasePath, TypeSourceInfo *WrittenTy, SourceLocation L, SourceLocation R)
Definition: Expr.cpp:2019
clang::ASTContext::getCharWidth
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Definition: ASTContext.h:2108
clang::ObjCCategoryDecl::protocol_begin
protocol_iterator protocol_begin() const
Definition: DeclObjC.h:2374
clang::ASTContext::getObjCEncodingForType
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
Definition: ASTContext.cpp:6783
clang::Type::isObjCQualifiedIdType
bool isObjCQualifiedIdType() const
Definition: Type.h:6639
clang::DeclStmt::decls
decl_range decls()
Definition: Stmt.h:1273
clang::ObjCInterfaceDecl::getCanonicalDecl
ObjCInterfaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this Objective-C class.
Definition: DeclObjC.h:1929
clang::ObjCAtFinallyStmt
Represents Objective-C&#39;s @finally statement.
Definition: StmtObjC.h:127
clang::ASTContext::getConstantArrayType
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArrayType::ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type...
Definition: ASTContext.cpp:3325
clang::DeclContext::addDecl
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1524
clang::ObjCIvarRefExpr::getBase
const Expr * getBase() const
Definition: ExprObjC.h:580
clang::ASTContext::getTypeSize
uint64_t getTypeSize(QualType T) const
Return the size of the specified (complete) type T, in bits.
Definition: ASTContext.h:2104
clang::ObjCIvarRefExpr
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
clang::ASTContext::getSourceManager
SourceManager & getSourceManager()
Definition: ASTContext.h:679
clang::ASTContext::getCanonicalType
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
clang::ObjCContainerDecl::getAtEndRange
SourceRange getAtEndRange() const
Definition: DeclObjC.h:1136
X
X
Add a minimal nested name specifier fixit hint to allow lookup of a tag name from an outer enclosing ...
Definition: SemaDecl.cpp:14780
clang::BreakStmt::getBeginLoc
SourceLocation getBeginLoc() const
Definition: Stmt.h:2611
clang::ObjCIvarRefExpr::isFreeIvar
bool isFreeIvar() const
Definition: ExprObjC.h:585
clang::Rewriter
Rewriter - This is the main interface to the rewrite buffers.
Definition: Rewriter.h:32
clang::FunctionProtoType::getParamType
QualType getParamType(unsigned i) const
Definition: Type.h:3966
clang::Stmt::printPretty
void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\, const ASTContext *Context=nullptr) const
Definition: StmtPrinter.cpp:2518
clang::ASTContext::getTranslationUnitDecl
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2836
clang::UETT_SizeOf
Definition: TypeTraits.h:97
clang::ObjCImplementationDecl::ivar_empty
bool ivar_empty() const
Definition: DeclObjC.h:2731
clang::ContinueStmt
ContinueStmt - This represents a continue.
Definition: Stmt.h:2569
clang::ObjCMessageExpr::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: ExprObjC.h:1452
clang::ObjCContainerDecl::classmeth_iterator
filtered_decl_iterator< ObjCMethodDecl, &ObjCMethodDecl::isClassMethod > classmeth_iterator
Definition: DeclObjC.h:1082
clang::SourceLocation::isInvalid
bool isInvalid() const
Definition: SourceLocation.h:107
clang::ObjCIvarDecl
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1959
clang::Rewriter::isRewritable
static bool isRewritable(SourceLocation Loc)
isRewritable - Return true if this location is a raw file location, which is rewritable.
Definition: Rewriter.h:82
clang::TypedefDecl::Create
static TypedefDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.cpp:4803
clang::AttrSyntax::C
clang::ASTContext::getPointerType
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
Definition: ASTContext.cpp:3102
clang::ObjCMethodDecl::isVariadic
bool isVariadic() const
Definition: DeclObjC.h:428
clang::ObjCMessageExpr::Class
The receiver is a class.
Definition: ExprObjC.h:1098
clang::ObjCAtTryStmt
Represents Objective-C&#39;s @try ... @catch ... @finally statement.
Definition: StmtObjC.h:165
clang::ObjCCategoryDecl::protocol_end
protocol_iterator protocol_end() const
Definition: DeclObjC.h:2378
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
clang::ObjCAtTryStmt::getNumCatchStmts
unsigned getNumCatchStmts() const
Retrieve the number of @catch statements in this try-catch-finally block.
Definition: StmtObjC.h:214
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1711
clang::CallExpr
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2546
clang::ObjCMethodDecl::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclObjC.h:284
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:250
clang::ObjCImplementationDecl::getName
StringRef getName() const
getName - Get the name of identifier for the class interface associated with this implementation as a...
Definition: DeclObjC.h:2687
clang::ASTContext::IntTy
CanQualType IntTy
Definition: ASTContext.h:1025
clang::TranslationUnitDecl
The top declaration context.
Definition: Decl.h:82
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1171
clang::ObjCPropertyImplDecl::getPropertyDecl
ObjCPropertyDecl * getPropertyDecl() const
Definition: DeclObjC.h:2837
clang::CompoundStmt::getBeginLoc
SourceLocation getBeginLoc() const
Definition: Stmt.h:1436
clang::Type::isPointerType
bool isPointerType() const
Definition: Type.h:6504
clang::BreakStmt
BreakStmt - This represents a break.
Definition: Stmt.h:2599
clang::PseudoObjectExpr::getSemanticExpr
Expr * getSemanticExpr(unsigned index)
Definition: Expr.h:5803
clang::ObjCAtCatchStmt::getCatchParamDecl
const VarDecl * getCatchParamDecl() const
Definition: StmtObjC.h:97
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:630
clang::VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:129
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:207
clang::ObjCContainerDecl::instmeth_begin
instmeth_iterator instmeth_begin() const
Definition: DeclObjC.h:1072
clang::FunctionProtoType::ExtProtoInfo::Variadic
bool Variadic
Definition: Type.h:3839
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:223
clang::ASTContext::DoubleTy
CanQualType DoubleTy
Definition: ASTContext.h:1028
clang::ObjCInterfaceDecl::getEndOfDefinitionLoc
SourceLocation getEndOfDefinitionLoc() const
Definition: DeclObjC.h:1892
clang::ObjCMessageExpr::getRightLoc
SourceLocation getRightLoc() const
Definition: ExprObjC.h:1417
clang::Type::isFunctionPointerType
bool isFunctionPointerType() const
Definition: Type.h:6538
clang::FieldDecl::Create
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.cpp:4006
clang::ObjCMessageExpr::SuperClass
The receiver is a superclass.
Definition: ExprObjC.h:1104
clang::ObjCMessageExpr::getSelectorLocs
void getSelectorLocs(SmallVectorImpl< SourceLocation > &SelLocs) const
Definition: ExprObjC.cpp:289
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:216
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:724
clang::ASTContext::getFullLoc
FullSourceLoc getFullLoc(SourceLocation Loc) const
Definition: ASTContext.h:736
clang::ObjCCategoryImplDecl
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2513
clang::ICIS_NoInit
No in-class initializer.
Definition: Specifiers.h:259
clang::ObjCAtThrowStmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: StmtObjC.h:351
clang::SourceManager
This class handles loading and caching of source files into memory.
Definition: SourceManager.h:596
clang::ASTContext::BlockRequiresCopying
bool BlockRequiresCopying(QualType Ty, const VarDecl *D)
Returns true iff we need copy/dispose helpers for the given type.
Definition: ASTContext.cpp:6359
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:429
clang::ObjCMethodDecl::parameters
ArrayRef< ParmVarDecl * > parameters() const
Definition: DeclObjC.h:368
clang::ObjCMessageExpr::getClassReceiverTypeInfo
TypeSourceInfo * getClassReceiverTypeInfo() const
Returns a type-source information of a class message send, or nullptr if the message is not a class m...
Definition: ExprObjC.h:1288
clang::ASTContext::getSizeType
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Definition: ASTContext.cpp:5254
clang::ObjCInterfaceDecl::FindCategoryDeclaration
ObjCCategoryDecl * FindCategoryDeclaration(IdentifierInfo *CategoryId) const
FindCategoryDeclaration - Finds category declaration in the list of categories for this class and ret...
Definition: DeclObjC.cpp:1689