Bug Summary

File:clang/lib/Frontend/Rewrite/RewriteObjC.cpp
Warning:line 3962, column 11
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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