/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp
Line | Count | Source (jump to first uncovered line) |
1 | | //===-- RewriteModernObjC.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/Basic/TargetInfo.h" |
23 | | #include "clang/Config/config.h" |
24 | | #include "clang/Lex/Lexer.h" |
25 | | #include "clang/Rewrite/Core/Rewriter.h" |
26 | | #include "llvm/ADT/DenseSet.h" |
27 | | #include "llvm/ADT/SetVector.h" |
28 | | #include "llvm/ADT/SmallPtrSet.h" |
29 | | #include "llvm/ADT/StringExtras.h" |
30 | | #include "llvm/Support/MemoryBuffer.h" |
31 | | #include "llvm/Support/raw_ostream.h" |
32 | | #include <memory> |
33 | | |
34 | | #if CLANG_ENABLE_OBJC_REWRITER |
35 | | |
36 | | using namespace clang; |
37 | | using llvm::utostr; |
38 | | |
39 | | namespace { |
40 | | class RewriteModernObjC : public ASTConsumer { |
41 | | protected: |
42 | | |
43 | | enum { |
44 | | BLOCK_FIELD_IS_OBJECT = 3, /* id, NSObject, __attribute__((NSObject)), |
45 | | block, ... */ |
46 | | BLOCK_FIELD_IS_BLOCK = 7, /* a block variable */ |
47 | | BLOCK_FIELD_IS_BYREF = 8, /* the on stack structure holding the |
48 | | __block variable */ |
49 | | BLOCK_FIELD_IS_WEAK = 16, /* declared __weak, only used in byref copy |
50 | | helpers */ |
51 | | BLOCK_BYREF_CALLER = 128, /* called from __block (byref) copy/dispose |
52 | | support routines */ |
53 | | BLOCK_BYREF_CURRENT_MAX = 256 |
54 | | }; |
55 | | |
56 | | enum { |
57 | | BLOCK_NEEDS_FREE = (1 << 24), |
58 | | BLOCK_HAS_COPY_DISPOSE = (1 << 25), |
59 | | BLOCK_HAS_CXX_OBJ = (1 << 26), |
60 | | BLOCK_IS_GC = (1 << 27), |
61 | | BLOCK_IS_GLOBAL = (1 << 28), |
62 | | BLOCK_HAS_DESCRIPTOR = (1 << 29) |
63 | | }; |
64 | | |
65 | | Rewriter Rewrite; |
66 | | DiagnosticsEngine &Diags; |
67 | | const LangOptions &LangOpts; |
68 | | ASTContext *Context; |
69 | | SourceManager *SM; |
70 | | TranslationUnitDecl *TUDecl; |
71 | | FileID MainFileID; |
72 | | const char *MainFileStart, *MainFileEnd; |
73 | | Stmt *CurrentBody; |
74 | | ParentMap *PropParentMap; // created lazily. |
75 | | std::string InFileName; |
76 | | std::unique_ptr<raw_ostream> OutFile; |
77 | | std::string Preamble; |
78 | | |
79 | | TypeDecl *ProtocolTypeDecl; |
80 | | VarDecl *GlobalVarDecl; |
81 | | Expr *GlobalConstructionExp; |
82 | | unsigned RewriteFailedDiag; |
83 | | unsigned GlobalBlockRewriteFailedDiag; |
84 | | // ObjC string constant support. |
85 | | unsigned NumObjCStringLiterals; |
86 | | VarDecl *ConstantStringClassReference; |
87 | | RecordDecl *NSStringRecord; |
88 | | |
89 | | // ObjC foreach break/continue generation support. |
90 | | int BcLabelCount; |
91 | | |
92 | | unsigned TryFinallyContainsReturnDiag; |
93 | | // Needed for super. |
94 | | ObjCMethodDecl *CurMethodDef; |
95 | | RecordDecl *SuperStructDecl; |
96 | | RecordDecl *ConstantStringDecl; |
97 | | |
98 | | FunctionDecl *MsgSendFunctionDecl; |
99 | | FunctionDecl *MsgSendSuperFunctionDecl; |
100 | | FunctionDecl *MsgSendStretFunctionDecl; |
101 | | FunctionDecl *MsgSendSuperStretFunctionDecl; |
102 | | FunctionDecl *MsgSendFpretFunctionDecl; |
103 | | FunctionDecl *GetClassFunctionDecl; |
104 | | FunctionDecl *GetMetaClassFunctionDecl; |
105 | | FunctionDecl *GetSuperClassFunctionDecl; |
106 | | FunctionDecl *SelGetUidFunctionDecl; |
107 | | FunctionDecl *CFStringFunctionDecl; |
108 | | FunctionDecl *SuperConstructorFunctionDecl; |
109 | | FunctionDecl *CurFunctionDef; |
110 | | |
111 | | /* Misc. containers needed for meta-data rewrite. */ |
112 | | SmallVector<ObjCImplementationDecl *, 8> ClassImplementation; |
113 | | SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation; |
114 | | llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs; |
115 | | llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols; |
116 | | llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCWrittenInterfaces; |
117 | | llvm::SmallPtrSet<TagDecl*, 32> GlobalDefinedTags; |
118 | | SmallVector<ObjCInterfaceDecl*, 32> ObjCInterfacesSeen; |
119 | | /// DefinedNonLazyClasses - List of defined "non-lazy" classes. |
120 | | SmallVector<ObjCInterfaceDecl*, 8> DefinedNonLazyClasses; |
121 | | |
122 | | /// DefinedNonLazyCategories - List of defined "non-lazy" categories. |
123 | | SmallVector<ObjCCategoryDecl *, 8> DefinedNonLazyCategories; |
124 | | |
125 | | SmallVector<Stmt *, 32> Stmts; |
126 | | SmallVector<int, 8> ObjCBcLabelNo; |
127 | | // Remember all the @protocol(<expr>) expressions. |
128 | | llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ProtocolExprDecls; |
129 | | |
130 | | llvm::DenseSet<uint64_t> CopyDestroyCache; |
131 | | |
132 | | // Block expressions. |
133 | | SmallVector<BlockExpr *, 32> Blocks; |
134 | | SmallVector<int, 32> InnerDeclRefsCount; |
135 | | SmallVector<DeclRefExpr *, 32> InnerDeclRefs; |
136 | | |
137 | | SmallVector<DeclRefExpr *, 32> BlockDeclRefs; |
138 | | |
139 | | // Block related declarations. |
140 | | SmallVector<ValueDecl *, 8> BlockByCopyDecls; |
141 | | llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDeclsPtrSet; |
142 | | SmallVector<ValueDecl *, 8> BlockByRefDecls; |
143 | | llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDeclsPtrSet; |
144 | | llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo; |
145 | | llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls; |
146 | | llvm::SmallPtrSet<VarDecl *, 8> ImportedLocalExternalDecls; |
147 | | |
148 | | llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs; |
149 | | llvm::DenseMap<ObjCInterfaceDecl *, |
150 | | llvm::SmallSetVector<ObjCIvarDecl *, 8> > ReferencedIvars; |
151 | | |
152 | | // ivar bitfield grouping containers |
153 | | llvm::DenseSet<const ObjCInterfaceDecl *> ObjCInterefaceHasBitfieldGroups; |
154 | | llvm::DenseMap<const ObjCIvarDecl* , unsigned> IvarGroupNumber; |
155 | | // This container maps an <class, group number for ivar> tuple to the type |
156 | | // of the struct where the bitfield belongs. |
157 | | llvm::DenseMap<std::pair<const ObjCInterfaceDecl*, unsigned>, QualType> GroupRecordType; |
158 | | SmallVector<FunctionDecl*, 32> FunctionDefinitionsSeen; |
159 | | |
160 | | // This maps an original source AST to it's rewritten form. This allows |
161 | | // us to avoid rewriting the same node twice (which is very uncommon). |
162 | | // This is needed to support some of the exotic property rewriting. |
163 | | llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes; |
164 | | |
165 | | // Needed for header files being rewritten |
166 | | bool IsHeader; |
167 | | bool SilenceRewriteMacroWarning; |
168 | | bool GenerateLineInfo; |
169 | | bool objc_impl_method; |
170 | | |
171 | | bool DisableReplaceStmt; |
172 | | class DisableReplaceStmtScope { |
173 | | RewriteModernObjC &R; |
174 | | bool SavedValue; |
175 | | |
176 | | public: |
177 | | DisableReplaceStmtScope(RewriteModernObjC &R) |
178 | 130 | : R(R), SavedValue(R.DisableReplaceStmt) { |
179 | 130 | R.DisableReplaceStmt = true; |
180 | 130 | } |
181 | 130 | ~DisableReplaceStmtScope() { |
182 | 130 | R.DisableReplaceStmt = SavedValue; |
183 | 130 | } |
184 | | }; |
185 | | void InitializeCommon(ASTContext &context); |
186 | | |
187 | | public: |
188 | | llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames; |
189 | | |
190 | | // Top Level Driver code. |
191 | 584 | bool HandleTopLevelDecl(DeclGroupRef D) override { |
192 | 998 | for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I414 ) { |
193 | 667 | if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*I)) { |
194 | 157 | if (!Class->isThisDeclarationADefinition()) { |
195 | 11 | RewriteForwardClassDecl(D); |
196 | 11 | break; |
197 | 146 | } else { |
198 | | // Keep track of all interface declarations seen. |
199 | 146 | ObjCInterfacesSeen.push_back(Class); |
200 | 146 | break; |
201 | 146 | } |
202 | 157 | } |
203 | | |
204 | 510 | if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*I)) { |
205 | 18 | if (!Proto->isThisDeclarationADefinition()) { |
206 | 2 | RewriteForwardProtocolDecl(D); |
207 | 2 | break; |
208 | 2 | } |
209 | 18 | } |
210 | | |
211 | 508 | if (FunctionDecl *FDecl = dyn_cast<FunctionDecl>(*I)) { |
212 | | // Under modern abi, we cannot translate body of the function |
213 | | // yet until all class extensions and its implementation is seen. |
214 | | // This is because they may introduce new bitfields which must go |
215 | | // into their grouping struct. |
216 | 172 | if (FDecl->isThisDeclarationADefinition() && |
217 | | // Not c functions defined inside an objc container. |
218 | 172 | !FDecl->isTopLevelDeclInObjCContainer()96 ) { |
219 | 94 | FunctionDefinitionsSeen.push_back(FDecl); |
220 | 94 | break; |
221 | 94 | } |
222 | 172 | } |
223 | 414 | HandleTopLevelSingleDecl(*I); |
224 | 414 | } |
225 | 584 | return true; |
226 | 584 | } |
227 | | |
228 | 1 | void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) override { |
229 | 2 | for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I1 ) { |
230 | 1 | if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(*I)) { |
231 | 1 | if (isTopLevelBlockPointerType(TD->getUnderlyingType())) |
232 | 1 | RewriteBlockPointerDecl(TD); |
233 | 0 | else if (TD->getUnderlyingType()->isFunctionPointerType()) |
234 | 0 | CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); |
235 | 0 | else |
236 | 0 | RewriteObjCQualifiedInterfaceTypes(TD); |
237 | 1 | } |
238 | 1 | } |
239 | 1 | } |
240 | | |
241 | | void HandleTopLevelSingleDecl(Decl *D); |
242 | | void HandleDeclInMainFile(Decl *D); |
243 | | RewriteModernObjC(std::string inFile, std::unique_ptr<raw_ostream> OS, |
244 | | DiagnosticsEngine &D, const LangOptions &LOpts, |
245 | | bool silenceMacroWarn, bool LineInfo); |
246 | | |
247 | 78 | ~RewriteModernObjC() override {} |
248 | | |
249 | | void HandleTranslationUnit(ASTContext &C) override; |
250 | | |
251 | 278 | void ReplaceStmt(Stmt *Old, Stmt *New) { |
252 | 278 | ReplaceStmtWithRange(Old, New, Old->getSourceRange()); |
253 | 278 | } |
254 | | |
255 | 408 | void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) { |
256 | 408 | assert(Old != nullptr && New != nullptr && "Expected non-null Stmt's"); |
257 | | |
258 | 408 | Stmt *ReplacingStmt = ReplacedNodes[Old]; |
259 | 408 | if (ReplacingStmt) |
260 | 0 | return; // We can't rewrite the same node twice. |
261 | | |
262 | 408 | if (DisableReplaceStmt) |
263 | 16 | return; |
264 | | |
265 | | // Measure the old text. |
266 | 392 | int Size = Rewrite.getRangeSize(SrcRange); |
267 | 392 | if (Size == -1) { |
268 | 0 | Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag) |
269 | 0 | << Old->getSourceRange(); |
270 | 0 | return; |
271 | 0 | } |
272 | | // Get the new text. |
273 | 392 | std::string SStr; |
274 | 392 | llvm::raw_string_ostream S(SStr); |
275 | 392 | New->printPretty(S, nullptr, PrintingPolicy(LangOpts)); |
276 | 392 | const std::string &Str = S.str(); |
277 | | |
278 | | // If replacement succeeded or warning disabled return with no warning. |
279 | 392 | if (!Rewrite.ReplaceText(SrcRange.getBegin(), Size, Str)) { |
280 | 392 | ReplacedNodes[Old] = New; |
281 | 392 | return; |
282 | 392 | } |
283 | 0 | if (SilenceRewriteMacroWarning) |
284 | 0 | return; |
285 | 0 | Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag) |
286 | 0 | << Old->getSourceRange(); |
287 | 0 | } |
288 | | |
289 | | void InsertText(SourceLocation Loc, StringRef Str, |
290 | 870 | bool InsertAfter = true) { |
291 | | // If insertion succeeded or warning disabled return with no warning. |
292 | 870 | if (!Rewrite.InsertText(Loc, Str, InsertAfter) || |
293 | 870 | SilenceRewriteMacroWarning0 ) |
294 | 870 | return; |
295 | | |
296 | 0 | Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag); |
297 | 0 | } |
298 | | |
299 | | void ReplaceText(SourceLocation Start, unsigned OrigLength, |
300 | 714 | StringRef Str) { |
301 | | // If removal succeeded or warning disabled return with no warning. |
302 | 714 | if (!Rewrite.ReplaceText(Start, OrigLength, Str) || |
303 | 714 | SilenceRewriteMacroWarning0 ) |
304 | 714 | return; |
305 | | |
306 | 0 | Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag); |
307 | 0 | } |
308 | | |
309 | | // Syntactic Rewriting. |
310 | | void RewriteRecordBody(RecordDecl *RD); |
311 | | void RewriteInclude(); |
312 | | void RewriteLineDirective(const Decl *D); |
313 | | void ConvertSourceLocationToLineDirective(SourceLocation Loc, |
314 | | std::string &LineString); |
315 | | void RewriteForwardClassDecl(DeclGroupRef D); |
316 | | void RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &DG); |
317 | | void RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl, |
318 | | const std::string &typedefString); |
319 | | void RewriteImplementations(); |
320 | | void RewritePropertyImplDecl(ObjCPropertyImplDecl *PID, |
321 | | ObjCImplementationDecl *IMD, |
322 | | ObjCCategoryImplDecl *CID); |
323 | | void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl); |
324 | | void RewriteImplementationDecl(Decl *Dcl); |
325 | | void RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl, |
326 | | ObjCMethodDecl *MDecl, std::string &ResultStr); |
327 | | void RewriteTypeIntoString(QualType T, std::string &ResultStr, |
328 | | const FunctionType *&FPRetType); |
329 | | void RewriteByRefString(std::string &ResultStr, const std::string &Name, |
330 | | ValueDecl *VD, bool def=false); |
331 | | void RewriteCategoryDecl(ObjCCategoryDecl *Dcl); |
332 | | void RewriteProtocolDecl(ObjCProtocolDecl *Dcl); |
333 | | void RewriteForwardProtocolDecl(DeclGroupRef D); |
334 | | void RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG); |
335 | | void RewriteMethodDeclaration(ObjCMethodDecl *Method); |
336 | | void RewriteProperty(ObjCPropertyDecl *prop); |
337 | | void RewriteFunctionDecl(FunctionDecl *FD); |
338 | | void RewriteBlockPointerType(std::string& Str, QualType Type); |
339 | | void RewriteBlockPointerTypeVariable(std::string& Str, ValueDecl *VD); |
340 | | void RewriteBlockLiteralFunctionDecl(FunctionDecl *FD); |
341 | | void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl); |
342 | | void RewriteTypeOfDecl(VarDecl *VD); |
343 | | void RewriteObjCQualifiedInterfaceTypes(Expr *E); |
344 | | |
345 | | std::string getIvarAccessString(ObjCIvarDecl *D); |
346 | | |
347 | | // Expression Rewriting. |
348 | | Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S); |
349 | | Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp); |
350 | | Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo); |
351 | | Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo); |
352 | | Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp); |
353 | | Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp); |
354 | | Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp); |
355 | | Stmt *RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp); |
356 | | Stmt *RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp); |
357 | | Stmt *RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp); |
358 | | Stmt *RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp); |
359 | | Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp); |
360 | | Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S); |
361 | | Stmt *RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S); |
362 | | Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S); |
363 | | Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S); |
364 | | Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, |
365 | | SourceLocation OrigEnd); |
366 | | Stmt *RewriteBreakStmt(BreakStmt *S); |
367 | | Stmt *RewriteContinueStmt(ContinueStmt *S); |
368 | | void RewriteCastExpr(CStyleCastExpr *CE); |
369 | | void RewriteImplicitCastObjCExpr(CastExpr *IE); |
370 | | |
371 | | // Computes ivar bitfield group no. |
372 | | unsigned ObjCIvarBitfieldGroupNo(ObjCIvarDecl *IV); |
373 | | // Names field decl. for ivar bitfield group. |
374 | | void ObjCIvarBitfieldGroupDecl(ObjCIvarDecl *IV, std::string &Result); |
375 | | // Names struct type for ivar bitfield group. |
376 | | void ObjCIvarBitfieldGroupType(ObjCIvarDecl *IV, std::string &Result); |
377 | | // Names symbol for ivar bitfield group field offset. |
378 | | void ObjCIvarBitfieldGroupOffset(ObjCIvarDecl *IV, std::string &Result); |
379 | | // Given an ivar bitfield, it builds (or finds) its group record type. |
380 | | QualType GetGroupRecordTypeForObjCIvarBitfield(ObjCIvarDecl *IV); |
381 | | QualType SynthesizeBitfieldGroupStructType( |
382 | | ObjCIvarDecl *IV, |
383 | | SmallVectorImpl<ObjCIvarDecl *> &IVars); |
384 | | |
385 | | // Block rewriting. |
386 | | void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D); |
387 | | |
388 | | // Block specific rewrite rules. |
389 | | void RewriteBlockPointerDecl(NamedDecl *VD); |
390 | | void RewriteByRefVar(VarDecl *VD, bool firstDecl, bool lastDecl); |
391 | | Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD); |
392 | | Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE); |
393 | | void RewriteBlockPointerFunctionArgs(FunctionDecl *FD); |
394 | | |
395 | | void RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl, |
396 | | std::string &Result); |
397 | | |
398 | | void RewriteObjCFieldDecl(FieldDecl *fieldDecl, std::string &Result); |
399 | | bool IsTagDefinedInsideClass(ObjCContainerDecl *IDecl, TagDecl *Tag, |
400 | | bool &IsNamedDefinition); |
401 | | void RewriteLocallyDefinedNamedAggregates(FieldDecl *fieldDecl, |
402 | | std::string &Result); |
403 | | |
404 | | bool RewriteObjCFieldDeclType(QualType &Type, std::string &Result); |
405 | | |
406 | | void RewriteIvarOffsetSymbols(ObjCInterfaceDecl *CDecl, |
407 | | std::string &Result); |
408 | | |
409 | | void Initialize(ASTContext &context) override; |
410 | | |
411 | | // Misc. AST transformation routines. Sometimes they end up calling |
412 | | // rewriting routines on the new ASTs. |
413 | | CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD, |
414 | | ArrayRef<Expr *> Args, |
415 | | SourceLocation StartLoc=SourceLocation(), |
416 | | SourceLocation EndLoc=SourceLocation()); |
417 | | |
418 | | Expr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor, |
419 | | QualType returnType, |
420 | | SmallVectorImpl<QualType> &ArgTypes, |
421 | | SmallVectorImpl<Expr*> &MsgExprs, |
422 | | ObjCMethodDecl *Method); |
423 | | |
424 | | Stmt *SynthMessageExpr(ObjCMessageExpr *Exp, |
425 | | SourceLocation StartLoc=SourceLocation(), |
426 | | SourceLocation EndLoc=SourceLocation()); |
427 | | |
428 | | void SynthCountByEnumWithState(std::string &buf); |
429 | | void SynthMsgSendFunctionDecl(); |
430 | | void SynthMsgSendSuperFunctionDecl(); |
431 | | void SynthMsgSendStretFunctionDecl(); |
432 | | void SynthMsgSendFpretFunctionDecl(); |
433 | | void SynthMsgSendSuperStretFunctionDecl(); |
434 | | void SynthGetClassFunctionDecl(); |
435 | | void SynthGetMetaClassFunctionDecl(); |
436 | | void SynthGetSuperClassFunctionDecl(); |
437 | | void SynthSelGetUidFunctionDecl(); |
438 | | void SynthSuperConstructorFunctionDecl(); |
439 | | |
440 | | // Rewriting metadata |
441 | | template<typename MethodIterator> |
442 | | void RewriteObjCMethodsMetaData(MethodIterator MethodBegin, |
443 | | MethodIterator MethodEnd, |
444 | | bool IsInstanceMethod, |
445 | | StringRef prefix, |
446 | | StringRef ClassName, |
447 | | std::string &Result); |
448 | | void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol, |
449 | | std::string &Result); |
450 | | void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, |
451 | | std::string &Result); |
452 | | void RewriteClassSetupInitHook(std::string &Result); |
453 | | |
454 | | void RewriteMetaDataIntoBuffer(std::string &Result); |
455 | | void WriteImageInfo(std::string &Result); |
456 | | void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl, |
457 | | std::string &Result); |
458 | | void RewriteCategorySetupInitHook(std::string &Result); |
459 | | |
460 | | // Rewriting ivar |
461 | | void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar, |
462 | | std::string &Result); |
463 | | Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV); |
464 | | |
465 | | |
466 | | std::string SynthesizeByrefCopyDestroyHelper(VarDecl *VD, int flag); |
467 | | std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, |
468 | | StringRef funcName, std::string Tag); |
469 | | std::string SynthesizeBlockFunc(BlockExpr *CE, int i, |
470 | | StringRef funcName, std::string Tag); |
471 | | std::string SynthesizeBlockImpl(BlockExpr *CE, |
472 | | std::string Tag, std::string Desc); |
473 | | std::string SynthesizeBlockDescriptor(std::string DescTag, |
474 | | std::string ImplTag, |
475 | | int i, StringRef funcName, |
476 | | unsigned hasCopy); |
477 | | Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp); |
478 | | void SynthesizeBlockLiterals(SourceLocation FunLocStart, |
479 | | StringRef FunName); |
480 | | FunctionDecl *SynthBlockInitFunctionDecl(StringRef name); |
481 | | Stmt *SynthBlockInitExpr(BlockExpr *Exp, |
482 | | const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs); |
483 | | |
484 | | // Misc. helper routines. |
485 | | QualType getProtocolType(); |
486 | | void WarnAboutReturnGotoStmts(Stmt *S); |
487 | | void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND); |
488 | | void InsertBlockLiteralsWithinFunction(FunctionDecl *FD); |
489 | | void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD); |
490 | | |
491 | | bool IsDeclStmtInForeachHeader(DeclStmt *DS); |
492 | | void CollectBlockDeclRefInfo(BlockExpr *Exp); |
493 | | void GetBlockDeclRefExprs(Stmt *S); |
494 | | void GetInnerBlockDeclRefExprs(Stmt *S, |
495 | | SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs, |
496 | | llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts); |
497 | | |
498 | | // We avoid calling Type::isBlockPointerType(), since it operates on the |
499 | | // canonical type. We only care if the top-level type is a closure pointer. |
500 | 1.32k | bool isTopLevelBlockPointerType(QualType T) { |
501 | 1.32k | return isa<BlockPointerType>(T); |
502 | 1.32k | } |
503 | | |
504 | | /// convertBlockPointerToFunctionPointer - Converts a block-pointer type |
505 | | /// to a function pointer type and upon success, returns true; false |
506 | | /// otherwise. |
507 | 707 | bool convertBlockPointerToFunctionPointer(QualType &T) { |
508 | 707 | if (isTopLevelBlockPointerType(T)) { |
509 | 22 | const auto *BPT = T->castAs<BlockPointerType>(); |
510 | 22 | T = Context->getPointerType(BPT->getPointeeType()); |
511 | 22 | return true; |
512 | 22 | } |
513 | 685 | return false; |
514 | 707 | } |
515 | | |
516 | | bool convertObjCTypeToCStyleType(QualType &T); |
517 | | |
518 | | bool needToScanForQualifiers(QualType T); |
519 | | QualType getSuperStructType(); |
520 | | QualType getConstantStringStructType(); |
521 | | QualType convertFunctionTypeOfBlocks(const FunctionType *FT); |
522 | | |
523 | 527 | void convertToUnqualifiedObjCType(QualType &T) { |
524 | 527 | if (T->isObjCQualifiedIdType()) { |
525 | 15 | bool isConst = T.isConstQualified(); |
526 | 15 | T = isConst ? Context->getObjCIdType().withConst()2 |
527 | 15 | : Context->getObjCIdType()13 ; |
528 | 15 | } |
529 | 512 | else if (T->isObjCQualifiedClassType()) |
530 | 0 | T = Context->getObjCClassType(); |
531 | 512 | else if (T->isObjCObjectPointerType() && |
532 | 512 | T->getPointeeType()->isObjCQualifiedInterfaceType()134 ) { |
533 | 18 | if (const ObjCObjectPointerType * OBJPT = |
534 | 18 | T->getAsObjCInterfacePointerType()) { |
535 | 18 | const ObjCInterfaceType *IFaceT = OBJPT->getInterfaceType(); |
536 | 18 | T = QualType(IFaceT, 0); |
537 | 18 | T = Context->getPointerType(T); |
538 | 18 | } |
539 | 18 | } |
540 | 527 | } |
541 | | |
542 | | // FIXME: This predicate seems like it would be useful to add to ASTContext. |
543 | 36 | bool isObjCType(QualType T) { |
544 | 36 | if (!LangOpts.ObjC) |
545 | 0 | return false; |
546 | | |
547 | 36 | QualType OCT = Context->getCanonicalType(T).getUnqualifiedType(); |
548 | | |
549 | 36 | if (OCT == Context->getCanonicalType(Context->getObjCIdType()) || |
550 | 36 | OCT == Context->getCanonicalType(Context->getObjCClassType())33 ) |
551 | 3 | return true; |
552 | | |
553 | 33 | if (const PointerType *PT = OCT->getAs<PointerType>()) { |
554 | 2 | if (isa<ObjCInterfaceType>(PT->getPointeeType()) || |
555 | 2 | PT->getPointeeType()->isObjCQualifiedIdType()) |
556 | 0 | return true; |
557 | 2 | } |
558 | 33 | return false; |
559 | 33 | } |
560 | | |
561 | | bool PointerTypeTakesAnyBlockArguments(QualType QT); |
562 | | bool PointerTypeTakesAnyObjCQualifiedType(QualType QT); |
563 | | void GetExtentOfArgList(const char *Name, const char *&LParen, |
564 | | const char *&RParen); |
565 | | |
566 | 180 | void QuoteDoublequotes(std::string &From, std::string &To) { |
567 | 2.42k | for (unsigned i = 0; i < From.length(); i++2.24k ) { |
568 | 2.24k | if (From[i] == '"') |
569 | 260 | To += "\\\""; |
570 | 1.98k | else |
571 | 1.98k | To += From[i]; |
572 | 2.24k | } |
573 | 180 | } |
574 | | |
575 | | QualType getSimpleFunctionType(QualType result, |
576 | | ArrayRef<QualType> args, |
577 | 404 | bool variadic = false) { |
578 | 404 | if (result == Context->getObjCInstanceType()) |
579 | 0 | result = Context->getObjCIdType(); |
580 | 404 | FunctionProtoType::ExtProtoInfo fpi; |
581 | 404 | fpi.Variadic = variadic; |
582 | 404 | return Context->getFunctionType(result, args, fpi); |
583 | 404 | } |
584 | | |
585 | | // Helper function: create a CStyleCastExpr with trivial type source info. |
586 | | CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty, |
587 | 909 | CastKind Kind, Expr *E) { |
588 | 909 | TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation()); |
589 | 909 | return CStyleCastExpr::Create(*Ctx, Ty, VK_PRValue, Kind, E, nullptr, |
590 | 909 | FPOptionsOverride(), TInfo, |
591 | 909 | SourceLocation(), SourceLocation()); |
592 | 909 | } |
593 | | |
594 | 93 | bool ImplementationIsNonLazy(const ObjCImplDecl *OD) const { |
595 | 93 | IdentifierInfo* II = &Context->Idents.get("load"); |
596 | 93 | Selector LoadSel = Context->Selectors.getSelector(0, &II); |
597 | 93 | return OD->getClassMethod(LoadSel) != nullptr; |
598 | 93 | } |
599 | | |
600 | 217 | StringLiteral *getStringLiteral(StringRef Str) { |
601 | 217 | QualType StrType = Context->getConstantArrayType( |
602 | 217 | Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr, |
603 | 217 | ArraySizeModifier::Normal, 0); |
604 | 217 | return StringLiteral::Create(*Context, Str, StringLiteralKind::Ordinary, |
605 | 217 | /*Pascal=*/false, StrType, SourceLocation()); |
606 | 217 | } |
607 | | }; |
608 | | } // end anonymous namespace |
609 | | |
610 | | void RewriteModernObjC::RewriteBlocksInFunctionProtoType(QualType funcType, |
611 | 192 | NamedDecl *D) { |
612 | 192 | if (const FunctionProtoType *fproto |
613 | 192 | = dyn_cast<FunctionProtoType>(funcType.IgnoreParens())) { |
614 | 192 | for (const auto &I : fproto->param_types()) |
615 | 114 | if (isTopLevelBlockPointerType(I)) { |
616 | | // All the args are checked/rewritten. Don't call twice! |
617 | 26 | RewriteBlockPointerDecl(D); |
618 | 26 | break; |
619 | 26 | } |
620 | 192 | } |
621 | 192 | } |
622 | | |
623 | 2 | void RewriteModernObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) { |
624 | 2 | const PointerType *PT = funcType->getAs<PointerType>(); |
625 | 2 | if (PT && PointerTypeTakesAnyBlockArguments(funcType)) |
626 | 0 | RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND); |
627 | 2 | } |
628 | | |
629 | 78 | static bool IsHeaderFile(const std::string &Filename) { |
630 | 78 | std::string::size_type DotPos = Filename.rfind('.'); |
631 | | |
632 | 78 | if (DotPos == std::string::npos) { |
633 | | // no file extension |
634 | 0 | return false; |
635 | 0 | } |
636 | | |
637 | 78 | std::string Ext = Filename.substr(DotPos + 1); |
638 | | // C header: .h |
639 | | // C++ header: .hh or .H; |
640 | 78 | return Ext == "h" || Ext == "hh" || Ext == "H"; |
641 | 78 | } |
642 | | |
643 | | RewriteModernObjC::RewriteModernObjC(std::string inFile, |
644 | | std::unique_ptr<raw_ostream> OS, |
645 | | DiagnosticsEngine &D, |
646 | | const LangOptions &LOpts, |
647 | | bool silenceMacroWarn, bool LineInfo) |
648 | 78 | : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)), |
649 | 78 | SilenceRewriteMacroWarning(silenceMacroWarn), GenerateLineInfo(LineInfo) { |
650 | 78 | IsHeader = IsHeaderFile(inFile); |
651 | 78 | RewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning, |
652 | 78 | "rewriting sub-expression within a macro (may not be correct)"); |
653 | | // FIXME. This should be an error. But if block is not called, it is OK. And it |
654 | | // may break including some headers. |
655 | 78 | GlobalBlockRewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning, |
656 | 78 | "rewriting block literal declared in global scope is not implemented"); |
657 | | |
658 | 78 | TryFinallyContainsReturnDiag = Diags.getCustomDiagID( |
659 | 78 | DiagnosticsEngine::Warning, |
660 | 78 | "rewriter doesn't support user-specified control flow semantics " |
661 | 78 | "for @try/@finally (code may not execute properly)"); |
662 | 78 | } |
663 | | |
664 | | std::unique_ptr<ASTConsumer> clang::CreateModernObjCRewriter( |
665 | | const std::string &InFile, std::unique_ptr<raw_ostream> OS, |
666 | | DiagnosticsEngine &Diags, const LangOptions &LOpts, |
667 | 78 | bool SilenceRewriteMacroWarning, bool LineInfo) { |
668 | 78 | return std::make_unique<RewriteModernObjC>(InFile, std::move(OS), Diags, |
669 | 78 | LOpts, SilenceRewriteMacroWarning, |
670 | 78 | LineInfo); |
671 | 78 | } |
672 | | |
673 | 78 | void RewriteModernObjC::InitializeCommon(ASTContext &context) { |
674 | 78 | Context = &context; |
675 | 78 | SM = &Context->getSourceManager(); |
676 | 78 | TUDecl = Context->getTranslationUnitDecl(); |
677 | 78 | MsgSendFunctionDecl = nullptr; |
678 | 78 | MsgSendSuperFunctionDecl = nullptr; |
679 | 78 | MsgSendStretFunctionDecl = nullptr; |
680 | 78 | MsgSendSuperStretFunctionDecl = nullptr; |
681 | 78 | MsgSendFpretFunctionDecl = nullptr; |
682 | 78 | GetClassFunctionDecl = nullptr; |
683 | 78 | GetMetaClassFunctionDecl = nullptr; |
684 | 78 | GetSuperClassFunctionDecl = nullptr; |
685 | 78 | SelGetUidFunctionDecl = nullptr; |
686 | 78 | CFStringFunctionDecl = nullptr; |
687 | 78 | ConstantStringClassReference = nullptr; |
688 | 78 | NSStringRecord = nullptr; |
689 | 78 | CurMethodDef = nullptr; |
690 | 78 | CurFunctionDef = nullptr; |
691 | 78 | GlobalVarDecl = nullptr; |
692 | 78 | GlobalConstructionExp = nullptr; |
693 | 78 | SuperStructDecl = nullptr; |
694 | 78 | ProtocolTypeDecl = nullptr; |
695 | 78 | ConstantStringDecl = nullptr; |
696 | 78 | BcLabelCount = 0; |
697 | 78 | SuperConstructorFunctionDecl = nullptr; |
698 | 78 | NumObjCStringLiterals = 0; |
699 | 78 | PropParentMap = nullptr; |
700 | 78 | CurrentBody = nullptr; |
701 | 78 | DisableReplaceStmt = false; |
702 | 78 | objc_impl_method = false; |
703 | | |
704 | | // Get the ID and start/end of the main file. |
705 | 78 | MainFileID = SM->getMainFileID(); |
706 | 78 | llvm::MemoryBufferRef MainBuf = SM->getBufferOrFake(MainFileID); |
707 | 78 | MainFileStart = MainBuf.getBufferStart(); |
708 | 78 | MainFileEnd = MainBuf.getBufferEnd(); |
709 | | |
710 | 78 | Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts()); |
711 | 78 | } |
712 | | |
713 | | //===----------------------------------------------------------------------===// |
714 | | // Top Level Driver Code |
715 | | //===----------------------------------------------------------------------===// |
716 | | |
717 | 541 | void RewriteModernObjC::HandleTopLevelSingleDecl(Decl *D) { |
718 | 541 | if (Diags.hasErrorOccurred()) |
719 | 0 | return; |
720 | | |
721 | | // Two cases: either the decl could be in the main file, or it could be in a |
722 | | // #included file. If the former, rewrite it now. If the later, check to see |
723 | | // if we rewrote the #include/#import. |
724 | 541 | SourceLocation Loc = D->getLocation(); |
725 | 541 | Loc = SM->getExpansionLoc(Loc); |
726 | | |
727 | | // If this is for a builtin, ignore it. |
728 | 541 | if (Loc.isInvalid()) return0 ; |
729 | | |
730 | | // Look for built-in declarations that we need to refer during the rewrite. |
731 | 541 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { |
732 | 192 | RewriteFunctionDecl(FD); |
733 | 349 | } else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) { |
734 | | // declared in <Foundation/NSString.h> |
735 | 21 | if (FVD->getName() == "_NSConstantStringClassReference") { |
736 | 0 | ConstantStringClassReference = FVD; |
737 | 0 | return; |
738 | 0 | } |
739 | 328 | } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) { |
740 | 14 | RewriteCategoryDecl(CD); |
741 | 314 | } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) { |
742 | 16 | if (PD->isThisDeclarationADefinition()) |
743 | 16 | RewriteProtocolDecl(PD); |
744 | 298 | } else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) { |
745 | | // Recurse into linkage specifications |
746 | 25 | for (DeclContext::decl_iterator DI = LSD->decls_begin(), |
747 | 25 | DIEnd = LSD->decls_end(); |
748 | 67 | DI != DIEnd; ) { |
749 | 42 | if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>((*DI))) { |
750 | 11 | if (!IFace->isThisDeclarationADefinition()) { |
751 | 5 | SmallVector<Decl *, 8> DG; |
752 | 5 | SourceLocation StartLoc = IFace->getBeginLoc(); |
753 | 21 | do { |
754 | 21 | if (isa<ObjCInterfaceDecl>(*DI) && |
755 | 21 | !cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition()20 && |
756 | 21 | StartLoc == (*DI)->getBeginLoc()19 ) |
757 | 16 | DG.push_back(*DI); |
758 | 5 | else |
759 | 5 | break; |
760 | | |
761 | 16 | ++DI; |
762 | 16 | } while (DI != DIEnd); |
763 | 0 | RewriteForwardClassDecl(DG); |
764 | 5 | continue; |
765 | 5 | } |
766 | 6 | else { |
767 | | // Keep track of all interface declarations seen. |
768 | 6 | ObjCInterfacesSeen.push_back(IFace); |
769 | 6 | ++DI; |
770 | 6 | continue; |
771 | 6 | } |
772 | 11 | } |
773 | | |
774 | 31 | if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>((*DI))) { |
775 | 0 | if (!Proto->isThisDeclarationADefinition()) { |
776 | 0 | SmallVector<Decl *, 8> DG; |
777 | 0 | SourceLocation StartLoc = Proto->getBeginLoc(); |
778 | 0 | do { |
779 | 0 | if (isa<ObjCProtocolDecl>(*DI) && |
780 | 0 | !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() && |
781 | 0 | StartLoc == (*DI)->getBeginLoc()) |
782 | 0 | DG.push_back(*DI); |
783 | 0 | else |
784 | 0 | break; |
785 | | |
786 | 0 | ++DI; |
787 | 0 | } while (DI != DIEnd); |
788 | 0 | RewriteForwardProtocolDecl(DG); |
789 | 0 | continue; |
790 | 0 | } |
791 | 0 | } |
792 | | |
793 | 31 | HandleTopLevelSingleDecl(*DI); |
794 | 31 | ++DI; |
795 | 31 | } |
796 | 25 | } |
797 | | // If we have a decl in the main file, see if we should rewrite it. |
798 | 541 | if (SM->isWrittenInMainFile(Loc)) |
799 | 541 | return HandleDeclInMainFile(D); |
800 | 541 | } |
801 | | |
802 | | //===----------------------------------------------------------------------===// |
803 | | // Syntactic (non-AST) Rewriting Code |
804 | | //===----------------------------------------------------------------------===// |
805 | | |
806 | 78 | void RewriteModernObjC::RewriteInclude() { |
807 | 78 | SourceLocation LocStart = SM->getLocForStartOfFile(MainFileID); |
808 | 78 | StringRef MainBuf = SM->getBufferData(MainFileID); |
809 | 78 | const char *MainBufStart = MainBuf.begin(); |
810 | 78 | const char *MainBufEnd = MainBuf.end(); |
811 | 78 | size_t ImportLen = strlen("import"); |
812 | | |
813 | | // Loop over the whole file, looking for includes. |
814 | 79.2k | for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr79.1k ) { |
815 | 79.1k | if (*BufPtr == '#') { |
816 | 182 | if (++BufPtr == MainBufEnd) |
817 | 0 | return; |
818 | 354 | while (182 *BufPtr == ' ' || *BufPtr == '\t'182 ) |
819 | 172 | if (++BufPtr == MainBufEnd) |
820 | 0 | return; |
821 | 182 | if (!strncmp(BufPtr, "import", ImportLen)) { |
822 | | // replace import with include |
823 | 0 | SourceLocation ImportLoc = |
824 | 0 | LocStart.getLocWithOffset(BufPtr-MainBufStart); |
825 | 0 | ReplaceText(ImportLoc, ImportLen, "include"); |
826 | 0 | BufPtr += ImportLen; |
827 | 0 | } |
828 | 182 | } |
829 | 79.1k | } |
830 | 78 | } |
831 | | |
832 | | static void WriteInternalIvarName(const ObjCInterfaceDecl *IDecl, |
833 | 438 | ObjCIvarDecl *IvarDecl, std::string &Result) { |
834 | 438 | Result += "OBJC_IVAR_$_"; |
835 | 438 | Result += IDecl->getName(); |
836 | 438 | Result += "$"; |
837 | 438 | Result += IvarDecl->getName(); |
838 | 438 | } |
839 | | |
840 | | std::string |
841 | 30 | RewriteModernObjC::getIvarAccessString(ObjCIvarDecl *D) { |
842 | 30 | const ObjCInterfaceDecl *ClassDecl = D->getContainingInterface(); |
843 | | |
844 | | // Build name of symbol holding ivar offset. |
845 | 30 | std::string IvarOffsetName; |
846 | 30 | if (D->isBitField()) |
847 | 4 | ObjCIvarBitfieldGroupOffset(D, IvarOffsetName); |
848 | 26 | else |
849 | 26 | WriteInternalIvarName(ClassDecl, D, IvarOffsetName); |
850 | | |
851 | 30 | std::string S = "(*("; |
852 | 30 | QualType IvarT = D->getType(); |
853 | 30 | if (D->isBitField()) |
854 | 4 | IvarT = GetGroupRecordTypeForObjCIvarBitfield(D); |
855 | | |
856 | 30 | if (!IvarT->getAs<TypedefType>() && IvarT->isRecordType()19 ) { |
857 | 4 | RecordDecl *RD = IvarT->castAs<RecordType>()->getDecl(); |
858 | 4 | RD = RD->getDefinition(); |
859 | 4 | if (RD && !RD->getDeclName().getAsIdentifierInfo()) { |
860 | | // decltype(((Foo_IMPL*)0)->bar) * |
861 | 0 | auto *CDecl = cast<ObjCContainerDecl>(D->getDeclContext()); |
862 | | // ivar in class extensions requires special treatment. |
863 | 0 | if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) |
864 | 0 | CDecl = CatDecl->getClassInterface(); |
865 | 0 | std::string RecName = std::string(CDecl->getName()); |
866 | 0 | RecName += "_IMPL"; |
867 | 0 | RecordDecl *RD = RecordDecl::Create(*Context, TagTypeKind::Struct, TUDecl, |
868 | 0 | SourceLocation(), SourceLocation(), |
869 | 0 | &Context->Idents.get(RecName)); |
870 | 0 | QualType PtrStructIMPL = Context->getPointerType(Context->getTagDeclType(RD)); |
871 | 0 | unsigned UnsignedIntSize = |
872 | 0 | static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy)); |
873 | 0 | Expr *Zero = IntegerLiteral::Create(*Context, |
874 | 0 | llvm::APInt(UnsignedIntSize, 0), |
875 | 0 | Context->UnsignedIntTy, SourceLocation()); |
876 | 0 | Zero = NoTypeInfoCStyleCastExpr(Context, PtrStructIMPL, CK_BitCast, Zero); |
877 | 0 | ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), |
878 | 0 | Zero); |
879 | 0 | FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
880 | 0 | SourceLocation(), |
881 | 0 | &Context->Idents.get(D->getNameAsString()), |
882 | 0 | IvarT, nullptr, |
883 | 0 | /*BitWidth=*/nullptr, /*Mutable=*/true, |
884 | 0 | ICIS_NoInit); |
885 | 0 | MemberExpr *ME = MemberExpr::CreateImplicit( |
886 | 0 | *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary); |
887 | 0 | IvarT = Context->getDecltypeType(ME, ME->getType()); |
888 | 0 | } |
889 | 4 | } |
890 | 30 | convertObjCTypeToCStyleType(IvarT); |
891 | 30 | QualType castT = Context->getPointerType(IvarT); |
892 | 30 | std::string TypeString(castT.getAsString(Context->getPrintingPolicy())); |
893 | 30 | S += TypeString; |
894 | 30 | S += ")"; |
895 | | |
896 | | // ((char *)self + IVAR_OFFSET_SYMBOL_NAME) |
897 | 30 | S += "((char *)self + "; |
898 | 30 | S += IvarOffsetName; |
899 | 30 | S += "))"; |
900 | 30 | if (D->isBitField()) { |
901 | 4 | S += "."; |
902 | 4 | S += D->getNameAsString(); |
903 | 4 | } |
904 | 30 | ReferencedIvars[const_cast<ObjCInterfaceDecl *>(ClassDecl)].insert(D); |
905 | 30 | return S; |
906 | 30 | } |
907 | | |
908 | | /// mustSynthesizeSetterGetterMethod - returns true if setter or getter has not |
909 | | /// been found in the class implementation. In this case, it must be synthesized. |
910 | | static bool mustSynthesizeSetterGetterMethod(ObjCImplementationDecl *IMP, |
911 | | ObjCPropertyDecl *PD, |
912 | 104 | bool getter) { |
913 | 104 | auto *OMD = IMP->getInstanceMethod(getter ? PD->getGetterName()56 |
914 | 104 | : PD->getSetterName()48 ); |
915 | 104 | return !OMD || OMD->isSynthesizedAccessorStub(); |
916 | 104 | } |
917 | | |
918 | | void RewriteModernObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID, |
919 | | ObjCImplementationDecl *IMD, |
920 | 31 | ObjCCategoryImplDecl *CID) { |
921 | 31 | static bool objcGetPropertyDefined = false; |
922 | 31 | static bool objcSetPropertyDefined = false; |
923 | 31 | SourceLocation startGetterSetterLoc; |
924 | | |
925 | 31 | if (PID->getBeginLoc().isValid()) { |
926 | 23 | SourceLocation startLoc = PID->getBeginLoc(); |
927 | 23 | InsertText(startLoc, "// "); |
928 | 23 | const char *startBuf = SM->getCharacterData(startLoc); |
929 | 23 | assert((*startBuf == '@') && "bogus @synthesize location"); |
930 | 23 | const char *semiBuf = strchr(startBuf, ';'); |
931 | 23 | assert((*semiBuf == ';') && "@synthesize: can't find ';'"); |
932 | 23 | startGetterSetterLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1); |
933 | 23 | } else |
934 | 8 | startGetterSetterLoc = IMD ? IMD->getEndLoc() : CID->getEndLoc()0 ; |
935 | | |
936 | 31 | if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) |
937 | 3 | return; // FIXME: is this correct? |
938 | | |
939 | | // Generate the 'getter' function. |
940 | 28 | ObjCPropertyDecl *PD = PID->getPropertyDecl(); |
941 | 28 | ObjCIvarDecl *OID = PID->getPropertyIvarDecl(); |
942 | 28 | assert(IMD && OID && "Synthesized ivars must be attached to @implementation"); |
943 | | |
944 | 28 | unsigned Attributes = PD->getPropertyAttributes(); |
945 | 28 | if (mustSynthesizeSetterGetterMethod(IMD, PD, true /*getter*/)) { |
946 | 26 | bool GenGetProperty = |
947 | 26 | !(Attributes & ObjCPropertyAttribute::kind_nonatomic) && |
948 | 26 | (Attributes & (ObjCPropertyAttribute::kind_retain | |
949 | 22 | ObjCPropertyAttribute::kind_copy)); |
950 | 26 | std::string Getr; |
951 | 26 | if (GenGetProperty && !objcGetPropertyDefined9 ) { |
952 | 5 | objcGetPropertyDefined = true; |
953 | | // FIXME. Is this attribute correct in all cases? |
954 | 5 | Getr = "\nextern \"C\" __declspec(dllimport) " |
955 | 5 | "id objc_getProperty(id, SEL, long, bool);\n"; |
956 | 5 | } |
957 | 26 | RewriteObjCMethodDecl(OID->getContainingInterface(), |
958 | 26 | PID->getGetterMethodDecl(), Getr); |
959 | 26 | Getr += "{ "; |
960 | | // Synthesize an explicit cast to gain access to the ivar. |
961 | | // See objc-act.c:objc_synthesize_new_getter() for details. |
962 | 26 | if (GenGetProperty) { |
963 | | // return objc_getProperty(self, _cmd, offsetof(ClassDecl, OID), 1) |
964 | 9 | Getr += "typedef "; |
965 | 9 | const FunctionType *FPRetType = nullptr; |
966 | 9 | RewriteTypeIntoString(PID->getGetterMethodDecl()->getReturnType(), Getr, |
967 | 9 | FPRetType); |
968 | 9 | Getr += " _TYPE"; |
969 | 9 | if (FPRetType) { |
970 | 1 | Getr += ")"; // close the precedence "scope" for "*". |
971 | | |
972 | | // Now, emit the argument types (if any). |
973 | 1 | if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)){ |
974 | 1 | Getr += "("; |
975 | 1 | for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i0 ) { |
976 | 0 | if (i) Getr += ", "; |
977 | 0 | std::string ParamStr = |
978 | 0 | FT->getParamType(i).getAsString(Context->getPrintingPolicy()); |
979 | 0 | Getr += ParamStr; |
980 | 0 | } |
981 | 1 | if (FT->isVariadic()) { |
982 | 0 | if (FT->getNumParams()) |
983 | 0 | Getr += ", "; |
984 | 0 | Getr += "..."; |
985 | 0 | } |
986 | 1 | Getr += ")"; |
987 | 1 | } else |
988 | 0 | Getr += "()"; |
989 | 1 | } |
990 | 9 | Getr += ";\n"; |
991 | 9 | Getr += "return (_TYPE)"; |
992 | 9 | Getr += "objc_getProperty(self, _cmd, "; |
993 | 9 | RewriteIvarOffsetComputation(OID, Getr); |
994 | 9 | Getr += ", 1)"; |
995 | 9 | } |
996 | 17 | else |
997 | 17 | Getr += "return " + getIvarAccessString(OID); |
998 | 26 | Getr += "; }"; |
999 | 26 | InsertText(startGetterSetterLoc, Getr); |
1000 | 26 | } |
1001 | | |
1002 | 28 | if (PD->isReadOnly() || |
1003 | 28 | !mustSynthesizeSetterGetterMethod(IMD, PD, false /*setter*/)24 ) |
1004 | 6 | return; |
1005 | | |
1006 | | // Generate the 'setter' function. |
1007 | 22 | std::string Setr; |
1008 | 22 | bool GenSetProperty = Attributes & (ObjCPropertyAttribute::kind_retain | |
1009 | 22 | ObjCPropertyAttribute::kind_copy); |
1010 | 22 | if (GenSetProperty && !objcSetPropertyDefined9 ) { |
1011 | 6 | objcSetPropertyDefined = true; |
1012 | | // FIXME. Is this attribute correct in all cases? |
1013 | 6 | Setr = "\nextern \"C\" __declspec(dllimport) " |
1014 | 6 | "void objc_setProperty (id, SEL, long, id, bool, bool);\n"; |
1015 | 6 | } |
1016 | | |
1017 | 22 | RewriteObjCMethodDecl(OID->getContainingInterface(), |
1018 | 22 | PID->getSetterMethodDecl(), Setr); |
1019 | 22 | Setr += "{ "; |
1020 | | // Synthesize an explicit cast to initialize the ivar. |
1021 | | // See objc-act.c:objc_synthesize_new_setter() for details. |
1022 | 22 | if (GenSetProperty) { |
1023 | 9 | Setr += "objc_setProperty (self, _cmd, "; |
1024 | 9 | RewriteIvarOffsetComputation(OID, Setr); |
1025 | 9 | Setr += ", (id)"; |
1026 | 9 | Setr += PD->getName(); |
1027 | 9 | Setr += ", "; |
1028 | 9 | if (Attributes & ObjCPropertyAttribute::kind_nonatomic) |
1029 | 2 | Setr += "0, "; |
1030 | 7 | else |
1031 | 7 | Setr += "1, "; |
1032 | 9 | if (Attributes & ObjCPropertyAttribute::kind_copy) |
1033 | 4 | Setr += "1)"; |
1034 | 5 | else |
1035 | 5 | Setr += "0)"; |
1036 | 9 | } |
1037 | 13 | else { |
1038 | 13 | Setr += getIvarAccessString(OID) + " = "; |
1039 | 13 | Setr += PD->getName(); |
1040 | 13 | } |
1041 | 22 | Setr += "; }\n"; |
1042 | 22 | InsertText(startGetterSetterLoc, Setr); |
1043 | 22 | } |
1044 | | |
1045 | | static void RewriteOneForwardClassDecl(ObjCInterfaceDecl *ForwardDecl, |
1046 | 181 | std::string &typedefString) { |
1047 | 181 | typedefString += "\n#ifndef _REWRITER_typedef_"; |
1048 | 181 | typedefString += ForwardDecl->getNameAsString(); |
1049 | 181 | typedefString += "\n"; |
1050 | 181 | typedefString += "#define _REWRITER_typedef_"; |
1051 | 181 | typedefString += ForwardDecl->getNameAsString(); |
1052 | 181 | typedefString += "\n"; |
1053 | 181 | typedefString += "typedef struct objc_object "; |
1054 | 181 | typedefString += ForwardDecl->getNameAsString(); |
1055 | | // typedef struct { } _objc_exc_Classname; |
1056 | 181 | typedefString += ";\ntypedef struct {} _objc_exc_"; |
1057 | 181 | typedefString += ForwardDecl->getNameAsString(); |
1058 | 181 | typedefString += ";\n#endif\n"; |
1059 | 181 | } |
1060 | | |
1061 | | void RewriteModernObjC::RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl, |
1062 | 16 | const std::string &typedefString) { |
1063 | 16 | SourceLocation startLoc = ClassDecl->getBeginLoc(); |
1064 | 16 | const char *startBuf = SM->getCharacterData(startLoc); |
1065 | 16 | const char *semiPtr = strchr(startBuf, ';'); |
1066 | | // Replace the @class with typedefs corresponding to the classes. |
1067 | 16 | ReplaceText(startLoc, semiPtr-startBuf+1, typedefString); |
1068 | 16 | } |
1069 | | |
1070 | 11 | void RewriteModernObjC::RewriteForwardClassDecl(DeclGroupRef D) { |
1071 | 11 | std::string typedefString; |
1072 | 26 | for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I15 ) { |
1073 | 15 | if (ObjCInterfaceDecl *ForwardDecl = dyn_cast<ObjCInterfaceDecl>(*I)) { |
1074 | 13 | if (I == D.begin()) { |
1075 | | // Translate to typedef's that forward reference structs with the same name |
1076 | | // as the class. As a convenience, we include the original declaration |
1077 | | // as a comment. |
1078 | 11 | typedefString += "// @class "; |
1079 | 11 | typedefString += ForwardDecl->getNameAsString(); |
1080 | 11 | typedefString += ";"; |
1081 | 11 | } |
1082 | 13 | RewriteOneForwardClassDecl(ForwardDecl, typedefString); |
1083 | 13 | } |
1084 | 2 | else |
1085 | 2 | HandleTopLevelSingleDecl(*I); |
1086 | 15 | } |
1087 | 11 | DeclGroupRef::iterator I = D.begin(); |
1088 | 11 | RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(*I), typedefString); |
1089 | 11 | } |
1090 | | |
1091 | | void RewriteModernObjC::RewriteForwardClassDecl( |
1092 | 5 | const SmallVectorImpl<Decl *> &D) { |
1093 | 5 | std::string typedefString; |
1094 | 21 | for (unsigned i = 0; i < D.size(); i++16 ) { |
1095 | 16 | ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]); |
1096 | 16 | if (i == 0) { |
1097 | 5 | typedefString += "// @class "; |
1098 | 5 | typedefString += ForwardDecl->getNameAsString(); |
1099 | 5 | typedefString += ";"; |
1100 | 5 | } |
1101 | 16 | RewriteOneForwardClassDecl(ForwardDecl, typedefString); |
1102 | 16 | } |
1103 | 5 | RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString); |
1104 | 5 | } |
1105 | | |
1106 | 210 | void RewriteModernObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) { |
1107 | | // When method is a synthesized one, such as a getter/setter there is |
1108 | | // nothing to rewrite. |
1109 | 210 | if (Method->isImplicit()) |
1110 | 68 | return; |
1111 | 142 | SourceLocation LocStart = Method->getBeginLoc(); |
1112 | 142 | SourceLocation LocEnd = Method->getEndLoc(); |
1113 | | |
1114 | 142 | if (SM->getExpansionLineNumber(LocEnd) > |
1115 | 142 | SM->getExpansionLineNumber(LocStart)) { |
1116 | 0 | InsertText(LocStart, "#if 0\n"); |
1117 | 0 | ReplaceText(LocEnd, 1, ";\n#endif\n"); |
1118 | 142 | } else { |
1119 | 142 | InsertText(LocStart, "// "); |
1120 | 142 | } |
1121 | 142 | } |
1122 | | |
1123 | 37 | void RewriteModernObjC::RewriteProperty(ObjCPropertyDecl *prop) { |
1124 | 37 | SourceLocation Loc = prop->getAtLoc(); |
1125 | | |
1126 | 37 | ReplaceText(Loc, 0, "// "); |
1127 | | // FIXME: handle properties that are declared across multiple lines. |
1128 | 37 | } |
1129 | | |
1130 | 14 | void RewriteModernObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) { |
1131 | 14 | SourceLocation LocStart = CatDecl->getBeginLoc(); |
1132 | | |
1133 | | // FIXME: handle category headers that are declared across multiple lines. |
1134 | 14 | if (CatDecl->getIvarRBraceLoc().isValid()) { |
1135 | 8 | ReplaceText(LocStart, 1, "/** "); |
1136 | 8 | ReplaceText(CatDecl->getIvarRBraceLoc(), 1, "**/ "); |
1137 | 8 | } |
1138 | 6 | else { |
1139 | 6 | ReplaceText(LocStart, 0, "// "); |
1140 | 6 | } |
1141 | | |
1142 | 14 | for (auto *I : CatDecl->instance_properties()) |
1143 | 4 | RewriteProperty(I); |
1144 | | |
1145 | 14 | for (auto *I : CatDecl->instance_methods()) |
1146 | 8 | RewriteMethodDeclaration(I); |
1147 | 14 | for (auto *I : CatDecl->class_methods()) |
1148 | 0 | RewriteMethodDeclaration(I); |
1149 | | |
1150 | | // Lastly, comment out the @end. |
1151 | 14 | ReplaceText(CatDecl->getAtEndRange().getBegin(), |
1152 | 14 | strlen("@end"), "/* @end */\n"); |
1153 | 14 | } |
1154 | | |
1155 | 16 | void RewriteModernObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) { |
1156 | 16 | SourceLocation LocStart = PDecl->getBeginLoc(); |
1157 | 16 | assert(PDecl->isThisDeclarationADefinition()); |
1158 | | |
1159 | | // FIXME: handle protocol headers that are declared across multiple lines. |
1160 | 16 | ReplaceText(LocStart, 0, "// "); |
1161 | | |
1162 | 16 | for (auto *I : PDecl->instance_methods()) |
1163 | 11 | RewriteMethodDeclaration(I); |
1164 | 16 | for (auto *I : PDecl->class_methods()) |
1165 | 3 | RewriteMethodDeclaration(I); |
1166 | 16 | for (auto *I : PDecl->instance_properties()) |
1167 | 2 | RewriteProperty(I); |
1168 | | |
1169 | | // Lastly, comment out the @end. |
1170 | 16 | SourceLocation LocEnd = PDecl->getAtEndRange().getBegin(); |
1171 | 16 | ReplaceText(LocEnd, strlen("@end"), "/* @end */\n"); |
1172 | | |
1173 | | // Must comment out @optional/@required |
1174 | 16 | const char *startBuf = SM->getCharacterData(LocStart); |
1175 | 16 | const char *endBuf = SM->getCharacterData(LocEnd); |
1176 | 933 | for (const char *p = startBuf; p < endBuf; p++917 ) { |
1177 | 917 | if (*p == '@' && !strncmp(p+1, "optional", strlen("optional"))23 ) { |
1178 | 4 | SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf); |
1179 | 4 | ReplaceText(OptionalLoc, strlen("@optional"), "/* @optional */"); |
1180 | | |
1181 | 4 | } |
1182 | 913 | else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))19 ) { |
1183 | 1 | SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf); |
1184 | 1 | ReplaceText(OptionalLoc, strlen("@required"), "/* @required */"); |
1185 | | |
1186 | 1 | } |
1187 | 917 | } |
1188 | 16 | } |
1189 | | |
1190 | 2 | void RewriteModernObjC::RewriteForwardProtocolDecl(DeclGroupRef D) { |
1191 | 2 | SourceLocation LocStart = (*D.begin())->getBeginLoc(); |
1192 | 2 | if (LocStart.isInvalid()) |
1193 | 0 | llvm_unreachable("Invalid SourceLocation"); |
1194 | | // FIXME: handle forward protocol that are declared across multiple lines. |
1195 | 2 | ReplaceText(LocStart, 0, "// "); |
1196 | 2 | } |
1197 | | |
1198 | | void |
1199 | 0 | RewriteModernObjC::RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG) { |
1200 | 0 | SourceLocation LocStart = DG[0]->getBeginLoc(); |
1201 | 0 | if (LocStart.isInvalid()) |
1202 | 0 | llvm_unreachable("Invalid SourceLocation"); |
1203 | | // FIXME: handle forward protocol that are declared across multiple lines. |
1204 | 0 | ReplaceText(LocStart, 0, "// "); |
1205 | 0 | } |
1206 | | |
1207 | | void RewriteModernObjC::RewriteTypeIntoString(QualType T, std::string &ResultStr, |
1208 | 122 | const FunctionType *&FPRetType) { |
1209 | 122 | if (T->isObjCQualifiedIdType()) |
1210 | 0 | ResultStr += "id"; |
1211 | 122 | else if (T->isFunctionPointerType() || |
1212 | 122 | T->isBlockPointerType()) { |
1213 | | // needs special handling, since pointer-to-functions have special |
1214 | | // syntax (where a decaration models use). |
1215 | 4 | QualType retType = T; |
1216 | 4 | QualType PointeeTy; |
1217 | 4 | if (const PointerType* PT = retType->getAs<PointerType>()) |
1218 | 0 | PointeeTy = PT->getPointeeType(); |
1219 | 4 | else if (const BlockPointerType *BPT = retType->getAs<BlockPointerType>()) |
1220 | 4 | PointeeTy = BPT->getPointeeType(); |
1221 | 4 | if ((FPRetType = PointeeTy->getAs<FunctionType>())) { |
1222 | 4 | ResultStr += |
1223 | 4 | FPRetType->getReturnType().getAsString(Context->getPrintingPolicy()); |
1224 | 4 | ResultStr += "(*"; |
1225 | 4 | } |
1226 | 4 | } else |
1227 | 118 | ResultStr += T.getAsString(Context->getPrintingPolicy()); |
1228 | 122 | } |
1229 | | |
1230 | | void RewriteModernObjC::RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl, |
1231 | | ObjCMethodDecl *OMD, |
1232 | 113 | std::string &ResultStr) { |
1233 | | //fprintf(stderr,"In RewriteObjCMethodDecl\n"); |
1234 | 113 | const FunctionType *FPRetType = nullptr; |
1235 | 113 | ResultStr += "\nstatic "; |
1236 | 113 | RewriteTypeIntoString(OMD->getReturnType(), ResultStr, FPRetType); |
1237 | 113 | ResultStr += " "; |
1238 | | |
1239 | | // Unique method name |
1240 | 113 | std::string NameStr; |
1241 | | |
1242 | 113 | if (OMD->isInstanceMethod()) |
1243 | 104 | NameStr += "_I_"; |
1244 | 9 | else |
1245 | 9 | NameStr += "_C_"; |
1246 | | |
1247 | 113 | NameStr += IDecl->getNameAsString(); |
1248 | 113 | NameStr += "_"; |
1249 | | |
1250 | 113 | if (ObjCCategoryImplDecl *CID = |
1251 | 113 | dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) { |
1252 | 0 | NameStr += CID->getNameAsString(); |
1253 | 0 | NameStr += "_"; |
1254 | 0 | } |
1255 | | // Append selector names, replacing ':' with '_' |
1256 | 113 | { |
1257 | 113 | std::string selString = OMD->getSelector().getAsString(); |
1258 | 113 | int len = selString.size(); |
1259 | 1.00k | for (int i = 0; i < len; i++894 ) |
1260 | 894 | if (selString[i] == ':') |
1261 | 48 | selString[i] = '_'; |
1262 | 113 | NameStr += selString; |
1263 | 113 | } |
1264 | | // Remember this name for metadata emission |
1265 | 113 | MethodInternalNames[OMD] = NameStr; |
1266 | 113 | ResultStr += NameStr; |
1267 | | |
1268 | | // Rewrite arguments |
1269 | 113 | ResultStr += "("; |
1270 | | |
1271 | | // invisible arguments |
1272 | 113 | if (OMD->isInstanceMethod()) { |
1273 | 104 | QualType selfTy = Context->getObjCInterfaceType(IDecl); |
1274 | 104 | selfTy = Context->getPointerType(selfTy); |
1275 | 104 | if (!LangOpts.MicrosoftExt) { |
1276 | 0 | if (ObjCSynthesizedStructs.count(const_cast<ObjCInterfaceDecl*>(IDecl))) |
1277 | 0 | ResultStr += "struct "; |
1278 | 0 | } |
1279 | | // When rewriting for Microsoft, explicitly omit the structure name. |
1280 | 104 | ResultStr += IDecl->getNameAsString(); |
1281 | 104 | ResultStr += " *"; |
1282 | 104 | } |
1283 | 9 | else |
1284 | 9 | ResultStr += Context->getObjCClassType().getAsString( |
1285 | 9 | Context->getPrintingPolicy()); |
1286 | | |
1287 | 113 | ResultStr += " self, "; |
1288 | 113 | ResultStr += Context->getObjCSelType().getAsString(Context->getPrintingPolicy()); |
1289 | 113 | ResultStr += " _cmd"; |
1290 | | |
1291 | | // Method arguments. |
1292 | 113 | for (const auto *PDecl : OMD->parameters()) { |
1293 | 48 | ResultStr += ", "; |
1294 | 48 | if (PDecl->getType()->isObjCQualifiedIdType()) { |
1295 | 0 | ResultStr += "id "; |
1296 | 0 | ResultStr += PDecl->getNameAsString(); |
1297 | 48 | } else { |
1298 | 48 | std::string Name = PDecl->getNameAsString(); |
1299 | 48 | QualType QT = PDecl->getType(); |
1300 | | // Make sure we convert "t (^)(...)" to "t (*)(...)". |
1301 | 48 | (void)convertBlockPointerToFunctionPointer(QT); |
1302 | 48 | QT.getAsStringInternal(Name, Context->getPrintingPolicy()); |
1303 | 48 | ResultStr += Name; |
1304 | 48 | } |
1305 | 48 | } |
1306 | 113 | if (OMD->isVariadic()) |
1307 | 0 | ResultStr += ", ..."; |
1308 | 113 | ResultStr += ") "; |
1309 | | |
1310 | 113 | if (FPRetType) { |
1311 | 3 | ResultStr += ")"; // close the precedence "scope" for "*". |
1312 | | |
1313 | | // Now, emit the argument types (if any). |
1314 | 3 | if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)) { |
1315 | 3 | ResultStr += "("; |
1316 | 3 | for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i0 ) { |
1317 | 0 | if (i) ResultStr += ", "; |
1318 | 0 | std::string ParamStr = |
1319 | 0 | FT->getParamType(i).getAsString(Context->getPrintingPolicy()); |
1320 | 0 | ResultStr += ParamStr; |
1321 | 0 | } |
1322 | 3 | if (FT->isVariadic()) { |
1323 | 0 | if (FT->getNumParams()) |
1324 | 0 | ResultStr += ", "; |
1325 | 0 | ResultStr += "..."; |
1326 | 0 | } |
1327 | 3 | ResultStr += ")"; |
1328 | 3 | } else { |
1329 | 0 | ResultStr += "()"; |
1330 | 0 | } |
1331 | 3 | } |
1332 | 113 | } |
1333 | | |
1334 | 93 | void RewriteModernObjC::RewriteImplementationDecl(Decl *OID) { |
1335 | 93 | ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID); |
1336 | 93 | ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID); |
1337 | 93 | assert((IMD || CID) && "Unknown implementation type"); |
1338 | | |
1339 | 93 | if (IMD) { |
1340 | 88 | if (IMD->getIvarRBraceLoc().isValid()) { |
1341 | 3 | ReplaceText(IMD->getBeginLoc(), 1, "/** "); |
1342 | 3 | ReplaceText(IMD->getIvarRBraceLoc(), 1, "**/ "); |
1343 | 3 | } |
1344 | 85 | else { |
1345 | 85 | InsertText(IMD->getBeginLoc(), "// "); |
1346 | 85 | } |
1347 | 88 | } |
1348 | 5 | else |
1349 | 5 | InsertText(CID->getBeginLoc(), "// "); |
1350 | | |
1351 | 104 | for (auto *OMD : IMD93 ? IMD->instance_methods()88 : CID->instance_methods()5 ) { |
1352 | 104 | if (!OMD->getBody()) |
1353 | 48 | continue; |
1354 | 56 | std::string ResultStr; |
1355 | 56 | RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr); |
1356 | 56 | SourceLocation LocStart = OMD->getBeginLoc(); |
1357 | 56 | SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc(); |
1358 | | |
1359 | 56 | const char *startBuf = SM->getCharacterData(LocStart); |
1360 | 56 | const char *endBuf = SM->getCharacterData(LocEnd); |
1361 | 56 | ReplaceText(LocStart, endBuf-startBuf, ResultStr); |
1362 | 56 | } |
1363 | | |
1364 | 93 | for (auto *OMD : IMD ? IMD->class_methods()88 : CID->class_methods()5 ) { |
1365 | 9 | if (!OMD->getBody()) |
1366 | 0 | continue; |
1367 | 9 | std::string ResultStr; |
1368 | 9 | RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr); |
1369 | 9 | SourceLocation LocStart = OMD->getBeginLoc(); |
1370 | 9 | SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc(); |
1371 | | |
1372 | 9 | const char *startBuf = SM->getCharacterData(LocStart); |
1373 | 9 | const char *endBuf = SM->getCharacterData(LocEnd); |
1374 | 9 | ReplaceText(LocStart, endBuf-startBuf, ResultStr); |
1375 | 9 | } |
1376 | 93 | for (auto *I : IMD ? IMD->property_impls()88 : CID->property_impls()5 ) |
1377 | 31 | RewritePropertyImplDecl(I, IMD, CID); |
1378 | | |
1379 | 93 | InsertText(IMD ? IMD->getEndLoc()88 : CID->getEndLoc()5 , "// "); |
1380 | 93 | } |
1381 | | |
1382 | 183 | void RewriteModernObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) { |
1383 | | // Do not synthesize more than once. |
1384 | 183 | if (ObjCSynthesizedStructs.count(ClassDecl)) |
1385 | 9 | return; |
1386 | | // Make sure super class's are written before current class is written. |
1387 | 174 | ObjCInterfaceDecl *SuperClass = ClassDecl->getSuperClass(); |
1388 | 205 | while (SuperClass) { |
1389 | 31 | RewriteInterfaceDecl(SuperClass); |
1390 | 31 | SuperClass = SuperClass->getSuperClass(); |
1391 | 31 | } |
1392 | 174 | std::string ResultStr; |
1393 | 174 | if (!ObjCWrittenInterfaces.count(ClassDecl->getCanonicalDecl())) { |
1394 | | // we haven't seen a forward decl - generate a typedef. |
1395 | 152 | RewriteOneForwardClassDecl(ClassDecl, ResultStr); |
1396 | 152 | RewriteIvarOffsetSymbols(ClassDecl, ResultStr); |
1397 | | |
1398 | 152 | RewriteObjCInternalStruct(ClassDecl, ResultStr); |
1399 | | // Mark this typedef as having been written into its c++ equivalent. |
1400 | 152 | ObjCWrittenInterfaces.insert(ClassDecl->getCanonicalDecl()); |
1401 | | |
1402 | 152 | for (auto *I : ClassDecl->instance_properties()) |
1403 | 31 | RewriteProperty(I); |
1404 | 152 | for (auto *I : ClassDecl->instance_methods()) |
1405 | 108 | RewriteMethodDeclaration(I); |
1406 | 152 | for (auto *I : ClassDecl->class_methods()) |
1407 | 80 | RewriteMethodDeclaration(I); |
1408 | | |
1409 | | // Lastly, comment out the @end. |
1410 | 152 | ReplaceText(ClassDecl->getAtEndRange().getBegin(), strlen("@end"), |
1411 | 152 | "/* @end */\n"); |
1412 | 152 | } |
1413 | 174 | } |
1414 | | |
1415 | 13 | Stmt *RewriteModernObjC::RewritePropertyOrImplicitSetter(PseudoObjectExpr *PseudoOp) { |
1416 | 13 | SourceRange OldRange = PseudoOp->getSourceRange(); |
1417 | | |
1418 | | // We just magically know some things about the structure of this |
1419 | | // expression. |
1420 | 13 | ObjCMessageExpr *OldMsg = |
1421 | 13 | cast<ObjCMessageExpr>(PseudoOp->getSemanticExpr( |
1422 | 13 | PseudoOp->getNumSemanticExprs() - 1)); |
1423 | | |
1424 | | // Because the rewriter doesn't allow us to rewrite rewritten code, |
1425 | | // we need to suppress rewriting the sub-statements. |
1426 | 13 | Expr *Base; |
1427 | 13 | SmallVector<Expr*, 2> Args; |
1428 | 13 | { |
1429 | 13 | DisableReplaceStmtScope S(*this); |
1430 | | |
1431 | | // Rebuild the base expression if we have one. |
1432 | 13 | Base = nullptr; |
1433 | 13 | if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) { |
1434 | 13 | Base = OldMsg->getInstanceReceiver(); |
1435 | 13 | Base = cast<OpaqueValueExpr>(Base)->getSourceExpr(); |
1436 | 13 | Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base)); |
1437 | 13 | } |
1438 | | |
1439 | 13 | unsigned numArgs = OldMsg->getNumArgs(); |
1440 | 29 | for (unsigned i = 0; i < numArgs; i++16 ) { |
1441 | 16 | Expr *Arg = OldMsg->getArg(i); |
1442 | 16 | if (isa<OpaqueValueExpr>(Arg)) |
1443 | 13 | Arg = cast<OpaqueValueExpr>(Arg)->getSourceExpr(); |
1444 | 16 | Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg)); |
1445 | 16 | Args.push_back(Arg); |
1446 | 16 | } |
1447 | 13 | } |
1448 | | |
1449 | | // TODO: avoid this copy. |
1450 | 13 | SmallVector<SourceLocation, 1> SelLocs; |
1451 | 13 | OldMsg->getSelectorLocs(SelLocs); |
1452 | | |
1453 | 13 | ObjCMessageExpr *NewMsg = nullptr; |
1454 | 13 | switch (OldMsg->getReceiverKind()) { |
1455 | 0 | case ObjCMessageExpr::Class: |
1456 | 0 | NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(), |
1457 | 0 | OldMsg->getValueKind(), |
1458 | 0 | OldMsg->getLeftLoc(), |
1459 | 0 | OldMsg->getClassReceiverTypeInfo(), |
1460 | 0 | OldMsg->getSelector(), |
1461 | 0 | SelLocs, |
1462 | 0 | OldMsg->getMethodDecl(), |
1463 | 0 | Args, |
1464 | 0 | OldMsg->getRightLoc(), |
1465 | 0 | OldMsg->isImplicit()); |
1466 | 0 | break; |
1467 | | |
1468 | 13 | case ObjCMessageExpr::Instance: |
1469 | 13 | NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(), |
1470 | 13 | OldMsg->getValueKind(), |
1471 | 13 | OldMsg->getLeftLoc(), |
1472 | 13 | Base, |
1473 | 13 | OldMsg->getSelector(), |
1474 | 13 | SelLocs, |
1475 | 13 | OldMsg->getMethodDecl(), |
1476 | 13 | Args, |
1477 | 13 | OldMsg->getRightLoc(), |
1478 | 13 | OldMsg->isImplicit()); |
1479 | 13 | break; |
1480 | | |
1481 | 0 | case ObjCMessageExpr::SuperClass: |
1482 | 0 | case ObjCMessageExpr::SuperInstance: |
1483 | 0 | NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(), |
1484 | 0 | OldMsg->getValueKind(), |
1485 | 0 | OldMsg->getLeftLoc(), |
1486 | 0 | OldMsg->getSuperLoc(), |
1487 | 0 | OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance, |
1488 | 0 | OldMsg->getSuperType(), |
1489 | 0 | OldMsg->getSelector(), |
1490 | 0 | SelLocs, |
1491 | 0 | OldMsg->getMethodDecl(), |
1492 | 0 | Args, |
1493 | 0 | OldMsg->getRightLoc(), |
1494 | 0 | OldMsg->isImplicit()); |
1495 | 0 | break; |
1496 | 13 | } |
1497 | | |
1498 | 13 | Stmt *Replacement = SynthMessageExpr(NewMsg); |
1499 | 13 | ReplaceStmtWithRange(PseudoOp, Replacement, OldRange); |
1500 | 13 | return Replacement; |
1501 | 13 | } |
1502 | | |
1503 | 20 | Stmt *RewriteModernObjC::RewritePropertyOrImplicitGetter(PseudoObjectExpr *PseudoOp) { |
1504 | 20 | SourceRange OldRange = PseudoOp->getSourceRange(); |
1505 | | |
1506 | | // We just magically know some things about the structure of this |
1507 | | // expression. |
1508 | 20 | ObjCMessageExpr *OldMsg = |
1509 | 20 | cast<ObjCMessageExpr>(PseudoOp->getResultExpr()->IgnoreImplicit()); |
1510 | | |
1511 | | // Because the rewriter doesn't allow us to rewrite rewritten code, |
1512 | | // we need to suppress rewriting the sub-statements. |
1513 | 20 | Expr *Base = nullptr; |
1514 | 20 | SmallVector<Expr*, 1> Args; |
1515 | 20 | { |
1516 | 20 | DisableReplaceStmtScope S(*this); |
1517 | | // Rebuild the base expression if we have one. |
1518 | 20 | if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) { |
1519 | 20 | Base = OldMsg->getInstanceReceiver(); |
1520 | 20 | Base = cast<OpaqueValueExpr>(Base)->getSourceExpr(); |
1521 | 20 | Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base)); |
1522 | 20 | } |
1523 | 20 | unsigned numArgs = OldMsg->getNumArgs(); |
1524 | 23 | for (unsigned i = 0; i < numArgs; i++3 ) { |
1525 | 3 | Expr *Arg = OldMsg->getArg(i); |
1526 | 3 | if (isa<OpaqueValueExpr>(Arg)) |
1527 | 0 | Arg = cast<OpaqueValueExpr>(Arg)->getSourceExpr(); |
1528 | 3 | Arg = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Arg)); |
1529 | 3 | Args.push_back(Arg); |
1530 | 3 | } |
1531 | 20 | } |
1532 | | |
1533 | | // Intentionally empty. |
1534 | 20 | SmallVector<SourceLocation, 1> SelLocs; |
1535 | | |
1536 | 20 | ObjCMessageExpr *NewMsg = nullptr; |
1537 | 20 | switch (OldMsg->getReceiverKind()) { |
1538 | 0 | case ObjCMessageExpr::Class: |
1539 | 0 | NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(), |
1540 | 0 | OldMsg->getValueKind(), |
1541 | 0 | OldMsg->getLeftLoc(), |
1542 | 0 | OldMsg->getClassReceiverTypeInfo(), |
1543 | 0 | OldMsg->getSelector(), |
1544 | 0 | SelLocs, |
1545 | 0 | OldMsg->getMethodDecl(), |
1546 | 0 | Args, |
1547 | 0 | OldMsg->getRightLoc(), |
1548 | 0 | OldMsg->isImplicit()); |
1549 | 0 | break; |
1550 | | |
1551 | 20 | case ObjCMessageExpr::Instance: |
1552 | 20 | NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(), |
1553 | 20 | OldMsg->getValueKind(), |
1554 | 20 | OldMsg->getLeftLoc(), |
1555 | 20 | Base, |
1556 | 20 | OldMsg->getSelector(), |
1557 | 20 | SelLocs, |
1558 | 20 | OldMsg->getMethodDecl(), |
1559 | 20 | Args, |
1560 | 20 | OldMsg->getRightLoc(), |
1561 | 20 | OldMsg->isImplicit()); |
1562 | 20 | break; |
1563 | | |
1564 | 0 | case ObjCMessageExpr::SuperClass: |
1565 | 0 | case ObjCMessageExpr::SuperInstance: |
1566 | 0 | NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(), |
1567 | 0 | OldMsg->getValueKind(), |
1568 | 0 | OldMsg->getLeftLoc(), |
1569 | 0 | OldMsg->getSuperLoc(), |
1570 | 0 | OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance, |
1571 | 0 | OldMsg->getSuperType(), |
1572 | 0 | OldMsg->getSelector(), |
1573 | 0 | SelLocs, |
1574 | 0 | OldMsg->getMethodDecl(), |
1575 | 0 | Args, |
1576 | 0 | OldMsg->getRightLoc(), |
1577 | 0 | OldMsg->isImplicit()); |
1578 | 0 | break; |
1579 | 20 | } |
1580 | | |
1581 | 20 | Stmt *Replacement = SynthMessageExpr(NewMsg); |
1582 | 20 | ReplaceStmtWithRange(PseudoOp, Replacement, OldRange); |
1583 | 20 | return Replacement; |
1584 | 20 | } |
1585 | | |
1586 | | /// SynthCountByEnumWithState - To print: |
1587 | | /// ((NSUInteger (*) |
1588 | | /// (id, SEL, struct __objcFastEnumerationState *, id *, NSUInteger)) |
1589 | | /// (void *)objc_msgSend)((id)l_collection, |
1590 | | /// sel_registerName( |
1591 | | /// "countByEnumeratingWithState:objects:count:"), |
1592 | | /// &enumState, |
1593 | | /// (id *)__rw_items, (NSUInteger)16) |
1594 | | /// |
1595 | 10 | void RewriteModernObjC::SynthCountByEnumWithState(std::string &buf) { |
1596 | 10 | buf += "((_WIN_NSUInteger (*) (id, SEL, struct __objcFastEnumerationState *, " |
1597 | 10 | "id *, _WIN_NSUInteger))(void *)objc_msgSend)"; |
1598 | 10 | buf += "\n\t\t"; |
1599 | 10 | buf += "((id)l_collection,\n\t\t"; |
1600 | 10 | buf += "sel_registerName(\"countByEnumeratingWithState:objects:count:\"),"; |
1601 | 10 | buf += "\n\t\t"; |
1602 | 10 | buf += "&enumState, " |
1603 | 10 | "(id *)__rw_items, (_WIN_NSUInteger)16)"; |
1604 | 10 | } |
1605 | | |
1606 | | /// RewriteBreakStmt - Rewrite for a break-stmt inside an ObjC2's foreach |
1607 | | /// statement to exit to its outer synthesized loop. |
1608 | | /// |
1609 | 5 | Stmt *RewriteModernObjC::RewriteBreakStmt(BreakStmt *S) { |
1610 | 5 | if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back())) |
1611 | 5 | return S; |
1612 | | // replace break with goto __break_label |
1613 | 0 | std::string buf; |
1614 | |
|
1615 | 0 | SourceLocation startLoc = S->getBeginLoc(); |
1616 | 0 | buf = "goto __break_label_"; |
1617 | 0 | buf += utostr(ObjCBcLabelNo.back()); |
1618 | 0 | ReplaceText(startLoc, strlen("break"), buf); |
1619 | |
|
1620 | 0 | return nullptr; |
1621 | 5 | } |
1622 | | |
1623 | | void RewriteModernObjC::ConvertSourceLocationToLineDirective( |
1624 | | SourceLocation Loc, |
1625 | 117 | std::string &LineString) { |
1626 | 117 | if (Loc.isFileID() && GenerateLineInfo) { |
1627 | 1 | LineString += "\n#line "; |
1628 | 1 | PresumedLoc PLoc = SM->getPresumedLoc(Loc); |
1629 | 1 | LineString += utostr(PLoc.getLine()); |
1630 | 1 | LineString += " \""; |
1631 | 1 | LineString += Lexer::Stringify(PLoc.getFilename()); |
1632 | 1 | LineString += "\"\n"; |
1633 | 1 | } |
1634 | 117 | } |
1635 | | |
1636 | | /// RewriteContinueStmt - Rewrite for a continue-stmt inside an ObjC2's foreach |
1637 | | /// statement to continue with its inner synthesized loop. |
1638 | | /// |
1639 | 0 | Stmt *RewriteModernObjC::RewriteContinueStmt(ContinueStmt *S) { |
1640 | 0 | if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back())) |
1641 | 0 | return S; |
1642 | | // replace continue with goto __continue_label |
1643 | 0 | std::string buf; |
1644 | |
|
1645 | 0 | SourceLocation startLoc = S->getBeginLoc(); |
1646 | 0 | buf = "goto __continue_label_"; |
1647 | 0 | buf += utostr(ObjCBcLabelNo.back()); |
1648 | 0 | ReplaceText(startLoc, strlen("continue"), buf); |
1649 | |
|
1650 | 0 | return nullptr; |
1651 | 0 | } |
1652 | | |
1653 | | /// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement. |
1654 | | /// It rewrites: |
1655 | | /// for ( type elem in collection) { stmts; } |
1656 | | |
1657 | | /// Into: |
1658 | | /// { |
1659 | | /// type elem; |
1660 | | /// struct __objcFastEnumerationState enumState = { 0 }; |
1661 | | /// id __rw_items[16]; |
1662 | | /// id l_collection = (id)collection; |
1663 | | /// NSUInteger limit = [l_collection countByEnumeratingWithState:&enumState |
1664 | | /// objects:__rw_items count:16]; |
1665 | | /// if (limit) { |
1666 | | /// unsigned long startMutations = *enumState.mutationsPtr; |
1667 | | /// do { |
1668 | | /// unsigned long counter = 0; |
1669 | | /// do { |
1670 | | /// if (startMutations != *enumState.mutationsPtr) |
1671 | | /// objc_enumerationMutation(l_collection); |
1672 | | /// elem = (type)enumState.itemsPtr[counter++]; |
1673 | | /// stmts; |
1674 | | /// __continue_label: ; |
1675 | | /// } while (counter < limit); |
1676 | | /// } while ((limit = [l_collection countByEnumeratingWithState:&enumState |
1677 | | /// objects:__rw_items count:16])); |
1678 | | /// elem = nil; |
1679 | | /// __break_label: ; |
1680 | | /// } |
1681 | | /// else |
1682 | | /// elem = nil; |
1683 | | /// } |
1684 | | /// |
1685 | | Stmt *RewriteModernObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S, |
1686 | 5 | SourceLocation OrigEnd) { |
1687 | 5 | assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty"); |
1688 | 5 | assert(isa<ObjCForCollectionStmt>(Stmts.back()) && |
1689 | 5 | "ObjCForCollectionStmt Statement stack mismatch"); |
1690 | 5 | assert(!ObjCBcLabelNo.empty() && |
1691 | 5 | "ObjCForCollectionStmt - Label No stack empty"); |
1692 | | |
1693 | 5 | SourceLocation startLoc = S->getBeginLoc(); |
1694 | 5 | const char *startBuf = SM->getCharacterData(startLoc); |
1695 | 5 | StringRef elementName; |
1696 | 5 | std::string elementTypeAsString; |
1697 | 5 | std::string buf; |
1698 | | // line directive first. |
1699 | 5 | SourceLocation ForEachLoc = S->getForLoc(); |
1700 | 5 | ConvertSourceLocationToLineDirective(ForEachLoc, buf); |
1701 | 5 | buf += "{\n\t"; |
1702 | 5 | if (DeclStmt *DS = dyn_cast<DeclStmt>(S->getElement())) { |
1703 | | // type elem; |
1704 | 5 | NamedDecl* D = cast<NamedDecl>(DS->getSingleDecl()); |
1705 | 5 | QualType ElementType = cast<ValueDecl>(D)->getType(); |
1706 | 5 | if (ElementType->isObjCQualifiedIdType() || |
1707 | 5 | ElementType->isObjCQualifiedInterfaceType()) |
1708 | | // Simply use 'id' for all qualified types. |
1709 | 0 | elementTypeAsString = "id"; |
1710 | 5 | else |
1711 | 5 | elementTypeAsString = ElementType.getAsString(Context->getPrintingPolicy()); |
1712 | 5 | buf += elementTypeAsString; |
1713 | 5 | buf += " "; |
1714 | 5 | elementName = D->getName(); |
1715 | 5 | buf += elementName; |
1716 | 5 | buf += ";\n\t"; |
1717 | 5 | } |
1718 | 0 | else { |
1719 | 0 | DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement()); |
1720 | 0 | elementName = DR->getDecl()->getName(); |
1721 | 0 | ValueDecl *VD = DR->getDecl(); |
1722 | 0 | if (VD->getType()->isObjCQualifiedIdType() || |
1723 | 0 | VD->getType()->isObjCQualifiedInterfaceType()) |
1724 | | // Simply use 'id' for all qualified types. |
1725 | 0 | elementTypeAsString = "id"; |
1726 | 0 | else |
1727 | 0 | elementTypeAsString = VD->getType().getAsString(Context->getPrintingPolicy()); |
1728 | 0 | } |
1729 | | |
1730 | | // struct __objcFastEnumerationState enumState = { 0 }; |
1731 | 5 | buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t"; |
1732 | | // id __rw_items[16]; |
1733 | 5 | buf += "id __rw_items[16];\n\t"; |
1734 | | // id l_collection = (id) |
1735 | 5 | buf += "id l_collection = (id)"; |
1736 | | // Find start location of 'collection' the hard way! |
1737 | 5 | const char *startCollectionBuf = startBuf; |
1738 | 5 | startCollectionBuf += 3; // skip 'for' |
1739 | 5 | startCollectionBuf = strchr(startCollectionBuf, '('); |
1740 | 5 | startCollectionBuf++; // skip '(' |
1741 | | // find 'in' and skip it. |
1742 | 33 | while (*startCollectionBuf != ' ' || |
1743 | 33 | *(startCollectionBuf+1) != 'i'10 || *(startCollectionBuf+2) != 'n'5 || |
1744 | 33 | (5 *(startCollectionBuf+3) != ' '5 && |
1745 | 5 | *(startCollectionBuf+3) != '['0 && *(startCollectionBuf+3) != '('0 )) |
1746 | 28 | startCollectionBuf++; |
1747 | 5 | startCollectionBuf += 3; |
1748 | | |
1749 | | // Replace: "for (type element in" with string constructed thus far. |
1750 | 5 | ReplaceText(startLoc, startCollectionBuf - startBuf, buf); |
1751 | | // Replace ')' in for '(' type elem in collection ')' with ';' |
1752 | 5 | SourceLocation rightParenLoc = S->getRParenLoc(); |
1753 | 5 | const char *rparenBuf = SM->getCharacterData(rightParenLoc); |
1754 | 5 | SourceLocation lparenLoc = startLoc.getLocWithOffset(rparenBuf-startBuf); |
1755 | 5 | buf = ";\n\t"; |
1756 | | |
1757 | | // unsigned long limit = [l_collection countByEnumeratingWithState:&enumState |
1758 | | // objects:__rw_items count:16]; |
1759 | | // which is synthesized into: |
1760 | | // NSUInteger limit = |
1761 | | // ((NSUInteger (*) |
1762 | | // (id, SEL, struct __objcFastEnumerationState *, id *, NSUInteger)) |
1763 | | // (void *)objc_msgSend)((id)l_collection, |
1764 | | // sel_registerName( |
1765 | | // "countByEnumeratingWithState:objects:count:"), |
1766 | | // (struct __objcFastEnumerationState *)&state, |
1767 | | // (id *)__rw_items, (NSUInteger)16); |
1768 | 5 | buf += "_WIN_NSUInteger limit =\n\t\t"; |
1769 | 5 | SynthCountByEnumWithState(buf); |
1770 | 5 | buf += ";\n\t"; |
1771 | | /// if (limit) { |
1772 | | /// unsigned long startMutations = *enumState.mutationsPtr; |
1773 | | /// do { |
1774 | | /// unsigned long counter = 0; |
1775 | | /// do { |
1776 | | /// if (startMutations != *enumState.mutationsPtr) |
1777 | | /// objc_enumerationMutation(l_collection); |
1778 | | /// elem = (type)enumState.itemsPtr[counter++]; |
1779 | 5 | buf += "if (limit) {\n\t"; |
1780 | 5 | buf += "unsigned long startMutations = *enumState.mutationsPtr;\n\t"; |
1781 | 5 | buf += "do {\n\t\t"; |
1782 | 5 | buf += "unsigned long counter = 0;\n\t\t"; |
1783 | 5 | buf += "do {\n\t\t\t"; |
1784 | 5 | buf += "if (startMutations != *enumState.mutationsPtr)\n\t\t\t\t"; |
1785 | 5 | buf += "objc_enumerationMutation(l_collection);\n\t\t\t"; |
1786 | 5 | buf += elementName; |
1787 | 5 | buf += " = ("; |
1788 | 5 | buf += elementTypeAsString; |
1789 | 5 | buf += ")enumState.itemsPtr[counter++];"; |
1790 | | // Replace ')' in for '(' type elem in collection ')' with all of these. |
1791 | 5 | ReplaceText(lparenLoc, 1, buf); |
1792 | | |
1793 | | /// __continue_label: ; |
1794 | | /// } while (counter < limit); |
1795 | | /// } while ((limit = [l_collection countByEnumeratingWithState:&enumState |
1796 | | /// objects:__rw_items count:16])); |
1797 | | /// elem = nil; |
1798 | | /// __break_label: ; |
1799 | | /// } |
1800 | | /// else |
1801 | | /// elem = nil; |
1802 | | /// } |
1803 | | /// |
1804 | 5 | buf = ";\n\t"; |
1805 | 5 | buf += "__continue_label_"; |
1806 | 5 | buf += utostr(ObjCBcLabelNo.back()); |
1807 | 5 | buf += ": ;"; |
1808 | 5 | buf += "\n\t\t"; |
1809 | 5 | buf += "} while (counter < limit);\n\t"; |
1810 | 5 | buf += "} while ((limit = "; |
1811 | 5 | SynthCountByEnumWithState(buf); |
1812 | 5 | buf += "));\n\t"; |
1813 | 5 | buf += elementName; |
1814 | 5 | buf += " = (("; |
1815 | 5 | buf += elementTypeAsString; |
1816 | 5 | buf += ")0);\n\t"; |
1817 | 5 | buf += "__break_label_"; |
1818 | 5 | buf += utostr(ObjCBcLabelNo.back()); |
1819 | 5 | buf += ": ;\n\t"; |
1820 | 5 | buf += "}\n\t"; |
1821 | 5 | buf += "else\n\t\t"; |
1822 | 5 | buf += elementName; |
1823 | 5 | buf += " = (("; |
1824 | 5 | buf += elementTypeAsString; |
1825 | 5 | buf += ")0);\n\t"; |
1826 | 5 | buf += "}\n"; |
1827 | | |
1828 | | // Insert all these *after* the statement body. |
1829 | | // FIXME: If this should support Obj-C++, support CXXTryStmt |
1830 | 5 | if (isa<CompoundStmt>(S->getBody())) { |
1831 | 5 | SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(1); |
1832 | 5 | InsertText(endBodyLoc, buf); |
1833 | 5 | } else { |
1834 | | /* Need to treat single statements specially. For example: |
1835 | | * |
1836 | | * for (A *a in b) if (stuff()) break; |
1837 | | * for (A *a in b) xxxyy; |
1838 | | * |
1839 | | * The following code simply scans ahead to the semi to find the actual end. |
1840 | | */ |
1841 | 0 | const char *stmtBuf = SM->getCharacterData(OrigEnd); |
1842 | 0 | const char *semiBuf = strchr(stmtBuf, ';'); |
1843 | 0 | assert(semiBuf && "Can't find ';'"); |
1844 | 0 | SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(semiBuf-stmtBuf+1); |
1845 | 0 | InsertText(endBodyLoc, buf); |
1846 | 0 | } |
1847 | 5 | Stmts.pop_back(); |
1848 | 5 | ObjCBcLabelNo.pop_back(); |
1849 | 5 | return nullptr; |
1850 | 5 | } |
1851 | | |
1852 | 12 | static void Write_RethrowObject(std::string &buf) { |
1853 | 12 | buf += "{ struct _FIN { _FIN(id reth) : rethrow(reth) {}\n"; |
1854 | 12 | buf += "\t~_FIN() { if (rethrow) objc_exception_throw(rethrow); }\n"; |
1855 | 12 | buf += "\tid rethrow;\n"; |
1856 | 12 | buf += "\t} _fin_force_rethow(_rethrow);"; |
1857 | 12 | } |
1858 | | |
1859 | | /// RewriteObjCSynchronizedStmt - |
1860 | | /// This routine rewrites @synchronized(expr) stmt; |
1861 | | /// into: |
1862 | | /// objc_sync_enter(expr); |
1863 | | /// @try stmt @finally { objc_sync_exit(expr); } |
1864 | | /// |
1865 | 4 | Stmt *RewriteModernObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) { |
1866 | | // Get the start location and compute the semi location. |
1867 | 4 | SourceLocation startLoc = S->getBeginLoc(); |
1868 | 4 | const char *startBuf = SM->getCharacterData(startLoc); |
1869 | | |
1870 | 4 | assert((*startBuf == '@') && "bogus @synchronized location"); |
1871 | | |
1872 | 4 | std::string buf; |
1873 | 4 | SourceLocation SynchLoc = S->getAtSynchronizedLoc(); |
1874 | 4 | ConvertSourceLocationToLineDirective(SynchLoc, buf); |
1875 | 4 | buf += "{ id _rethrow = 0; id _sync_obj = (id)"; |
1876 | | |
1877 | 4 | const char *lparenBuf = startBuf; |
1878 | 59 | while (*lparenBuf != '(') lparenBuf++55 ; |
1879 | 4 | ReplaceText(startLoc, lparenBuf-startBuf+1, buf); |
1880 | | |
1881 | 4 | buf = "; objc_sync_enter(_sync_obj);\n"; |
1882 | 4 | buf += "try {\n\tstruct _SYNC_EXIT { _SYNC_EXIT(id arg) : sync_exit(arg) {}"; |
1883 | 4 | buf += "\n\t~_SYNC_EXIT() {objc_sync_exit(sync_exit);}"; |
1884 | 4 | buf += "\n\tid sync_exit;"; |
1885 | 4 | buf += "\n\t} _sync_exit(_sync_obj);\n"; |
1886 | | |
1887 | | // We can't use S->getSynchExpr()->getEndLoc() to find the end location, since |
1888 | | // the sync expression is typically a message expression that's already |
1889 | | // been rewritten! (which implies the SourceLocation's are invalid). |
1890 | 4 | SourceLocation RParenExprLoc = S->getSynchBody()->getBeginLoc(); |
1891 | 4 | const char *RParenExprLocBuf = SM->getCharacterData(RParenExprLoc); |
1892 | 12 | while (*RParenExprLocBuf != ')') RParenExprLocBuf--8 ; |
1893 | 4 | RParenExprLoc = startLoc.getLocWithOffset(RParenExprLocBuf-startBuf); |
1894 | | |
1895 | 4 | SourceLocation LBranceLoc = S->getSynchBody()->getBeginLoc(); |
1896 | 4 | const char *LBraceLocBuf = SM->getCharacterData(LBranceLoc); |
1897 | 4 | assert (*LBraceLocBuf == '{'); |
1898 | 4 | ReplaceText(RParenExprLoc, (LBraceLocBuf - SM->getCharacterData(RParenExprLoc) + 1), buf); |
1899 | | |
1900 | 4 | SourceLocation startRBraceLoc = S->getSynchBody()->getEndLoc(); |
1901 | 4 | assert((*SM->getCharacterData(startRBraceLoc) == '}') && |
1902 | 4 | "bogus @synchronized block"); |
1903 | | |
1904 | 4 | buf = "} catch (id e) {_rethrow = e;}\n"; |
1905 | 4 | Write_RethrowObject(buf); |
1906 | 4 | buf += "}\n"; |
1907 | 4 | buf += "}\n"; |
1908 | | |
1909 | 4 | ReplaceText(startRBraceLoc, 1, buf); |
1910 | | |
1911 | 4 | return nullptr; |
1912 | 4 | } |
1913 | | |
1914 | | void RewriteModernObjC::WarnAboutReturnGotoStmts(Stmt *S) |
1915 | 33 | { |
1916 | | // Perform a bottom up traversal of all children. |
1917 | 33 | for (Stmt *SubStmt : S->children()) |
1918 | 25 | if (SubStmt) |
1919 | 25 | WarnAboutReturnGotoStmts(SubStmt); |
1920 | | |
1921 | 33 | if (isa<ReturnStmt>(S) || isa<GotoStmt>(S)) { |
1922 | 0 | Diags.Report(Context->getFullLoc(S->getBeginLoc()), |
1923 | 0 | TryFinallyContainsReturnDiag); |
1924 | 0 | } |
1925 | 33 | } |
1926 | | |
1927 | 1 | Stmt *RewriteModernObjC::RewriteObjCAutoreleasePoolStmt(ObjCAutoreleasePoolStmt *S) { |
1928 | 1 | SourceLocation startLoc = S->getAtLoc(); |
1929 | 1 | ReplaceText(startLoc, strlen("@autoreleasepool"), "/* @autoreleasepool */"); |
1930 | 1 | ReplaceText(S->getSubStmt()->getBeginLoc(), 1, |
1931 | 1 | "{ __AtAutoreleasePool __autoreleasepool; "); |
1932 | | |
1933 | 1 | return nullptr; |
1934 | 1 | } |
1935 | | |
1936 | 14 | Stmt *RewriteModernObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) { |
1937 | 14 | ObjCAtFinallyStmt *finalStmt = S->getFinallyStmt(); |
1938 | 14 | bool noCatch = S->getNumCatchStmts() == 0; |
1939 | 14 | std::string buf; |
1940 | 14 | SourceLocation TryLocation = S->getAtTryLoc(); |
1941 | 14 | ConvertSourceLocationToLineDirective(TryLocation, buf); |
1942 | | |
1943 | 14 | if (finalStmt) { |
1944 | 8 | if (noCatch) |
1945 | 7 | buf += "{ id volatile _rethrow = 0;\n"; |
1946 | 1 | else { |
1947 | 1 | buf += "{ id volatile _rethrow = 0;\ntry {\n"; |
1948 | 1 | } |
1949 | 8 | } |
1950 | | // Get the start location and compute the semi location. |
1951 | 14 | SourceLocation startLoc = S->getBeginLoc(); |
1952 | 14 | const char *startBuf = SM->getCharacterData(startLoc); |
1953 | | |
1954 | 14 | assert((*startBuf == '@') && "bogus @try location"); |
1955 | 14 | if (finalStmt) |
1956 | 8 | ReplaceText(startLoc, 1, buf); |
1957 | 6 | else |
1958 | | // @try -> try |
1959 | 6 | ReplaceText(startLoc, 1, ""); |
1960 | | |
1961 | 14 | for (ObjCAtCatchStmt *Catch : S->catch_stmts()) { |
1962 | 11 | VarDecl *catchDecl = Catch->getCatchParamDecl(); |
1963 | | |
1964 | 11 | startLoc = Catch->getBeginLoc(); |
1965 | 11 | bool AtRemoved = false; |
1966 | 11 | if (catchDecl) { |
1967 | 8 | QualType t = catchDecl->getType(); |
1968 | 8 | if (const ObjCObjectPointerType *Ptr = |
1969 | 8 | t->getAs<ObjCObjectPointerType>()) { |
1970 | | // Should be a pointer to a class. |
1971 | 8 | ObjCInterfaceDecl *IDecl = Ptr->getObjectType()->getInterface(); |
1972 | 8 | if (IDecl) { |
1973 | 6 | std::string Result; |
1974 | 6 | ConvertSourceLocationToLineDirective(Catch->getBeginLoc(), Result); |
1975 | | |
1976 | 6 | startBuf = SM->getCharacterData(startLoc); |
1977 | 6 | assert((*startBuf == '@') && "bogus @catch location"); |
1978 | 6 | SourceLocation rParenLoc = Catch->getRParenLoc(); |
1979 | 6 | const char *rParenBuf = SM->getCharacterData(rParenLoc); |
1980 | | |
1981 | | // _objc_exc_Foo *_e as argument to catch. |
1982 | 6 | Result += "catch (_objc_exc_"; Result += IDecl->getNameAsString(); |
1983 | 6 | Result += " *_"; Result += catchDecl->getNameAsString(); |
1984 | 6 | Result += ")"; |
1985 | 6 | ReplaceText(startLoc, rParenBuf-startBuf+1, Result); |
1986 | | // Foo *e = (Foo *)_e; |
1987 | 6 | Result.clear(); |
1988 | 6 | Result = "{ "; |
1989 | 6 | Result += IDecl->getNameAsString(); |
1990 | 6 | Result += " *"; Result += catchDecl->getNameAsString(); |
1991 | 6 | Result += " = ("; Result += IDecl->getNameAsString(); Result += "*)"; |
1992 | 6 | Result += "_"; Result += catchDecl->getNameAsString(); |
1993 | | |
1994 | 6 | Result += "; "; |
1995 | 6 | SourceLocation lBraceLoc = Catch->getCatchBody()->getBeginLoc(); |
1996 | 6 | ReplaceText(lBraceLoc, 1, Result); |
1997 | 6 | AtRemoved = true; |
1998 | 6 | } |
1999 | 8 | } |
2000 | 8 | } |
2001 | 11 | if (!AtRemoved) |
2002 | | // @catch -> catch |
2003 | 5 | ReplaceText(startLoc, 1, ""); |
2004 | | |
2005 | 11 | } |
2006 | 14 | if (finalStmt) { |
2007 | 8 | buf.clear(); |
2008 | 8 | SourceLocation FinallyLoc = finalStmt->getBeginLoc(); |
2009 | | |
2010 | 8 | if (noCatch) { |
2011 | 7 | ConvertSourceLocationToLineDirective(FinallyLoc, buf); |
2012 | 7 | buf += "catch (id e) {_rethrow = e;}\n"; |
2013 | 7 | } |
2014 | 1 | else { |
2015 | 1 | buf += "}\n"; |
2016 | 1 | ConvertSourceLocationToLineDirective(FinallyLoc, buf); |
2017 | 1 | buf += "catch (id e) {_rethrow = e;}\n"; |
2018 | 1 | } |
2019 | | |
2020 | 8 | SourceLocation startFinalLoc = finalStmt->getBeginLoc(); |
2021 | 8 | ReplaceText(startFinalLoc, 8, buf); |
2022 | 8 | Stmt *body = finalStmt->getFinallyBody(); |
2023 | 8 | SourceLocation startFinalBodyLoc = body->getBeginLoc(); |
2024 | 8 | buf.clear(); |
2025 | 8 | Write_RethrowObject(buf); |
2026 | 8 | ReplaceText(startFinalBodyLoc, 1, buf); |
2027 | | |
2028 | 8 | SourceLocation endFinalBodyLoc = body->getEndLoc(); |
2029 | 8 | ReplaceText(endFinalBodyLoc, 1, "}\n}"); |
2030 | | // Now check for any return/continue/go statements within the @try. |
2031 | 8 | WarnAboutReturnGotoStmts(S->getTryBody()); |
2032 | 8 | } |
2033 | | |
2034 | 14 | return nullptr; |
2035 | 14 | } |
2036 | | |
2037 | | // This can't be done with ReplaceStmt(S, ThrowExpr), since |
2038 | | // the throw expression is typically a message expression that's already |
2039 | | // been rewritten! (which implies the SourceLocation's are invalid). |
2040 | 5 | Stmt *RewriteModernObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) { |
2041 | | // Get the start location and compute the semi location. |
2042 | 5 | SourceLocation startLoc = S->getBeginLoc(); |
2043 | 5 | const char *startBuf = SM->getCharacterData(startLoc); |
2044 | | |
2045 | 5 | assert((*startBuf == '@') && "bogus @throw location"); |
2046 | | |
2047 | 5 | std::string buf; |
2048 | | /* void objc_exception_throw(id) __attribute__((noreturn)); */ |
2049 | 5 | if (S->getThrowExpr()) |
2050 | 4 | buf = "objc_exception_throw("; |
2051 | 1 | else |
2052 | 1 | buf = "throw"; |
2053 | | |
2054 | | // handle "@ throw" correctly. |
2055 | 5 | const char *wBuf = strchr(startBuf, 'w'); |
2056 | 5 | assert((*wBuf == 'w') && "@throw: can't find 'w'"); |
2057 | 5 | ReplaceText(startLoc, wBuf-startBuf+1, buf); |
2058 | | |
2059 | 5 | SourceLocation endLoc = S->getEndLoc(); |
2060 | 5 | const char *endBuf = SM->getCharacterData(endLoc); |
2061 | 5 | const char *semiBuf = strchr(endBuf, ';'); |
2062 | 5 | assert((*semiBuf == ';') && "@throw: can't find ';'"); |
2063 | 5 | SourceLocation semiLoc = startLoc.getLocWithOffset(semiBuf-startBuf); |
2064 | 5 | if (S->getThrowExpr()) |
2065 | 4 | ReplaceText(semiLoc, 1, ");"); |
2066 | 5 | return nullptr; |
2067 | 5 | } |
2068 | | |
2069 | 3 | Stmt *RewriteModernObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) { |
2070 | | // Create a new string expression. |
2071 | 3 | std::string StrEncoding; |
2072 | 3 | Context->getObjCEncodingForType(Exp->getEncodedType(), StrEncoding); |
2073 | 3 | Expr *Replacement = getStringLiteral(StrEncoding); |
2074 | 3 | ReplaceStmt(Exp, Replacement); |
2075 | | |
2076 | | // Replace this subexpr in the parent. |
2077 | | // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info. |
2078 | 3 | return Replacement; |
2079 | 3 | } |
2080 | | |
2081 | 0 | Stmt *RewriteModernObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) { |
2082 | 0 | if (!SelGetUidFunctionDecl) |
2083 | 0 | SynthSelGetUidFunctionDecl(); |
2084 | 0 | assert(SelGetUidFunctionDecl && "Can't find sel_registerName() decl"); |
2085 | | // Create a call to sel_registerName("selName"). |
2086 | 0 | SmallVector<Expr*, 8> SelExprs; |
2087 | 0 | SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString())); |
2088 | 0 | CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl, |
2089 | 0 | SelExprs); |
2090 | 0 | ReplaceStmt(Exp, SelExp); |
2091 | | // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info. |
2092 | 0 | return SelExp; |
2093 | 0 | } |
2094 | | |
2095 | | CallExpr * |
2096 | | RewriteModernObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD, |
2097 | | ArrayRef<Expr *> Args, |
2098 | | SourceLocation StartLoc, |
2099 | 215 | SourceLocation EndLoc) { |
2100 | | // Get the type, we will need to reference it in a couple spots. |
2101 | 215 | QualType msgSendType = FD->getType(); |
2102 | | |
2103 | | // Create a reference to the objc_msgSend() declaration. |
2104 | 215 | DeclRefExpr *DRE = new (Context) DeclRefExpr(*Context, FD, false, msgSendType, |
2105 | 215 | VK_LValue, SourceLocation()); |
2106 | | |
2107 | | // Now, we cast the reference to a pointer to the objc_msgSend type. |
2108 | 215 | QualType pToFunc = Context->getPointerType(msgSendType); |
2109 | 215 | ImplicitCastExpr *ICE = |
2110 | 215 | ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay, |
2111 | 215 | DRE, nullptr, VK_PRValue, FPOptionsOverride()); |
2112 | | |
2113 | 215 | const auto *FT = msgSendType->castAs<FunctionType>(); |
2114 | 215 | CallExpr *Exp = |
2115 | 215 | CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context), |
2116 | 215 | VK_PRValue, EndLoc, FPOptionsOverride()); |
2117 | 215 | return Exp; |
2118 | 215 | } |
2119 | | |
2120 | | static bool scanForProtocolRefs(const char *startBuf, const char *endBuf, |
2121 | 6 | const char *&startRef, const char *&endRef) { |
2122 | 70 | while (startBuf < endBuf) { |
2123 | 70 | if (*startBuf == '<') |
2124 | 6 | startRef = startBuf; // mark the start. |
2125 | 70 | if (*startBuf == '>') { |
2126 | 6 | if (startRef && *startRef == '<') { |
2127 | 6 | endRef = startBuf; // mark the end. |
2128 | 6 | return true; |
2129 | 6 | } |
2130 | 0 | return false; |
2131 | 6 | } |
2132 | 64 | startBuf++; |
2133 | 64 | } |
2134 | 0 | return false; |
2135 | 6 | } |
2136 | | |
2137 | 0 | static void scanToNextArgument(const char *&argRef) { |
2138 | 0 | int angle = 0; |
2139 | 0 | while (*argRef != ')' && (*argRef != ',' || angle > 0)) { |
2140 | 0 | if (*argRef == '<') |
2141 | 0 | angle++; |
2142 | 0 | else if (*argRef == '>') |
2143 | 0 | angle--; |
2144 | 0 | argRef++; |
2145 | 0 | } |
2146 | 0 | assert(angle == 0 && "scanToNextArgument - bad protocol type syntax"); |
2147 | 0 | } |
2148 | | |
2149 | 568 | bool RewriteModernObjC::needToScanForQualifiers(QualType T) { |
2150 | 568 | if (T->isObjCQualifiedIdType()) |
2151 | 2 | return true; |
2152 | 566 | if (const PointerType *PT = T->getAs<PointerType>()) { |
2153 | 70 | if (PT->getPointeeType()->isObjCQualifiedIdType()) |
2154 | 0 | return true; |
2155 | 70 | } |
2156 | 566 | if (T->isObjCObjectPointerType()) { |
2157 | 132 | T = T->getPointeeType(); |
2158 | 132 | return T->isObjCQualifiedInterfaceType(); |
2159 | 132 | } |
2160 | 434 | if (T->isArrayType()) { |
2161 | 0 | QualType ElemTy = Context->getBaseElementType(T); |
2162 | 0 | return needToScanForQualifiers(ElemTy); |
2163 | 0 | } |
2164 | 434 | return false; |
2165 | 434 | } |
2166 | | |
2167 | 30 | void RewriteModernObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) { |
2168 | 30 | QualType Type = E->getType(); |
2169 | 30 | if (needToScanForQualifiers(Type)) { |
2170 | 1 | SourceLocation Loc, EndLoc; |
2171 | | |
2172 | 1 | if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) { |
2173 | 1 | Loc = ECE->getLParenLoc(); |
2174 | 1 | EndLoc = ECE->getRParenLoc(); |
2175 | 1 | } else { |
2176 | 0 | Loc = E->getBeginLoc(); |
2177 | 0 | EndLoc = E->getEndLoc(); |
2178 | 0 | } |
2179 | | // This will defend against trying to rewrite synthesized expressions. |
2180 | 1 | if (Loc.isInvalid() || EndLoc.isInvalid()) |
2181 | 0 | return; |
2182 | | |
2183 | 1 | const char *startBuf = SM->getCharacterData(Loc); |
2184 | 1 | const char *endBuf = SM->getCharacterData(EndLoc); |
2185 | 1 | const char *startRef = nullptr, *endRef = nullptr; |
2186 | 1 | if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) { |
2187 | | // Get the locations of the startRef, endRef. |
2188 | 1 | SourceLocation LessLoc = Loc.getLocWithOffset(startRef-startBuf); |
2189 | 1 | SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-startBuf+1); |
2190 | | // Comment out the protocol references. |
2191 | 1 | InsertText(LessLoc, "/*"); |
2192 | 1 | InsertText(GreaterLoc, "*/"); |
2193 | 1 | } |
2194 | 1 | } |
2195 | 30 | } |
2196 | | |
2197 | 425 | void RewriteModernObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) { |
2198 | 425 | SourceLocation Loc; |
2199 | 425 | QualType Type; |
2200 | 425 | const FunctionProtoType *proto = nullptr; |
2201 | 425 | if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) { |
2202 | 193 | Loc = VD->getLocation(); |
2203 | 193 | Type = VD->getType(); |
2204 | 193 | } |
2205 | 232 | else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Dcl)) { |
2206 | 163 | Loc = FD->getLocation(); |
2207 | | // Check for ObjC 'id' and class types that have been adorned with protocol |
2208 | | // information (id<p>, C<p>*). The protocol references need to be rewritten! |
2209 | 163 | const FunctionType *funcType = FD->getType()->getAs<FunctionType>(); |
2210 | 163 | assert(funcType && "missing function type"); |
2211 | 163 | proto = dyn_cast<FunctionProtoType>(funcType); |
2212 | 163 | if (!proto) |
2213 | 0 | return; |
2214 | 163 | Type = proto->getReturnType(); |
2215 | 163 | } |
2216 | 69 | else if (FieldDecl *FD = dyn_cast<FieldDecl>(Dcl)) { |
2217 | 0 | Loc = FD->getLocation(); |
2218 | 0 | Type = FD->getType(); |
2219 | 0 | } |
2220 | 69 | else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(Dcl)) { |
2221 | 69 | Loc = TD->getLocation(); |
2222 | 69 | Type = TD->getUnderlyingType(); |
2223 | 69 | } |
2224 | 0 | else |
2225 | 0 | return; |
2226 | | |
2227 | 425 | if (needToScanForQualifiers(Type)) { |
2228 | | // Since types are unique, we need to scan the buffer. |
2229 | | |
2230 | 5 | const char *endBuf = SM->getCharacterData(Loc); |
2231 | 5 | const char *startBuf = endBuf; |
2232 | 72 | while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart67 ) |
2233 | 67 | startBuf--; // scan backward (from the decl location) for return type. |
2234 | 5 | const char *startRef = nullptr, *endRef = nullptr; |
2235 | 5 | if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) { |
2236 | | // Get the locations of the startRef, endRef. |
2237 | 5 | SourceLocation LessLoc = Loc.getLocWithOffset(startRef-endBuf); |
2238 | 5 | SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-endBuf+1); |
2239 | | // Comment out the protocol references. |
2240 | 5 | InsertText(LessLoc, "/*"); |
2241 | 5 | InsertText(GreaterLoc, "*/"); |
2242 | 5 | } |
2243 | 5 | } |
2244 | 425 | if (!proto) |
2245 | 262 | return; // most likely, was a variable |
2246 | | // Now check arguments. |
2247 | 163 | const char *startBuf = SM->getCharacterData(Loc); |
2248 | 163 | const char *startFuncBuf = startBuf; |
2249 | 248 | for (unsigned i = 0; i < proto->getNumParams(); i++85 ) { |
2250 | 85 | if (needToScanForQualifiers(proto->getParamType(i))) { |
2251 | | // Since types are unique, we need to scan the buffer. |
2252 | |
|
2253 | 0 | const char *endBuf = startBuf; |
2254 | | // scan forward (from the decl location) for argument types. |
2255 | 0 | scanToNextArgument(endBuf); |
2256 | 0 | const char *startRef = nullptr, *endRef = nullptr; |
2257 | 0 | if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) { |
2258 | | // Get the locations of the startRef, endRef. |
2259 | 0 | SourceLocation LessLoc = |
2260 | 0 | Loc.getLocWithOffset(startRef-startFuncBuf); |
2261 | 0 | SourceLocation GreaterLoc = |
2262 | 0 | Loc.getLocWithOffset(endRef-startFuncBuf+1); |
2263 | | // Comment out the protocol references. |
2264 | 0 | InsertText(LessLoc, "/*"); |
2265 | 0 | InsertText(GreaterLoc, "*/"); |
2266 | 0 | } |
2267 | 0 | startBuf = ++endBuf; |
2268 | 0 | } |
2269 | 85 | else { |
2270 | | // If the function name is derived from a macro expansion, then the |
2271 | | // argument buffer will not follow the name. Need to speak with Chris. |
2272 | 1.41k | while (*startBuf && *startBuf != ')' && *startBuf != ','1.34k ) |
2273 | 1.32k | startBuf++; // scan forward (from the decl location) for argument types. |
2274 | 85 | startBuf++; |
2275 | 85 | } |
2276 | 85 | } |
2277 | 163 | } |
2278 | | |
2279 | 146 | void RewriteModernObjC::RewriteTypeOfDecl(VarDecl *ND) { |
2280 | 146 | QualType QT = ND->getType(); |
2281 | 146 | const Type* TypePtr = QT->getAs<Type>(); |
2282 | 146 | if (!isa<TypeOfExprType>(TypePtr)) |
2283 | 143 | return; |
2284 | 9 | while (3 isa<TypeOfExprType>(TypePtr)) { |
2285 | 6 | const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr); |
2286 | 6 | QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType(); |
2287 | 6 | TypePtr = QT->getAs<Type>(); |
2288 | 6 | } |
2289 | | // FIXME. This will not work for multiple declarators; as in: |
2290 | | // __typeof__(a) b,c,d; |
2291 | 3 | std::string TypeAsString(QT.getAsString(Context->getPrintingPolicy())); |
2292 | 3 | SourceLocation DeclLoc = ND->getTypeSpecStartLoc(); |
2293 | 3 | const char *startBuf = SM->getCharacterData(DeclLoc); |
2294 | 3 | if (ND->getInit()) { |
2295 | 2 | std::string Name(ND->getNameAsString()); |
2296 | 2 | TypeAsString += " " + Name + " = "; |
2297 | 2 | Expr *E = ND->getInit(); |
2298 | 2 | SourceLocation startLoc; |
2299 | 2 | if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) |
2300 | 0 | startLoc = ECE->getLParenLoc(); |
2301 | 2 | else |
2302 | 2 | startLoc = E->getBeginLoc(); |
2303 | 2 | startLoc = SM->getExpansionLoc(startLoc); |
2304 | 2 | const char *endBuf = SM->getCharacterData(startLoc); |
2305 | 2 | ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString); |
2306 | 2 | } |
2307 | 1 | else { |
2308 | 1 | SourceLocation X = ND->getEndLoc(); |
2309 | 1 | X = SM->getExpansionLoc(X); |
2310 | 1 | const char *endBuf = SM->getCharacterData(X); |
2311 | 1 | ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString); |
2312 | 1 | } |
2313 | 3 | } |
2314 | | |
2315 | | // SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str); |
2316 | 3 | void RewriteModernObjC::SynthSelGetUidFunctionDecl() { |
2317 | 3 | IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName"); |
2318 | 3 | SmallVector<QualType, 16> ArgTys; |
2319 | 3 | ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst())); |
2320 | 3 | QualType getFuncType = |
2321 | 3 | getSimpleFunctionType(Context->getObjCSelType(), ArgTys); |
2322 | 3 | SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2323 | 3 | SourceLocation(), |
2324 | 3 | SourceLocation(), |
2325 | 3 | SelGetUidIdent, getFuncType, |
2326 | 3 | nullptr, SC_Extern); |
2327 | 3 | } |
2328 | | |
2329 | 192 | void RewriteModernObjC::RewriteFunctionDecl(FunctionDecl *FD) { |
2330 | | // declared in <objc/objc.h> |
2331 | 192 | if (FD->getIdentifier() && |
2332 | 192 | FD->getName() == "sel_registerName") { |
2333 | 29 | SelGetUidFunctionDecl = FD; |
2334 | 29 | return; |
2335 | 29 | } |
2336 | 163 | RewriteObjCQualifiedInterfaceTypes(FD); |
2337 | 163 | } |
2338 | | |
2339 | 9 | void RewriteModernObjC::RewriteBlockPointerType(std::string& Str, QualType Type) { |
2340 | 9 | std::string TypeString(Type.getAsString(Context->getPrintingPolicy())); |
2341 | 9 | const char *argPtr = TypeString.c_str(); |
2342 | 9 | if (!strchr(argPtr, '^')) { |
2343 | 1 | Str += TypeString; |
2344 | 1 | return; |
2345 | 1 | } |
2346 | 116 | while (8 *argPtr) { |
2347 | 108 | Str += (*argPtr == '^' ? '*'8 : *argPtr100 ); |
2348 | 108 | argPtr++; |
2349 | 108 | } |
2350 | 8 | } |
2351 | | |
2352 | | // FIXME. Consolidate this routine with RewriteBlockPointerType. |
2353 | | void RewriteModernObjC::RewriteBlockPointerTypeVariable(std::string& Str, |
2354 | 2 | ValueDecl *VD) { |
2355 | 2 | QualType Type = VD->getType(); |
2356 | 2 | std::string TypeString(Type.getAsString(Context->getPrintingPolicy())); |
2357 | 2 | const char *argPtr = TypeString.c_str(); |
2358 | 2 | int paren = 0; |
2359 | 29 | while (*argPtr) { |
2360 | 27 | switch (*argPtr) { |
2361 | 4 | case '(': |
2362 | 4 | Str += *argPtr; |
2363 | 4 | paren++; |
2364 | 4 | break; |
2365 | 4 | case ')': |
2366 | 4 | Str += *argPtr; |
2367 | 4 | paren--; |
2368 | 4 | break; |
2369 | 2 | case '^': |
2370 | 2 | Str += '*'; |
2371 | 2 | if (paren == 1) |
2372 | 2 | Str += VD->getNameAsString(); |
2373 | 2 | break; |
2374 | 17 | default: |
2375 | 17 | Str += *argPtr; |
2376 | 17 | break; |
2377 | 27 | } |
2378 | 27 | argPtr++; |
2379 | 27 | } |
2380 | 2 | } |
2381 | | |
2382 | 5 | void RewriteModernObjC::RewriteBlockLiteralFunctionDecl(FunctionDecl *FD) { |
2383 | 5 | SourceLocation FunLocStart = FD->getTypeSpecStartLoc(); |
2384 | 5 | const FunctionType *funcType = FD->getType()->getAs<FunctionType>(); |
2385 | 5 | const FunctionProtoType *proto = dyn_cast<FunctionProtoType>(funcType); |
2386 | 5 | if (!proto) |
2387 | 0 | return; |
2388 | 5 | QualType Type = proto->getReturnType(); |
2389 | 5 | std::string FdStr = Type.getAsString(Context->getPrintingPolicy()); |
2390 | 5 | FdStr += " "; |
2391 | 5 | FdStr += FD->getName(); |
2392 | 5 | FdStr += "("; |
2393 | 5 | unsigned numArgs = proto->getNumParams(); |
2394 | 8 | for (unsigned i = 0; i < numArgs; i++3 ) { |
2395 | 3 | QualType ArgType = proto->getParamType(i); |
2396 | 3 | RewriteBlockPointerType(FdStr, ArgType); |
2397 | 3 | if (i+1 < numArgs) |
2398 | 0 | FdStr += ", "; |
2399 | 3 | } |
2400 | 5 | if (FD->isVariadic()) { |
2401 | 2 | FdStr += (numArgs > 0) ? ", ...);\n"1 : "...);\n"1 ; |
2402 | 2 | } |
2403 | 3 | else |
2404 | 3 | FdStr += ");\n"; |
2405 | 5 | InsertText(FunLocStart, FdStr); |
2406 | 5 | } |
2407 | | |
2408 | | // SynthSuperConstructorFunctionDecl - id __rw_objc_super(id obj, id super); |
2409 | 1 | void RewriteModernObjC::SynthSuperConstructorFunctionDecl() { |
2410 | 1 | if (SuperConstructorFunctionDecl) |
2411 | 0 | return; |
2412 | 1 | IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super"); |
2413 | 1 | SmallVector<QualType, 16> ArgTys; |
2414 | 1 | QualType argT = Context->getObjCIdType(); |
2415 | 1 | assert(!argT.isNull() && "Can't find 'id' type"); |
2416 | 1 | ArgTys.push_back(argT); |
2417 | 1 | ArgTys.push_back(argT); |
2418 | 1 | QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(), |
2419 | 1 | ArgTys); |
2420 | 1 | SuperConstructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2421 | 1 | SourceLocation(), |
2422 | 1 | SourceLocation(), |
2423 | 1 | msgSendIdent, msgSendType, |
2424 | 1 | nullptr, SC_Extern); |
2425 | 1 | } |
2426 | | |
2427 | | // SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...); |
2428 | 29 | void RewriteModernObjC::SynthMsgSendFunctionDecl() { |
2429 | 29 | IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend"); |
2430 | 29 | SmallVector<QualType, 16> ArgTys; |
2431 | 29 | QualType argT = Context->getObjCIdType(); |
2432 | 29 | assert(!argT.isNull() && "Can't find 'id' type"); |
2433 | 29 | ArgTys.push_back(argT); |
2434 | 29 | argT = Context->getObjCSelType(); |
2435 | 29 | assert(!argT.isNull() && "Can't find 'SEL' type"); |
2436 | 29 | ArgTys.push_back(argT); |
2437 | 29 | QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(), |
2438 | 29 | ArgTys, /*variadic=*/true); |
2439 | 29 | MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2440 | 29 | SourceLocation(), |
2441 | 29 | SourceLocation(), |
2442 | 29 | msgSendIdent, msgSendType, nullptr, |
2443 | 29 | SC_Extern); |
2444 | 29 | } |
2445 | | |
2446 | | // SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(void); |
2447 | 25 | void RewriteModernObjC::SynthMsgSendSuperFunctionDecl() { |
2448 | 25 | IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper"); |
2449 | 25 | SmallVector<QualType, 2> ArgTys; |
2450 | 25 | ArgTys.push_back(Context->VoidTy); |
2451 | 25 | QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(), |
2452 | 25 | ArgTys, /*variadic=*/true); |
2453 | 25 | MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2454 | 25 | SourceLocation(), |
2455 | 25 | SourceLocation(), |
2456 | 25 | msgSendIdent, msgSendType, |
2457 | 25 | nullptr, SC_Extern); |
2458 | 25 | } |
2459 | | |
2460 | | // SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...); |
2461 | 25 | void RewriteModernObjC::SynthMsgSendStretFunctionDecl() { |
2462 | 25 | IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret"); |
2463 | 25 | SmallVector<QualType, 16> ArgTys; |
2464 | 25 | QualType argT = Context->getObjCIdType(); |
2465 | 25 | assert(!argT.isNull() && "Can't find 'id' type"); |
2466 | 25 | ArgTys.push_back(argT); |
2467 | 25 | argT = Context->getObjCSelType(); |
2468 | 25 | assert(!argT.isNull() && "Can't find 'SEL' type"); |
2469 | 25 | ArgTys.push_back(argT); |
2470 | 25 | QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(), |
2471 | 25 | ArgTys, /*variadic=*/true); |
2472 | 25 | MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2473 | 25 | SourceLocation(), |
2474 | 25 | SourceLocation(), |
2475 | 25 | msgSendIdent, msgSendType, |
2476 | 25 | nullptr, SC_Extern); |
2477 | 25 | } |
2478 | | |
2479 | | // SynthMsgSendSuperStretFunctionDecl - |
2480 | | // id objc_msgSendSuper_stret(void); |
2481 | 25 | void RewriteModernObjC::SynthMsgSendSuperStretFunctionDecl() { |
2482 | 25 | IdentifierInfo *msgSendIdent = |
2483 | 25 | &Context->Idents.get("objc_msgSendSuper_stret"); |
2484 | 25 | SmallVector<QualType, 2> ArgTys; |
2485 | 25 | ArgTys.push_back(Context->VoidTy); |
2486 | 25 | QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(), |
2487 | 25 | ArgTys, /*variadic=*/true); |
2488 | 25 | MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2489 | 25 | SourceLocation(), |
2490 | 25 | SourceLocation(), |
2491 | 25 | msgSendIdent, |
2492 | 25 | msgSendType, nullptr, |
2493 | 25 | SC_Extern); |
2494 | 25 | } |
2495 | | |
2496 | | // SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...); |
2497 | 25 | void RewriteModernObjC::SynthMsgSendFpretFunctionDecl() { |
2498 | 25 | IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret"); |
2499 | 25 | SmallVector<QualType, 16> ArgTys; |
2500 | 25 | QualType argT = Context->getObjCIdType(); |
2501 | 25 | assert(!argT.isNull() && "Can't find 'id' type"); |
2502 | 25 | ArgTys.push_back(argT); |
2503 | 25 | argT = Context->getObjCSelType(); |
2504 | 25 | assert(!argT.isNull() && "Can't find 'SEL' type"); |
2505 | 25 | ArgTys.push_back(argT); |
2506 | 25 | QualType msgSendType = getSimpleFunctionType(Context->DoubleTy, |
2507 | 25 | ArgTys, /*variadic=*/true); |
2508 | 25 | MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2509 | 25 | SourceLocation(), |
2510 | 25 | SourceLocation(), |
2511 | 25 | msgSendIdent, msgSendType, |
2512 | 25 | nullptr, SC_Extern); |
2513 | 25 | } |
2514 | | |
2515 | | // SynthGetClassFunctionDecl - Class objc_getClass(const char *name); |
2516 | 29 | void RewriteModernObjC::SynthGetClassFunctionDecl() { |
2517 | 29 | IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass"); |
2518 | 29 | SmallVector<QualType, 16> ArgTys; |
2519 | 29 | ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst())); |
2520 | 29 | QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(), |
2521 | 29 | ArgTys); |
2522 | 29 | GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2523 | 29 | SourceLocation(), |
2524 | 29 | SourceLocation(), |
2525 | 29 | getClassIdent, getClassType, |
2526 | 29 | nullptr, SC_Extern); |
2527 | 29 | } |
2528 | | |
2529 | | // SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls); |
2530 | 25 | void RewriteModernObjC::SynthGetSuperClassFunctionDecl() { |
2531 | 25 | IdentifierInfo *getSuperClassIdent = |
2532 | 25 | &Context->Idents.get("class_getSuperclass"); |
2533 | 25 | SmallVector<QualType, 16> ArgTys; |
2534 | 25 | ArgTys.push_back(Context->getObjCClassType()); |
2535 | 25 | QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(), |
2536 | 25 | ArgTys); |
2537 | 25 | GetSuperClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2538 | 25 | SourceLocation(), |
2539 | 25 | SourceLocation(), |
2540 | 25 | getSuperClassIdent, |
2541 | 25 | getClassType, nullptr, |
2542 | 25 | SC_Extern); |
2543 | 25 | } |
2544 | | |
2545 | | // SynthGetMetaClassFunctionDecl - Class objc_getMetaClass(const char *name); |
2546 | 25 | void RewriteModernObjC::SynthGetMetaClassFunctionDecl() { |
2547 | 25 | IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass"); |
2548 | 25 | SmallVector<QualType, 16> ArgTys; |
2549 | 25 | ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst())); |
2550 | 25 | QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(), |
2551 | 25 | ArgTys); |
2552 | 25 | GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl, |
2553 | 25 | SourceLocation(), |
2554 | 25 | SourceLocation(), |
2555 | 25 | getClassIdent, getClassType, |
2556 | 25 | nullptr, SC_Extern); |
2557 | 25 | } |
2558 | | |
2559 | 13 | Stmt *RewriteModernObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) { |
2560 | 13 | assert (Exp != nullptr && "Expected non-null ObjCStringLiteral"); |
2561 | 13 | QualType strType = getConstantStringStructType(); |
2562 | | |
2563 | 13 | std::string S = "__NSConstantStringImpl_"; |
2564 | | |
2565 | 13 | std::string tmpName = InFileName; |
2566 | 13 | unsigned i; |
2567 | 1.45k | for (i=0; i < tmpName.length(); i++1.44k ) { |
2568 | 1.44k | char c = tmpName.at(i); |
2569 | | // replace any non-alphanumeric characters with '_'. |
2570 | 1.44k | if (!isAlphanumeric(c)) |
2571 | 194 | tmpName[i] = '_'; |
2572 | 1.44k | } |
2573 | 13 | S += tmpName; |
2574 | 13 | S += "_"; |
2575 | 13 | S += utostr(NumObjCStringLiterals++); |
2576 | | |
2577 | 13 | Preamble += "static __NSConstantStringImpl " + S; |
2578 | 13 | Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,"; |
2579 | 13 | Preamble += "0x000007c8,"; // utf8_str |
2580 | | // The pretty printer for StringLiteral handles escape characters properly. |
2581 | 13 | std::string prettyBufS; |
2582 | 13 | llvm::raw_string_ostream prettyBuf(prettyBufS); |
2583 | 13 | Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts)); |
2584 | 13 | Preamble += prettyBuf.str(); |
2585 | 13 | Preamble += ","; |
2586 | 13 | Preamble += utostr(Exp->getString()->getByteLength()) + "};\n"; |
2587 | | |
2588 | 13 | VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(), |
2589 | 13 | SourceLocation(), &Context->Idents.get(S), |
2590 | 13 | strType, nullptr, SC_Static); |
2591 | 13 | DeclRefExpr *DRE = new (Context) |
2592 | 13 | DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation()); |
2593 | 13 | Expr *Unop = UnaryOperator::Create( |
2594 | 13 | const_cast<ASTContext &>(*Context), DRE, UO_AddrOf, |
2595 | 13 | Context->getPointerType(DRE->getType()), VK_PRValue, OK_Ordinary, |
2596 | 13 | SourceLocation(), false, FPOptionsOverride()); |
2597 | | // cast to NSConstantString * |
2598 | 13 | CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(), |
2599 | 13 | CK_CPointerToObjCPointerCast, Unop); |
2600 | 13 | ReplaceStmt(Exp, cast); |
2601 | | // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info. |
2602 | 13 | return cast; |
2603 | 13 | } |
2604 | | |
2605 | 16 | Stmt *RewriteModernObjC::RewriteObjCBoolLiteralExpr(ObjCBoolLiteralExpr *Exp) { |
2606 | 16 | unsigned IntSize = |
2607 | 16 | static_cast<unsigned>(Context->getTypeSize(Context->IntTy)); |
2608 | | |
2609 | 16 | Expr *FlagExp = IntegerLiteral::Create(*Context, |
2610 | 16 | llvm::APInt(IntSize, Exp->getValue()), |
2611 | 16 | Context->IntTy, Exp->getLocation()); |
2612 | 16 | CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Context->ObjCBuiltinBoolTy, |
2613 | 16 | CK_BitCast, FlagExp); |
2614 | 16 | ParenExpr *PE = new (Context) ParenExpr(Exp->getLocation(), Exp->getExprLoc(), |
2615 | 16 | cast); |
2616 | 16 | ReplaceStmt(Exp, PE); |
2617 | 16 | return PE; |
2618 | 16 | } |
2619 | | |
2620 | 36 | Stmt *RewriteModernObjC::RewriteObjCBoxedExpr(ObjCBoxedExpr *Exp) { |
2621 | | // synthesize declaration of helper functions needed in this routine. |
2622 | 36 | if (!SelGetUidFunctionDecl) |
2623 | 0 | SynthSelGetUidFunctionDecl(); |
2624 | | // use objc_msgSend() for all. |
2625 | 36 | if (!MsgSendFunctionDecl) |
2626 | 4 | SynthMsgSendFunctionDecl(); |
2627 | 36 | if (!GetClassFunctionDecl) |
2628 | 4 | SynthGetClassFunctionDecl(); |
2629 | | |
2630 | 36 | FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl; |
2631 | 36 | SourceLocation StartLoc = Exp->getBeginLoc(); |
2632 | 36 | SourceLocation EndLoc = Exp->getEndLoc(); |
2633 | | |
2634 | | // Synthesize a call to objc_msgSend(). |
2635 | 36 | SmallVector<Expr*, 4> MsgExprs; |
2636 | 36 | SmallVector<Expr*, 4> ClsExprs; |
2637 | | |
2638 | | // Create a call to objc_getClass("<BoxingClass>"). It will be the 1st argument. |
2639 | 36 | ObjCMethodDecl *BoxingMethod = Exp->getBoxingMethod(); |
2640 | 36 | ObjCInterfaceDecl *BoxingClass = BoxingMethod->getClassInterface(); |
2641 | | |
2642 | 36 | IdentifierInfo *clsName = BoxingClass->getIdentifier(); |
2643 | 36 | ClsExprs.push_back(getStringLiteral(clsName->getName())); |
2644 | 36 | CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs, |
2645 | 36 | StartLoc, EndLoc); |
2646 | 36 | MsgExprs.push_back(Cls); |
2647 | | |
2648 | | // Create a call to sel_registerName("<BoxingMethod>:"), etc. |
2649 | | // it will be the 2nd argument. |
2650 | 36 | SmallVector<Expr*, 4> SelExprs; |
2651 | 36 | SelExprs.push_back( |
2652 | 36 | getStringLiteral(BoxingMethod->getSelector().getAsString())); |
2653 | 36 | CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl, |
2654 | 36 | SelExprs, StartLoc, EndLoc); |
2655 | 36 | MsgExprs.push_back(SelExp); |
2656 | | |
2657 | | // User provided sub-expression is the 3rd, and last, argument. |
2658 | 36 | Expr *subExpr = Exp->getSubExpr(); |
2659 | 36 | if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(subExpr)) { |
2660 | 4 | QualType type = ICE->getType(); |
2661 | 4 | const Expr *SubExpr = ICE->IgnoreParenImpCasts(); |
2662 | 4 | CastKind CK = CK_BitCast; |
2663 | 4 | if (SubExpr->getType()->isIntegralType(*Context) && type->isBooleanType()2 ) |
2664 | 0 | CK = CK_IntegralToBoolean; |
2665 | 4 | subExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, subExpr); |
2666 | 4 | } |
2667 | 36 | MsgExprs.push_back(subExpr); |
2668 | | |
2669 | 36 | SmallVector<QualType, 4> ArgTypes; |
2670 | 36 | ArgTypes.push_back(Context->getObjCClassType()); |
2671 | 36 | ArgTypes.push_back(Context->getObjCSelType()); |
2672 | 36 | for (const auto PI : BoxingMethod->parameters()) |
2673 | 36 | ArgTypes.push_back(PI->getType()); |
2674 | | |
2675 | 36 | QualType returnType = Exp->getType(); |
2676 | | // Get the type, we will need to reference it in a couple spots. |
2677 | 36 | QualType msgSendType = MsgSendFlavor->getType(); |
2678 | | |
2679 | | // Create a reference to the objc_msgSend() declaration. |
2680 | 36 | DeclRefExpr *DRE = new (Context) DeclRefExpr( |
2681 | 36 | *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation()); |
2682 | | |
2683 | 36 | CastExpr *cast = NoTypeInfoCStyleCastExpr( |
2684 | 36 | Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE); |
2685 | | |
2686 | | // Now do the "normal" pointer to function cast. |
2687 | 36 | QualType castType = |
2688 | 36 | getSimpleFunctionType(returnType, ArgTypes, BoxingMethod->isVariadic()); |
2689 | 36 | castType = Context->getPointerType(castType); |
2690 | 36 | cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast, |
2691 | 36 | cast); |
2692 | | |
2693 | | // Don't forget the parens to enforce the proper binding. |
2694 | 36 | ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast); |
2695 | | |
2696 | 36 | auto *FT = msgSendType->castAs<FunctionType>(); |
2697 | 36 | CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), |
2698 | 36 | VK_PRValue, EndLoc, FPOptionsOverride()); |
2699 | 36 | ReplaceStmt(Exp, CE); |
2700 | 36 | return CE; |
2701 | 36 | } |
2702 | | |
2703 | 5 | Stmt *RewriteModernObjC::RewriteObjCArrayLiteralExpr(ObjCArrayLiteral *Exp) { |
2704 | | // synthesize declaration of helper functions needed in this routine. |
2705 | 5 | if (!SelGetUidFunctionDecl) |
2706 | 0 | SynthSelGetUidFunctionDecl(); |
2707 | | // use objc_msgSend() for all. |
2708 | 5 | if (!MsgSendFunctionDecl) |
2709 | 0 | SynthMsgSendFunctionDecl(); |
2710 | 5 | if (!GetClassFunctionDecl) |
2711 | 0 | SynthGetClassFunctionDecl(); |
2712 | | |
2713 | 5 | FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl; |
2714 | 5 | SourceLocation StartLoc = Exp->getBeginLoc(); |
2715 | 5 | SourceLocation EndLoc = Exp->getEndLoc(); |
2716 | | |
2717 | | // Build the expression: __NSContainer_literal(int, ...).arr |
2718 | 5 | QualType IntQT = Context->IntTy; |
2719 | 5 | QualType NSArrayFType = |
2720 | 5 | getSimpleFunctionType(Context->VoidTy, IntQT, true); |
2721 | 5 | std::string NSArrayFName("__NSContainer_literal"); |
2722 | 5 | FunctionDecl *NSArrayFD = SynthBlockInitFunctionDecl(NSArrayFName); |
2723 | 5 | DeclRefExpr *NSArrayDRE = new (Context) DeclRefExpr( |
2724 | 5 | *Context, NSArrayFD, false, NSArrayFType, VK_PRValue, SourceLocation()); |
2725 | | |
2726 | 5 | SmallVector<Expr*, 16> InitExprs; |
2727 | 5 | unsigned NumElements = Exp->getNumElements(); |
2728 | 5 | unsigned UnsignedIntSize = |
2729 | 5 | static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy)); |
2730 | 5 | Expr *count = IntegerLiteral::Create(*Context, |
2731 | 5 | llvm::APInt(UnsignedIntSize, NumElements), |
2732 | 5 | Context->UnsignedIntTy, SourceLocation()); |
2733 | 5 | InitExprs.push_back(count); |
2734 | 18 | for (unsigned i = 0; i < NumElements; i++13 ) |
2735 | 13 | InitExprs.push_back(Exp->getElement(i)); |
2736 | 5 | Expr *NSArrayCallExpr = |
2737 | 5 | CallExpr::Create(*Context, NSArrayDRE, InitExprs, NSArrayFType, VK_LValue, |
2738 | 5 | SourceLocation(), FPOptionsOverride()); |
2739 | | |
2740 | 5 | FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
2741 | 5 | SourceLocation(), |
2742 | 5 | &Context->Idents.get("arr"), |
2743 | 5 | Context->getPointerType(Context->VoidPtrTy), |
2744 | 5 | nullptr, /*BitWidth=*/nullptr, |
2745 | 5 | /*Mutable=*/true, ICIS_NoInit); |
2746 | 5 | MemberExpr *ArrayLiteralME = |
2747 | 5 | MemberExpr::CreateImplicit(*Context, NSArrayCallExpr, false, ARRFD, |
2748 | 5 | ARRFD->getType(), VK_LValue, OK_Ordinary); |
2749 | 5 | QualType ConstIdT = Context->getObjCIdType().withConst(); |
2750 | 5 | CStyleCastExpr * ArrayLiteralObjects = |
2751 | 5 | NoTypeInfoCStyleCastExpr(Context, |
2752 | 5 | Context->getPointerType(ConstIdT), |
2753 | 5 | CK_BitCast, |
2754 | 5 | ArrayLiteralME); |
2755 | | |
2756 | | // Synthesize a call to objc_msgSend(). |
2757 | 5 | SmallVector<Expr*, 32> MsgExprs; |
2758 | 5 | SmallVector<Expr*, 4> ClsExprs; |
2759 | 5 | QualType expType = Exp->getType(); |
2760 | | |
2761 | | // Create a call to objc_getClass("NSArray"). It will be th 1st argument. |
2762 | 5 | ObjCInterfaceDecl *Class = |
2763 | 5 | expType->getPointeeType()->castAs<ObjCObjectType>()->getInterface(); |
2764 | | |
2765 | 5 | IdentifierInfo *clsName = Class->getIdentifier(); |
2766 | 5 | ClsExprs.push_back(getStringLiteral(clsName->getName())); |
2767 | 5 | CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs, |
2768 | 5 | StartLoc, EndLoc); |
2769 | 5 | MsgExprs.push_back(Cls); |
2770 | | |
2771 | | // Create a call to sel_registerName("arrayWithObjects:count:"). |
2772 | | // it will be the 2nd argument. |
2773 | 5 | SmallVector<Expr*, 4> SelExprs; |
2774 | 5 | ObjCMethodDecl *ArrayMethod = Exp->getArrayWithObjectsMethod(); |
2775 | 5 | SelExprs.push_back( |
2776 | 5 | getStringLiteral(ArrayMethod->getSelector().getAsString())); |
2777 | 5 | CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl, |
2778 | 5 | SelExprs, StartLoc, EndLoc); |
2779 | 5 | MsgExprs.push_back(SelExp); |
2780 | | |
2781 | | // (const id [])objects |
2782 | 5 | MsgExprs.push_back(ArrayLiteralObjects); |
2783 | | |
2784 | | // (NSUInteger)cnt |
2785 | 5 | Expr *cnt = IntegerLiteral::Create(*Context, |
2786 | 5 | llvm::APInt(UnsignedIntSize, NumElements), |
2787 | 5 | Context->UnsignedIntTy, SourceLocation()); |
2788 | 5 | MsgExprs.push_back(cnt); |
2789 | | |
2790 | 5 | SmallVector<QualType, 4> ArgTypes; |
2791 | 5 | ArgTypes.push_back(Context->getObjCClassType()); |
2792 | 5 | ArgTypes.push_back(Context->getObjCSelType()); |
2793 | 5 | for (const auto *PI : ArrayMethod->parameters()) |
2794 | 10 | ArgTypes.push_back(PI->getType()); |
2795 | | |
2796 | 5 | QualType returnType = Exp->getType(); |
2797 | | // Get the type, we will need to reference it in a couple spots. |
2798 | 5 | QualType msgSendType = MsgSendFlavor->getType(); |
2799 | | |
2800 | | // Create a reference to the objc_msgSend() declaration. |
2801 | 5 | DeclRefExpr *DRE = new (Context) DeclRefExpr( |
2802 | 5 | *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation()); |
2803 | | |
2804 | 5 | CastExpr *cast = NoTypeInfoCStyleCastExpr( |
2805 | 5 | Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE); |
2806 | | |
2807 | | // Now do the "normal" pointer to function cast. |
2808 | 5 | QualType castType = |
2809 | 5 | getSimpleFunctionType(returnType, ArgTypes, ArrayMethod->isVariadic()); |
2810 | 5 | castType = Context->getPointerType(castType); |
2811 | 5 | cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast, |
2812 | 5 | cast); |
2813 | | |
2814 | | // Don't forget the parens to enforce the proper binding. |
2815 | 5 | ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast); |
2816 | | |
2817 | 5 | const FunctionType *FT = msgSendType->castAs<FunctionType>(); |
2818 | 5 | CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), |
2819 | 5 | VK_PRValue, EndLoc, FPOptionsOverride()); |
2820 | 5 | ReplaceStmt(Exp, CE); |
2821 | 5 | return CE; |
2822 | 5 | } |
2823 | | |
2824 | 2 | Stmt *RewriteModernObjC::RewriteObjCDictionaryLiteralExpr(ObjCDictionaryLiteral *Exp) { |
2825 | | // synthesize declaration of helper functions needed in this routine. |
2826 | 2 | if (!SelGetUidFunctionDecl) |
2827 | 0 | SynthSelGetUidFunctionDecl(); |
2828 | | // use objc_msgSend() for all. |
2829 | 2 | if (!MsgSendFunctionDecl) |
2830 | 0 | SynthMsgSendFunctionDecl(); |
2831 | 2 | if (!GetClassFunctionDecl) |
2832 | 0 | SynthGetClassFunctionDecl(); |
2833 | | |
2834 | 2 | FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl; |
2835 | 2 | SourceLocation StartLoc = Exp->getBeginLoc(); |
2836 | 2 | SourceLocation EndLoc = Exp->getEndLoc(); |
2837 | | |
2838 | | // Build the expression: __NSContainer_literal(int, ...).arr |
2839 | 2 | QualType IntQT = Context->IntTy; |
2840 | 2 | QualType NSDictFType = |
2841 | 2 | getSimpleFunctionType(Context->VoidTy, IntQT, true); |
2842 | 2 | std::string NSDictFName("__NSContainer_literal"); |
2843 | 2 | FunctionDecl *NSDictFD = SynthBlockInitFunctionDecl(NSDictFName); |
2844 | 2 | DeclRefExpr *NSDictDRE = new (Context) DeclRefExpr( |
2845 | 2 | *Context, NSDictFD, false, NSDictFType, VK_PRValue, SourceLocation()); |
2846 | | |
2847 | 2 | SmallVector<Expr*, 16> KeyExprs; |
2848 | 2 | SmallVector<Expr*, 16> ValueExprs; |
2849 | | |
2850 | 2 | unsigned NumElements = Exp->getNumElements(); |
2851 | 2 | unsigned UnsignedIntSize = |
2852 | 2 | static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy)); |
2853 | 2 | Expr *count = IntegerLiteral::Create(*Context, |
2854 | 2 | llvm::APInt(UnsignedIntSize, NumElements), |
2855 | 2 | Context->UnsignedIntTy, SourceLocation()); |
2856 | 2 | KeyExprs.push_back(count); |
2857 | 2 | ValueExprs.push_back(count); |
2858 | 8 | for (unsigned i = 0; i < NumElements; i++6 ) { |
2859 | 6 | ObjCDictionaryElement Element = Exp->getKeyValueElement(i); |
2860 | 6 | KeyExprs.push_back(Element.Key); |
2861 | 6 | ValueExprs.push_back(Element.Value); |
2862 | 6 | } |
2863 | | |
2864 | | // (const id [])objects |
2865 | 2 | Expr *NSValueCallExpr = |
2866 | 2 | CallExpr::Create(*Context, NSDictDRE, ValueExprs, NSDictFType, VK_LValue, |
2867 | 2 | SourceLocation(), FPOptionsOverride()); |
2868 | | |
2869 | 2 | FieldDecl *ARRFD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
2870 | 2 | SourceLocation(), |
2871 | 2 | &Context->Idents.get("arr"), |
2872 | 2 | Context->getPointerType(Context->VoidPtrTy), |
2873 | 2 | nullptr, /*BitWidth=*/nullptr, |
2874 | 2 | /*Mutable=*/true, ICIS_NoInit); |
2875 | 2 | MemberExpr *DictLiteralValueME = |
2876 | 2 | MemberExpr::CreateImplicit(*Context, NSValueCallExpr, false, ARRFD, |
2877 | 2 | ARRFD->getType(), VK_LValue, OK_Ordinary); |
2878 | 2 | QualType ConstIdT = Context->getObjCIdType().withConst(); |
2879 | 2 | CStyleCastExpr * DictValueObjects = |
2880 | 2 | NoTypeInfoCStyleCastExpr(Context, |
2881 | 2 | Context->getPointerType(ConstIdT), |
2882 | 2 | CK_BitCast, |
2883 | 2 | DictLiteralValueME); |
2884 | | // (const id <NSCopying> [])keys |
2885 | 2 | Expr *NSKeyCallExpr = |
2886 | 2 | CallExpr::Create(*Context, NSDictDRE, KeyExprs, NSDictFType, VK_LValue, |
2887 | 2 | SourceLocation(), FPOptionsOverride()); |
2888 | | |
2889 | 2 | MemberExpr *DictLiteralKeyME = |
2890 | 2 | MemberExpr::CreateImplicit(*Context, NSKeyCallExpr, false, ARRFD, |
2891 | 2 | ARRFD->getType(), VK_LValue, OK_Ordinary); |
2892 | | |
2893 | 2 | CStyleCastExpr * DictKeyObjects = |
2894 | 2 | NoTypeInfoCStyleCastExpr(Context, |
2895 | 2 | Context->getPointerType(ConstIdT), |
2896 | 2 | CK_BitCast, |
2897 | 2 | DictLiteralKeyME); |
2898 | | |
2899 | | // Synthesize a call to objc_msgSend(). |
2900 | 2 | SmallVector<Expr*, 32> MsgExprs; |
2901 | 2 | SmallVector<Expr*, 4> ClsExprs; |
2902 | 2 | QualType expType = Exp->getType(); |
2903 | | |
2904 | | // Create a call to objc_getClass("NSArray"). It will be th 1st argument. |
2905 | 2 | ObjCInterfaceDecl *Class = |
2906 | 2 | expType->getPointeeType()->castAs<ObjCObjectType>()->getInterface(); |
2907 | | |
2908 | 2 | IdentifierInfo *clsName = Class->getIdentifier(); |
2909 | 2 | ClsExprs.push_back(getStringLiteral(clsName->getName())); |
2910 | 2 | CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs, |
2911 | 2 | StartLoc, EndLoc); |
2912 | 2 | MsgExprs.push_back(Cls); |
2913 | | |
2914 | | // Create a call to sel_registerName("arrayWithObjects:count:"). |
2915 | | // it will be the 2nd argument. |
2916 | 2 | SmallVector<Expr*, 4> SelExprs; |
2917 | 2 | ObjCMethodDecl *DictMethod = Exp->getDictWithObjectsMethod(); |
2918 | 2 | SelExprs.push_back(getStringLiteral(DictMethod->getSelector().getAsString())); |
2919 | 2 | CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl, |
2920 | 2 | SelExprs, StartLoc, EndLoc); |
2921 | 2 | MsgExprs.push_back(SelExp); |
2922 | | |
2923 | | // (const id [])objects |
2924 | 2 | MsgExprs.push_back(DictValueObjects); |
2925 | | |
2926 | | // (const id <NSCopying> [])keys |
2927 | 2 | MsgExprs.push_back(DictKeyObjects); |
2928 | | |
2929 | | // (NSUInteger)cnt |
2930 | 2 | Expr *cnt = IntegerLiteral::Create(*Context, |
2931 | 2 | llvm::APInt(UnsignedIntSize, NumElements), |
2932 | 2 | Context->UnsignedIntTy, SourceLocation()); |
2933 | 2 | MsgExprs.push_back(cnt); |
2934 | | |
2935 | 2 | SmallVector<QualType, 8> ArgTypes; |
2936 | 2 | ArgTypes.push_back(Context->getObjCClassType()); |
2937 | 2 | ArgTypes.push_back(Context->getObjCSelType()); |
2938 | 6 | for (const auto *PI : DictMethod->parameters()) { |
2939 | 6 | QualType T = PI->getType(); |
2940 | 6 | if (const PointerType* PT = T->getAs<PointerType>()) { |
2941 | 4 | QualType PointeeTy = PT->getPointeeType(); |
2942 | 4 | convertToUnqualifiedObjCType(PointeeTy); |
2943 | 4 | T = Context->getPointerType(PointeeTy); |
2944 | 4 | } |
2945 | 6 | ArgTypes.push_back(T); |
2946 | 6 | } |
2947 | | |
2948 | 2 | QualType returnType = Exp->getType(); |
2949 | | // Get the type, we will need to reference it in a couple spots. |
2950 | 2 | QualType msgSendType = MsgSendFlavor->getType(); |
2951 | | |
2952 | | // Create a reference to the objc_msgSend() declaration. |
2953 | 2 | DeclRefExpr *DRE = new (Context) DeclRefExpr( |
2954 | 2 | *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation()); |
2955 | | |
2956 | 2 | CastExpr *cast = NoTypeInfoCStyleCastExpr( |
2957 | 2 | Context, Context->getPointerType(Context->VoidTy), CK_BitCast, DRE); |
2958 | | |
2959 | | // Now do the "normal" pointer to function cast. |
2960 | 2 | QualType castType = |
2961 | 2 | getSimpleFunctionType(returnType, ArgTypes, DictMethod->isVariadic()); |
2962 | 2 | castType = Context->getPointerType(castType); |
2963 | 2 | cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast, |
2964 | 2 | cast); |
2965 | | |
2966 | | // Don't forget the parens to enforce the proper binding. |
2967 | 2 | ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast); |
2968 | | |
2969 | 2 | const FunctionType *FT = msgSendType->castAs<FunctionType>(); |
2970 | 2 | CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), |
2971 | 2 | VK_PRValue, EndLoc, FPOptionsOverride()); |
2972 | 2 | ReplaceStmt(Exp, CE); |
2973 | 2 | return CE; |
2974 | 2 | } |
2975 | | |
2976 | | // struct __rw_objc_super { |
2977 | | // struct objc_object *object; struct objc_object *superClass; |
2978 | | // }; |
2979 | 2 | QualType RewriteModernObjC::getSuperStructType() { |
2980 | 2 | if (!SuperStructDecl) { |
2981 | 1 | SuperStructDecl = RecordDecl::Create( |
2982 | 1 | *Context, TagTypeKind::Struct, TUDecl, SourceLocation(), |
2983 | 1 | SourceLocation(), &Context->Idents.get("__rw_objc_super")); |
2984 | 1 | QualType FieldTypes[2]; |
2985 | | |
2986 | | // struct objc_object *object; |
2987 | 1 | FieldTypes[0] = Context->getObjCIdType(); |
2988 | | // struct objc_object *superClass; |
2989 | 1 | FieldTypes[1] = Context->getObjCIdType(); |
2990 | | |
2991 | | // Create fields |
2992 | 3 | for (unsigned i = 0; i < 2; ++i2 ) { |
2993 | 2 | SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl, |
2994 | 2 | SourceLocation(), |
2995 | 2 | SourceLocation(), nullptr, |
2996 | 2 | FieldTypes[i], nullptr, |
2997 | 2 | /*BitWidth=*/nullptr, |
2998 | 2 | /*Mutable=*/false, |
2999 | 2 | ICIS_NoInit)); |
3000 | 2 | } |
3001 | | |
3002 | 1 | SuperStructDecl->completeDefinition(); |
3003 | 1 | } |
3004 | 2 | return Context->getTagDeclType(SuperStructDecl); |
3005 | 2 | } |
3006 | | |
3007 | 13 | QualType RewriteModernObjC::getConstantStringStructType() { |
3008 | 13 | if (!ConstantStringDecl) { |
3009 | 3 | ConstantStringDecl = RecordDecl::Create( |
3010 | 3 | *Context, TagTypeKind::Struct, TUDecl, SourceLocation(), |
3011 | 3 | SourceLocation(), &Context->Idents.get("__NSConstantStringImpl")); |
3012 | 3 | QualType FieldTypes[4]; |
3013 | | |
3014 | | // struct objc_object *receiver; |
3015 | 3 | FieldTypes[0] = Context->getObjCIdType(); |
3016 | | // int flags; |
3017 | 3 | FieldTypes[1] = Context->IntTy; |
3018 | | // char *str; |
3019 | 3 | FieldTypes[2] = Context->getPointerType(Context->CharTy); |
3020 | | // long length; |
3021 | 3 | FieldTypes[3] = Context->LongTy; |
3022 | | |
3023 | | // Create fields |
3024 | 15 | for (unsigned i = 0; i < 4; ++i12 ) { |
3025 | 12 | ConstantStringDecl->addDecl(FieldDecl::Create(*Context, |
3026 | 12 | ConstantStringDecl, |
3027 | 12 | SourceLocation(), |
3028 | 12 | SourceLocation(), nullptr, |
3029 | 12 | FieldTypes[i], nullptr, |
3030 | 12 | /*BitWidth=*/nullptr, |
3031 | 12 | /*Mutable=*/true, |
3032 | 12 | ICIS_NoInit)); |
3033 | 12 | } |
3034 | | |
3035 | 3 | ConstantStringDecl->completeDefinition(); |
3036 | 3 | } |
3037 | 13 | return Context->getTagDeclType(ConstantStringDecl); |
3038 | 13 | } |
3039 | | |
3040 | | /// getFunctionSourceLocation - returns start location of a function |
3041 | | /// definition. Complication arises when function has declared as |
3042 | | /// extern "C" or extern "C" {...} |
3043 | | static SourceLocation getFunctionSourceLocation (RewriteModernObjC &R, |
3044 | 75 | FunctionDecl *FD) { |
3045 | 75 | if (FD->isExternC() && !FD->isMain()16 ) { |
3046 | 16 | const DeclContext *DC = FD->getDeclContext(); |
3047 | 16 | if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC)) |
3048 | | // if it is extern "C" {...}, return function decl's own location. |
3049 | 12 | if (!LSD->getRBraceLoc().isValid()) |
3050 | 4 | return LSD->getExternLoc(); |
3051 | 16 | } |
3052 | 71 | if (FD->getStorageClass() != SC_None) |
3053 | 5 | R.RewriteBlockLiteralFunctionDecl(FD); |
3054 | 71 | return FD->getTypeSpecStartLoc(); |
3055 | 75 | } |
3056 | | |
3057 | 162 | void RewriteModernObjC::RewriteLineDirective(const Decl *D) { |
3058 | | |
3059 | 162 | SourceLocation Location = D->getLocation(); |
3060 | | |
3061 | 162 | if (Location.isFileID() && GenerateLineInfo) { |
3062 | 3 | std::string LineString("\n#line "); |
3063 | 3 | PresumedLoc PLoc = SM->getPresumedLoc(Location); |
3064 | 3 | LineString += utostr(PLoc.getLine()); |
3065 | 3 | LineString += " \""; |
3066 | 3 | LineString += Lexer::Stringify(PLoc.getFilename()); |
3067 | 3 | if (isa<ObjCMethodDecl>(D)) |
3068 | 1 | LineString += "\""; |
3069 | 2 | else LineString += "\"\n"; |
3070 | | |
3071 | 3 | Location = D->getBeginLoc(); |
3072 | 3 | if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { |
3073 | 2 | if (FD->isExternC() && !FD->isMain()0 ) { |
3074 | 0 | const DeclContext *DC = FD->getDeclContext(); |
3075 | 0 | if (const LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(DC)) |
3076 | | // if it is extern "C" {...}, return function decl's own location. |
3077 | 0 | if (!LSD->getRBraceLoc().isValid()) |
3078 | 0 | Location = LSD->getExternLoc(); |
3079 | 0 | } |
3080 | 2 | } |
3081 | 3 | InsertText(Location, LineString); |
3082 | 3 | } |
3083 | 162 | } |
3084 | | |
3085 | | /// SynthMsgSendStretCallExpr - This routine translates message expression |
3086 | | /// into a call to objc_msgSend_stret() entry point. Tricky part is that |
3087 | | /// nil check on receiver must be performed before calling objc_msgSend_stret. |
3088 | | /// MsgSendStretFlavor - function declaration objc_msgSend_stret(...) |
3089 | | /// msgSendType - function type of objc_msgSend_stret(...) |
3090 | | /// returnType - Result type of the method being synthesized. |
3091 | | /// ArgTypes - type of the arguments passed to objc_msgSend_stret, starting with receiver type. |
3092 | | /// MsgExprs - list of argument expressions being passed to objc_msgSend_stret, |
3093 | | /// starting with receiver. |
3094 | | /// Method - Method being rewritten. |
3095 | | Expr *RewriteModernObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor, |
3096 | | QualType returnType, |
3097 | | SmallVectorImpl<QualType> &ArgTypes, |
3098 | | SmallVectorImpl<Expr*> &MsgExprs, |
3099 | 12 | ObjCMethodDecl *Method) { |
3100 | | // Now do the "normal" pointer to function cast. |
3101 | 12 | QualType FuncType = getSimpleFunctionType( |
3102 | 12 | returnType, ArgTypes, Method ? Method->isVariadic() : false0 ); |
3103 | 12 | QualType castType = Context->getPointerType(FuncType); |
3104 | | |
3105 | | // build type for containing the objc_msgSend_stret object. |
3106 | 12 | static unsigned stretCount=0; |
3107 | 12 | std::string name = "__Stret"; name += utostr(stretCount); |
3108 | 12 | std::string str = |
3109 | 12 | "extern \"C\" void * __cdecl memset(void *_Dst, int _Val, size_t _Size);\n"; |
3110 | 12 | str += "namespace {\n"; |
3111 | 12 | str += "struct "; str += name; |
3112 | 12 | str += " {\n\t"; |
3113 | 12 | str += name; |
3114 | 12 | str += "(id receiver, SEL sel"; |
3115 | 22 | for (unsigned i = 2; i < ArgTypes.size(); i++10 ) { |
3116 | 10 | std::string ArgName = "arg"; ArgName += utostr(i); |
3117 | 10 | ArgTypes[i].getAsStringInternal(ArgName, Context->getPrintingPolicy()); |
3118 | 10 | str += ", "; str += ArgName; |
3119 | 10 | } |
3120 | | // could be vararg. |
3121 | 19 | for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++7 ) { |
3122 | 7 | std::string ArgName = "arg"; ArgName += utostr(i); |
3123 | 7 | MsgExprs[i]->getType().getAsStringInternal(ArgName, |
3124 | 7 | Context->getPrintingPolicy()); |
3125 | 7 | str += ", "; str += ArgName; |
3126 | 7 | } |
3127 | | |
3128 | 12 | str += ") {\n"; |
3129 | 12 | str += "\t unsigned size = sizeof("; |
3130 | 12 | str += returnType.getAsString(Context->getPrintingPolicy()); str += ");\n"; |
3131 | | |
3132 | 12 | str += "\t if (size == 1 || size == 2 || size == 4 || size == 8)\n"; |
3133 | | |
3134 | 12 | str += "\t s = (("; str += castType.getAsString(Context->getPrintingPolicy()); |
3135 | 12 | str += ")(void *)objc_msgSend)(receiver, sel"; |
3136 | 22 | for (unsigned i = 2; i < ArgTypes.size(); i++10 ) { |
3137 | 10 | str += ", arg"; str += utostr(i); |
3138 | 10 | } |
3139 | | // could be vararg. |
3140 | 19 | for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++7 ) { |
3141 | 7 | str += ", arg"; str += utostr(i); |
3142 | 7 | } |
3143 | 12 | str+= ");\n"; |
3144 | | |
3145 | 12 | str += "\t else if (receiver == 0)\n"; |
3146 | 12 | str += "\t memset((void*)&s, 0, sizeof(s));\n"; |
3147 | 12 | str += "\t else\n"; |
3148 | | |
3149 | 12 | str += "\t s = (("; str += castType.getAsString(Context->getPrintingPolicy()); |
3150 | 12 | str += ")(void *)objc_msgSend_stret)(receiver, sel"; |
3151 | 22 | for (unsigned i = 2; i < ArgTypes.size(); i++10 ) { |
3152 | 10 | str += ", arg"; str += utostr(i); |
3153 | 10 | } |
3154 | | // could be vararg. |
3155 | 19 | for (unsigned i = ArgTypes.size(); i < MsgExprs.size(); i++7 ) { |
3156 | 7 | str += ", arg"; str += utostr(i); |
3157 | 7 | } |
3158 | 12 | str += ");\n"; |
3159 | | |
3160 | 12 | str += "\t}\n"; |
3161 | 12 | str += "\t"; str += returnType.getAsString(Context->getPrintingPolicy()); |
3162 | 12 | str += " s;\n"; |
3163 | 12 | str += "};\n};\n\n"; |
3164 | 12 | SourceLocation FunLocStart; |
3165 | 12 | if (CurFunctionDef) |
3166 | 11 | FunLocStart = getFunctionSourceLocation(*this, CurFunctionDef); |
3167 | 1 | else { |
3168 | 1 | assert(CurMethodDef && "SynthMsgSendStretCallExpr - CurMethodDef is null"); |
3169 | 1 | FunLocStart = CurMethodDef->getBeginLoc(); |
3170 | 1 | } |
3171 | | |
3172 | 12 | InsertText(FunLocStart, str); |
3173 | 12 | ++stretCount; |
3174 | | |
3175 | | // AST for __Stretn(receiver, args).s; |
3176 | 12 | IdentifierInfo *ID = &Context->Idents.get(name); |
3177 | 12 | FunctionDecl *FD = |
3178 | 12 | FunctionDecl::Create(*Context, TUDecl, SourceLocation(), SourceLocation(), |
3179 | 12 | ID, FuncType, nullptr, SC_Extern, false, false); |
3180 | 12 | DeclRefExpr *DRE = new (Context) |
3181 | 12 | DeclRefExpr(*Context, FD, false, castType, VK_PRValue, SourceLocation()); |
3182 | 12 | CallExpr *STCE = |
3183 | 12 | CallExpr::Create(*Context, DRE, MsgExprs, castType, VK_LValue, |
3184 | 12 | SourceLocation(), FPOptionsOverride()); |
3185 | | |
3186 | 12 | FieldDecl *FieldD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
3187 | 12 | SourceLocation(), |
3188 | 12 | &Context->Idents.get("s"), |
3189 | 12 | returnType, nullptr, |
3190 | 12 | /*BitWidth=*/nullptr, |
3191 | 12 | /*Mutable=*/true, ICIS_NoInit); |
3192 | 12 | MemberExpr *ME = MemberExpr::CreateImplicit( |
3193 | 12 | *Context, STCE, false, FieldD, FieldD->getType(), VK_LValue, OK_Ordinary); |
3194 | | |
3195 | 12 | return ME; |
3196 | 12 | } |
3197 | | |
3198 | | Stmt *RewriteModernObjC::SynthMessageExpr(ObjCMessageExpr *Exp, |
3199 | | SourceLocation StartLoc, |
3200 | 104 | SourceLocation EndLoc) { |
3201 | 104 | if (!SelGetUidFunctionDecl) |
3202 | 3 | SynthSelGetUidFunctionDecl(); |
3203 | 104 | if (!MsgSendFunctionDecl) |
3204 | 25 | SynthMsgSendFunctionDecl(); |
3205 | 104 | if (!MsgSendSuperFunctionDecl) |
3206 | 25 | SynthMsgSendSuperFunctionDecl(); |
3207 | 104 | if (!MsgSendStretFunctionDecl) |
3208 | 25 | SynthMsgSendStretFunctionDecl(); |
3209 | 104 | if (!MsgSendSuperStretFunctionDecl) |
3210 | 25 | SynthMsgSendSuperStretFunctionDecl(); |
3211 | 104 | if (!MsgSendFpretFunctionDecl) |
3212 | 25 | SynthMsgSendFpretFunctionDecl(); |
3213 | 104 | if (!GetClassFunctionDecl) |
3214 | 25 | SynthGetClassFunctionDecl(); |
3215 | 104 | if (!GetSuperClassFunctionDecl) |
3216 | 25 | SynthGetSuperClassFunctionDecl(); |
3217 | 104 | if (!GetMetaClassFunctionDecl) |
3218 | 25 | SynthGetMetaClassFunctionDecl(); |
3219 | | |
3220 | | // default to objc_msgSend(). |
3221 | 104 | FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl; |
3222 | | // May need to use objc_msgSend_stret() as well. |
3223 | 104 | FunctionDecl *MsgSendStretFlavor = nullptr; |
3224 | 104 | if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) { |
3225 | 98 | QualType resultType = mDecl->getReturnType(); |
3226 | 98 | if (resultType->isRecordType()) |
3227 | 12 | MsgSendStretFlavor = MsgSendStretFunctionDecl; |
3228 | 86 | else if (resultType->isRealFloatingType()) |
3229 | 0 | MsgSendFlavor = MsgSendFpretFunctionDecl; |
3230 | 98 | } |
3231 | | |
3232 | | // Synthesize a call to objc_msgSend(). |
3233 | 104 | SmallVector<Expr*, 8> MsgExprs; |
3234 | 104 | switch (Exp->getReceiverKind()) { |
3235 | 0 | case ObjCMessageExpr::SuperClass: { |
3236 | 0 | MsgSendFlavor = MsgSendSuperFunctionDecl; |
3237 | 0 | if (MsgSendStretFlavor) |
3238 | 0 | MsgSendStretFlavor = MsgSendSuperStretFunctionDecl; |
3239 | 0 | assert(MsgSendFlavor && "MsgSendFlavor is NULL!"); |
3240 | | |
3241 | 0 | ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface(); |
3242 | |
|
3243 | 0 | SmallVector<Expr*, 4> InitExprs; |
3244 | | |
3245 | | // set the receiver to self, the first argument to all methods. |
3246 | 0 | InitExprs.push_back(NoTypeInfoCStyleCastExpr( |
3247 | 0 | Context, Context->getObjCIdType(), CK_BitCast, |
3248 | 0 | new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false, |
3249 | 0 | Context->getObjCIdType(), VK_PRValue, |
3250 | 0 | SourceLocation()))); // set the 'receiver'. |
3251 | | |
3252 | | // (id)class_getSuperclass((Class)objc_getClass("CurrentClass")) |
3253 | 0 | SmallVector<Expr*, 8> ClsExprs; |
3254 | 0 | ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName())); |
3255 | | // (Class)objc_getClass("CurrentClass") |
3256 | 0 | CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl, |
3257 | 0 | ClsExprs, StartLoc, EndLoc); |
3258 | 0 | ClsExprs.clear(); |
3259 | 0 | ClsExprs.push_back(Cls); |
3260 | 0 | Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs, |
3261 | 0 | StartLoc, EndLoc); |
3262 | | |
3263 | | // (id)class_getSuperclass((Class)objc_getClass("CurrentClass")) |
3264 | | // To turn off a warning, type-cast to 'id' |
3265 | 0 | InitExprs.push_back( // set 'super class', using class_getSuperclass(). |
3266 | 0 | NoTypeInfoCStyleCastExpr(Context, |
3267 | 0 | Context->getObjCIdType(), |
3268 | 0 | CK_BitCast, Cls)); |
3269 | | // struct __rw_objc_super |
3270 | 0 | QualType superType = getSuperStructType(); |
3271 | 0 | Expr *SuperRep; |
3272 | |
|
3273 | 0 | if (LangOpts.MicrosoftExt) { |
3274 | 0 | SynthSuperConstructorFunctionDecl(); |
3275 | | // Simulate a constructor call... |
3276 | 0 | DeclRefExpr *DRE = new (Context) |
3277 | 0 | DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType, |
3278 | 0 | VK_LValue, SourceLocation()); |
3279 | 0 | SuperRep = |
3280 | 0 | CallExpr::Create(*Context, DRE, InitExprs, superType, VK_LValue, |
3281 | 0 | SourceLocation(), FPOptionsOverride()); |
3282 | | // The code for super is a little tricky to prevent collision with |
3283 | | // the structure definition in the header. The rewriter has it's own |
3284 | | // internal definition (__rw_objc_super) that is uses. This is why |
3285 | | // we need the cast below. For example: |
3286 | | // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER")) |
3287 | | // |
3288 | 0 | SuperRep = UnaryOperator::Create( |
3289 | 0 | const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf, |
3290 | 0 | Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary, |
3291 | 0 | SourceLocation(), false, FPOptionsOverride()); |
3292 | 0 | SuperRep = NoTypeInfoCStyleCastExpr(Context, |
3293 | 0 | Context->getPointerType(superType), |
3294 | 0 | CK_BitCast, SuperRep); |
3295 | 0 | } else { |
3296 | | // (struct __rw_objc_super) { <exprs from above> } |
3297 | 0 | InitListExpr *ILE = |
3298 | 0 | new (Context) InitListExpr(*Context, SourceLocation(), InitExprs, |
3299 | 0 | SourceLocation()); |
3300 | 0 | TypeSourceInfo *superTInfo |
3301 | 0 | = Context->getTrivialTypeSourceInfo(superType); |
3302 | 0 | SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo, |
3303 | 0 | superType, VK_LValue, |
3304 | 0 | ILE, false); |
3305 | | // struct __rw_objc_super * |
3306 | 0 | SuperRep = UnaryOperator::Create( |
3307 | 0 | const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf, |
3308 | 0 | Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary, |
3309 | 0 | SourceLocation(), false, FPOptionsOverride()); |
3310 | 0 | } |
3311 | 0 | MsgExprs.push_back(SuperRep); |
3312 | 0 | break; |
3313 | 0 | } |
3314 | | |
3315 | 23 | case ObjCMessageExpr::Class: { |
3316 | 23 | SmallVector<Expr*, 8> ClsExprs; |
3317 | 23 | ObjCInterfaceDecl *Class |
3318 | 23 | = Exp->getClassReceiver()->castAs<ObjCObjectType>()->getInterface(); |
3319 | 23 | IdentifierInfo *clsName = Class->getIdentifier(); |
3320 | 23 | ClsExprs.push_back(getStringLiteral(clsName->getName())); |
3321 | 23 | CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs, |
3322 | 23 | StartLoc, EndLoc); |
3323 | 23 | CastExpr *ArgExpr = NoTypeInfoCStyleCastExpr(Context, |
3324 | 23 | Context->getObjCIdType(), |
3325 | 23 | CK_BitCast, Cls); |
3326 | 23 | MsgExprs.push_back(ArgExpr); |
3327 | 23 | break; |
3328 | 0 | } |
3329 | | |
3330 | 1 | case ObjCMessageExpr::SuperInstance:{ |
3331 | 1 | MsgSendFlavor = MsgSendSuperFunctionDecl; |
3332 | 1 | if (MsgSendStretFlavor) |
3333 | 0 | MsgSendStretFlavor = MsgSendSuperStretFunctionDecl; |
3334 | 1 | assert(MsgSendFlavor && "MsgSendFlavor is NULL!"); |
3335 | 1 | ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface(); |
3336 | 1 | SmallVector<Expr*, 4> InitExprs; |
3337 | | |
3338 | 1 | InitExprs.push_back(NoTypeInfoCStyleCastExpr( |
3339 | 1 | Context, Context->getObjCIdType(), CK_BitCast, |
3340 | 1 | new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false, |
3341 | 1 | Context->getObjCIdType(), VK_PRValue, |
3342 | 1 | SourceLocation()))); // set the 'receiver'. |
3343 | | |
3344 | | // (id)class_getSuperclass((Class)objc_getClass("CurrentClass")) |
3345 | 1 | SmallVector<Expr*, 8> ClsExprs; |
3346 | 1 | ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName())); |
3347 | | // (Class)objc_getClass("CurrentClass") |
3348 | 1 | CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs, |
3349 | 1 | StartLoc, EndLoc); |
3350 | 1 | ClsExprs.clear(); |
3351 | 1 | ClsExprs.push_back(Cls); |
3352 | 1 | Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs, |
3353 | 1 | StartLoc, EndLoc); |
3354 | | |
3355 | | // (id)class_getSuperclass((Class)objc_getClass("CurrentClass")) |
3356 | | // To turn off a warning, type-cast to 'id' |
3357 | 1 | InitExprs.push_back( |
3358 | | // set 'super class', using class_getSuperclass(). |
3359 | 1 | NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(), |
3360 | 1 | CK_BitCast, Cls)); |
3361 | | // struct __rw_objc_super |
3362 | 1 | QualType superType = getSuperStructType(); |
3363 | 1 | Expr *SuperRep; |
3364 | | |
3365 | 1 | if (LangOpts.MicrosoftExt) { |
3366 | 1 | SynthSuperConstructorFunctionDecl(); |
3367 | | // Simulate a constructor call... |
3368 | 1 | DeclRefExpr *DRE = new (Context) |
3369 | 1 | DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType, |
3370 | 1 | VK_LValue, SourceLocation()); |
3371 | 1 | SuperRep = |
3372 | 1 | CallExpr::Create(*Context, DRE, InitExprs, superType, VK_LValue, |
3373 | 1 | SourceLocation(), FPOptionsOverride()); |
3374 | | // The code for super is a little tricky to prevent collision with |
3375 | | // the structure definition in the header. The rewriter has it's own |
3376 | | // internal definition (__rw_objc_super) that is uses. This is why |
3377 | | // we need the cast below. For example: |
3378 | | // (struct __rw_objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER")) |
3379 | | // |
3380 | 1 | SuperRep = UnaryOperator::Create( |
3381 | 1 | const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf, |
3382 | 1 | Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary, |
3383 | 1 | SourceLocation(), false, FPOptionsOverride()); |
3384 | 1 | SuperRep = NoTypeInfoCStyleCastExpr(Context, |
3385 | 1 | Context->getPointerType(superType), |
3386 | 1 | CK_BitCast, SuperRep); |
3387 | 1 | } else { |
3388 | | // (struct __rw_objc_super) { <exprs from above> } |
3389 | 0 | InitListExpr *ILE = |
3390 | 0 | new (Context) InitListExpr(*Context, SourceLocation(), InitExprs, |
3391 | 0 | SourceLocation()); |
3392 | 0 | TypeSourceInfo *superTInfo |
3393 | 0 | = Context->getTrivialTypeSourceInfo(superType); |
3394 | 0 | SuperRep = new (Context) CompoundLiteralExpr( |
3395 | 0 | SourceLocation(), superTInfo, superType, VK_PRValue, ILE, false); |
3396 | 0 | } |
3397 | 1 | MsgExprs.push_back(SuperRep); |
3398 | 1 | break; |
3399 | 1 | } |
3400 | | |
3401 | 80 | case ObjCMessageExpr::Instance: { |
3402 | | // Remove all type-casts because it may contain objc-style types; e.g. |
3403 | | // Foo<Proto> *. |
3404 | 80 | Expr *recExpr = Exp->getInstanceReceiver(); |
3405 | 81 | while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr)) |
3406 | 1 | recExpr = CE->getSubExpr(); |
3407 | 80 | CastKind CK = recExpr->getType()->isObjCObjectPointerType() |
3408 | 80 | ? CK_BitCast : recExpr->getType()->isBlockPointerType()0 |
3409 | 0 | ? CK_BlockPointerToObjCPointerCast |
3410 | 0 | : CK_CPointerToObjCPointerCast; |
3411 | | |
3412 | 80 | recExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(), |
3413 | 80 | CK, recExpr); |
3414 | 80 | MsgExprs.push_back(recExpr); |
3415 | 80 | break; |
3416 | 1 | } |
3417 | 104 | } |
3418 | | |
3419 | | // Create a call to sel_registerName("selName"), it will be the 2nd argument. |
3420 | 104 | SmallVector<Expr*, 8> SelExprs; |
3421 | 104 | SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString())); |
3422 | 104 | CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl, |
3423 | 104 | SelExprs, StartLoc, EndLoc); |
3424 | 104 | MsgExprs.push_back(SelExp); |
3425 | | |
3426 | | // Now push any user supplied arguments. |
3427 | 158 | for (unsigned i = 0; i < Exp->getNumArgs(); i++54 ) { |
3428 | 54 | Expr *userExpr = Exp->getArg(i); |
3429 | | // Make all implicit casts explicit...ICE comes in handy:-) |
3430 | 54 | if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) { |
3431 | | // Reuse the ICE type, it is exactly what the doctor ordered. |
3432 | 28 | QualType type = ICE->getType(); |
3433 | 28 | if (needToScanForQualifiers(type)) |
3434 | 0 | type = Context->getObjCIdType(); |
3435 | | // Make sure we convert "type (^)(...)" to "type (*)(...)". |
3436 | 28 | (void)convertBlockPointerToFunctionPointer(type); |
3437 | 28 | const Expr *SubExpr = ICE->IgnoreParenImpCasts(); |
3438 | 28 | CastKind CK; |
3439 | 28 | if (SubExpr->getType()->isIntegralType(*Context) && |
3440 | 28 | type->isBooleanType()13 ) { |
3441 | 0 | CK = CK_IntegralToBoolean; |
3442 | 28 | } else if (type->isObjCObjectPointerType()) { |
3443 | 13 | if (SubExpr->getType()->isBlockPointerType()) { |
3444 | 0 | CK = CK_BlockPointerToObjCPointerCast; |
3445 | 13 | } else if (SubExpr->getType()->isPointerType()) { |
3446 | 0 | CK = CK_CPointerToObjCPointerCast; |
3447 | 13 | } else { |
3448 | 13 | CK = CK_BitCast; |
3449 | 13 | } |
3450 | 15 | } else { |
3451 | 15 | CK = CK_BitCast; |
3452 | 15 | } |
3453 | | |
3454 | 28 | userExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, userExpr); |
3455 | 28 | } |
3456 | | // Make id<P...> cast into an 'id' cast. |
3457 | 26 | else if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(userExpr)) { |
3458 | 3 | if (CE->getType()->isObjCQualifiedIdType()) { |
3459 | 0 | while ((CE = dyn_cast<CStyleCastExpr>(userExpr))) |
3460 | 0 | userExpr = CE->getSubExpr(); |
3461 | 0 | CastKind CK; |
3462 | 0 | if (userExpr->getType()->isIntegralType(*Context)) { |
3463 | 0 | CK = CK_IntegralToPointer; |
3464 | 0 | } else if (userExpr->getType()->isBlockPointerType()) { |
3465 | 0 | CK = CK_BlockPointerToObjCPointerCast; |
3466 | 0 | } else if (userExpr->getType()->isPointerType()) { |
3467 | 0 | CK = CK_CPointerToObjCPointerCast; |
3468 | 0 | } else { |
3469 | 0 | CK = CK_BitCast; |
3470 | 0 | } |
3471 | 0 | userExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(), |
3472 | 0 | CK, userExpr); |
3473 | 0 | } |
3474 | 3 | } |
3475 | 54 | MsgExprs.push_back(userExpr); |
3476 | | // We've transferred the ownership to MsgExprs. For now, we *don't* null |
3477 | | // out the argument in the original expression (since we aren't deleting |
3478 | | // the ObjCMessageExpr). See RewritePropertyOrImplicitSetter() usage for more info. |
3479 | | //Exp->setArg(i, 0); |
3480 | 54 | } |
3481 | | // Generate the funky cast. |
3482 | 104 | CastExpr *cast; |
3483 | 104 | SmallVector<QualType, 8> ArgTypes; |
3484 | 104 | QualType returnType; |
3485 | | |
3486 | | // Push 'id' and 'SEL', the 2 implicit arguments. |
3487 | 104 | if (MsgSendFlavor == MsgSendSuperFunctionDecl) |
3488 | 1 | ArgTypes.push_back(Context->getPointerType(getSuperStructType())); |
3489 | 103 | else |
3490 | 103 | ArgTypes.push_back(Context->getObjCIdType()); |
3491 | 104 | ArgTypes.push_back(Context->getObjCSelType()); |
3492 | 104 | if (ObjCMethodDecl *OMD = Exp->getMethodDecl()) { |
3493 | | // Push any user argument types. |
3494 | 98 | for (const auto *PI : OMD->parameters()) { |
3495 | 44 | QualType t = PI->getType()->isObjCQualifiedIdType() |
3496 | 44 | ? Context->getObjCIdType()0 |
3497 | 44 | : PI->getType(); |
3498 | | // Make sure we convert "t (^)(...)" to "t (*)(...)". |
3499 | 44 | (void)convertBlockPointerToFunctionPointer(t); |
3500 | 44 | ArgTypes.push_back(t); |
3501 | 44 | } |
3502 | 98 | returnType = Exp->getType(); |
3503 | 98 | convertToUnqualifiedObjCType(returnType); |
3504 | 98 | (void)convertBlockPointerToFunctionPointer(returnType); |
3505 | 98 | } else { |
3506 | 6 | returnType = Context->getObjCIdType(); |
3507 | 6 | } |
3508 | | // Get the type, we will need to reference it in a couple spots. |
3509 | 104 | QualType msgSendType = MsgSendFlavor->getType(); |
3510 | | |
3511 | | // Create a reference to the objc_msgSend() declaration. |
3512 | 104 | DeclRefExpr *DRE = new (Context) DeclRefExpr( |
3513 | 104 | *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation()); |
3514 | | |
3515 | | // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid). |
3516 | | // If we don't do this cast, we get the following bizarre warning/note: |
3517 | | // xx.m:13: warning: function called through a non-compatible type |
3518 | | // xx.m:13: note: if this code is reached, the program will abort |
3519 | 104 | cast = NoTypeInfoCStyleCastExpr(Context, |
3520 | 104 | Context->getPointerType(Context->VoidTy), |
3521 | 104 | CK_BitCast, DRE); |
3522 | | |
3523 | | // Now do the "normal" pointer to function cast. |
3524 | | // If we don't have a method decl, force a variadic cast. |
3525 | 104 | const ObjCMethodDecl *MD = Exp->getMethodDecl(); |
3526 | 104 | QualType castType = |
3527 | 104 | getSimpleFunctionType(returnType, ArgTypes, MD ? MD->isVariadic()98 : true6 ); |
3528 | 104 | castType = Context->getPointerType(castType); |
3529 | 104 | cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast, |
3530 | 104 | cast); |
3531 | | |
3532 | | // Don't forget the parens to enforce the proper binding. |
3533 | 104 | ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast); |
3534 | | |
3535 | 104 | const FunctionType *FT = msgSendType->castAs<FunctionType>(); |
3536 | 104 | CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), |
3537 | 104 | VK_PRValue, EndLoc, FPOptionsOverride()); |
3538 | 104 | Stmt *ReplacingStmt = CE; |
3539 | 104 | if (MsgSendStretFlavor) { |
3540 | | // We have the method which returns a struct/union. Must also generate |
3541 | | // call to objc_msgSend_stret and hang both varieties on a conditional |
3542 | | // expression which dictate which one to envoke depending on size of |
3543 | | // method's return type. |
3544 | | |
3545 | 12 | Expr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor, |
3546 | 12 | returnType, |
3547 | 12 | ArgTypes, MsgExprs, |
3548 | 12 | Exp->getMethodDecl()); |
3549 | 12 | ReplacingStmt = STCE; |
3550 | 12 | } |
3551 | | // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info. |
3552 | 104 | return ReplacingStmt; |
3553 | 104 | } |
3554 | | |
3555 | 71 | Stmt *RewriteModernObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) { |
3556 | 71 | Stmt *ReplacingStmt = |
3557 | 71 | SynthMessageExpr(Exp, Exp->getBeginLoc(), Exp->getEndLoc()); |
3558 | | |
3559 | | // Now do the actual rewrite. |
3560 | 71 | ReplaceStmt(Exp, ReplacingStmt); |
3561 | | |
3562 | | // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info. |
3563 | 71 | return ReplacingStmt; |
3564 | 71 | } |
3565 | | |
3566 | | // typedef struct objc_object Protocol; |
3567 | 4 | QualType RewriteModernObjC::getProtocolType() { |
3568 | 4 | if (!ProtocolTypeDecl) { |
3569 | 1 | TypeSourceInfo *TInfo |
3570 | 1 | = Context->getTrivialTypeSourceInfo(Context->getObjCIdType()); |
3571 | 1 | ProtocolTypeDecl = TypedefDecl::Create(*Context, TUDecl, |
3572 | 1 | SourceLocation(), SourceLocation(), |
3573 | 1 | &Context->Idents.get("Protocol"), |
3574 | 1 | TInfo); |
3575 | 1 | } |
3576 | 4 | return Context->getTypeDeclType(ProtocolTypeDecl); |
3577 | 4 | } |
3578 | | |
3579 | | /// RewriteObjCProtocolExpr - Rewrite a protocol expression into |
3580 | | /// a synthesized/forward data reference (to the protocol's metadata). |
3581 | | /// The forward references (and metadata) are generated in |
3582 | | /// RewriteModernObjC::HandleTranslationUnit(). |
3583 | 2 | Stmt *RewriteModernObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) { |
3584 | 2 | std::string Name = "_OBJC_PROTOCOL_REFERENCE_$_" + |
3585 | 2 | Exp->getProtocol()->getNameAsString(); |
3586 | 2 | IdentifierInfo *ID = &Context->Idents.get(Name); |
3587 | 2 | VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(), |
3588 | 2 | SourceLocation(), ID, getProtocolType(), |
3589 | 2 | nullptr, SC_Extern); |
3590 | 2 | DeclRefExpr *DRE = new (Context) DeclRefExpr( |
3591 | 2 | *Context, VD, false, getProtocolType(), VK_LValue, SourceLocation()); |
3592 | 2 | CastExpr *castExpr = NoTypeInfoCStyleCastExpr( |
3593 | 2 | Context, Context->getPointerType(DRE->getType()), CK_BitCast, DRE); |
3594 | 2 | ReplaceStmt(Exp, castExpr); |
3595 | 2 | ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl()); |
3596 | | // delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info. |
3597 | 2 | return castExpr; |
3598 | 2 | } |
3599 | | |
3600 | | /// IsTagDefinedInsideClass - This routine checks that a named tagged type |
3601 | | /// is defined inside an objective-c class. If so, it returns true. |
3602 | | bool RewriteModernObjC::IsTagDefinedInsideClass(ObjCContainerDecl *IDecl, |
3603 | | TagDecl *Tag, |
3604 | 39 | bool &IsNamedDefinition) { |
3605 | 39 | if (!IDecl) |
3606 | 0 | return false; |
3607 | 39 | SourceLocation TagLocation; |
3608 | 39 | if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag)) { |
3609 | 31 | RD = RD->getDefinition(); |
3610 | 31 | if (!RD || !RD->getDeclName().getAsIdentifierInfo()) |
3611 | 16 | return false; |
3612 | 15 | IsNamedDefinition = true; |
3613 | 15 | TagLocation = RD->getLocation(); |
3614 | 15 | return Context->getSourceManager().isBeforeInTranslationUnit( |
3615 | 15 | IDecl->getLocation(), TagLocation); |
3616 | 31 | } |
3617 | 8 | if (EnumDecl *ED = dyn_cast<EnumDecl>(Tag)) { |
3618 | 8 | if (!ED || !ED->getDeclName().getAsIdentifierInfo()) |
3619 | 4 | return false; |
3620 | 4 | IsNamedDefinition = true; |
3621 | 4 | TagLocation = ED->getLocation(); |
3622 | 4 | return Context->getSourceManager().isBeforeInTranslationUnit( |
3623 | 4 | IDecl->getLocation(), TagLocation); |
3624 | 8 | } |
3625 | 0 | return false; |
3626 | 8 | } |
3627 | | |
3628 | | /// RewriteObjCFieldDeclType - This routine rewrites a type into the buffer. |
3629 | | /// It handles elaborated types, as well as enum types in the process. |
3630 | | bool RewriteModernObjC::RewriteObjCFieldDeclType(QualType &Type, |
3631 | 297 | std::string &Result) { |
3632 | 297 | if (Type->getAs<TypedefType>()) { |
3633 | 46 | Result += "\t"; |
3634 | 46 | return false; |
3635 | 46 | } |
3636 | | |
3637 | 251 | if (Type->isArrayType()) { |
3638 | 2 | QualType ElemTy = Context->getBaseElementType(Type); |
3639 | 2 | return RewriteObjCFieldDeclType(ElemTy, Result); |
3640 | 2 | } |
3641 | 249 | else if (Type->isRecordType()) { |
3642 | 68 | RecordDecl *RD = Type->castAs<RecordType>()->getDecl(); |
3643 | 68 | if (RD->isCompleteDefinition()) { |
3644 | 68 | if (RD->isStruct()) |
3645 | 61 | Result += "\n\tstruct "; |
3646 | 7 | else if (RD->isUnion()) |
3647 | 7 | Result += "\n\tunion "; |
3648 | 0 | else |
3649 | 0 | assert(false && "class not allowed as an ivar type"); |
3650 | | |
3651 | 68 | Result += RD->getName(); |
3652 | 68 | if (GlobalDefinedTags.count(RD)) { |
3653 | | // struct/union is defined globally, use it. |
3654 | 27 | Result += " "; |
3655 | 27 | return true; |
3656 | 27 | } |
3657 | 41 | Result += " {\n"; |
3658 | 41 | for (auto *FD : RD->fields()) |
3659 | 102 | RewriteObjCFieldDecl(FD, Result); |
3660 | 41 | Result += "\t} "; |
3661 | 41 | return true; |
3662 | 68 | } |
3663 | 68 | } |
3664 | 181 | else if (Type->isEnumeralType()) { |
3665 | 16 | EnumDecl *ED = Type->castAs<EnumType>()->getDecl(); |
3666 | 16 | if (ED->isCompleteDefinition()) { |
3667 | 16 | Result += "\n\tenum "; |
3668 | 16 | Result += ED->getName(); |
3669 | 16 | if (GlobalDefinedTags.count(ED)) { |
3670 | | // Enum is globall defined, use it. |
3671 | 9 | Result += " "; |
3672 | 9 | return true; |
3673 | 9 | } |
3674 | | |
3675 | 7 | Result += " {\n"; |
3676 | 13 | for (const auto *EC : ED->enumerators()) { |
3677 | 13 | Result += "\t"; Result += EC->getName(); Result += " = "; |
3678 | 13 | Result += toString(EC->getInitVal(), 10); |
3679 | 13 | Result += ",\n"; |
3680 | 13 | } |
3681 | 7 | Result += "\t} "; |
3682 | 7 | return true; |
3683 | 16 | } |
3684 | 16 | } |
3685 | | |
3686 | 165 | Result += "\t"; |
3687 | 165 | convertObjCTypeToCStyleType(Type); |
3688 | 165 | return false; |
3689 | 251 | } |
3690 | | |
3691 | | |
3692 | | /// RewriteObjCFieldDecl - This routine rewrites a field into the buffer. |
3693 | | /// It handles elaborated types, as well as enum types in the process. |
3694 | | void RewriteModernObjC::RewriteObjCFieldDecl(FieldDecl *fieldDecl, |
3695 | 269 | std::string &Result) { |
3696 | 269 | QualType Type = fieldDecl->getType(); |
3697 | 269 | std::string Name = fieldDecl->getNameAsString(); |
3698 | | |
3699 | 269 | bool EleboratedType = RewriteObjCFieldDeclType(Type, Result); |
3700 | 269 | if (!EleboratedType) |
3701 | 211 | Type.getAsStringInternal(Name, Context->getPrintingPolicy()); |
3702 | 269 | Result += Name; |
3703 | 269 | if (fieldDecl->isBitField()) { |
3704 | 64 | Result += " : "; Result += utostr(fieldDecl->getBitWidthValue(*Context)); |
3705 | 64 | } |
3706 | 205 | else if (EleboratedType && Type->isArrayType()58 ) { |
3707 | 1 | const ArrayType *AT = Context->getAsArrayType(Type); |
3708 | 2 | do { |
3709 | 2 | if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(AT)) { |
3710 | 2 | Result += "["; |
3711 | 2 | llvm::APInt Dim = CAT->getSize(); |
3712 | 2 | Result += utostr(Dim.getZExtValue()); |
3713 | 2 | Result += "]"; |
3714 | 2 | } |
3715 | 2 | AT = Context->getAsArrayType(AT->getElementType()); |
3716 | 2 | } while (AT); |
3717 | 1 | } |
3718 | | |
3719 | 269 | Result += ";\n"; |
3720 | 269 | } |
3721 | | |
3722 | | /// RewriteLocallyDefinedNamedAggregates - This routine rewrites locally defined |
3723 | | /// named aggregate types into the input buffer. |
3724 | | void RewriteModernObjC::RewriteLocallyDefinedNamedAggregates(FieldDecl *fieldDecl, |
3725 | 213 | std::string &Result) { |
3726 | 213 | QualType Type = fieldDecl->getType(); |
3727 | 213 | if (Type->getAs<TypedefType>()) |
3728 | 44 | return; |
3729 | 169 | if (Type->isArrayType()) |
3730 | 2 | Type = Context->getBaseElementType(Type); |
3731 | | |
3732 | 169 | auto *IDecl = dyn_cast<ObjCContainerDecl>(fieldDecl->getDeclContext()); |
3733 | | |
3734 | 169 | TagDecl *TD = nullptr; |
3735 | 169 | if (Type->isRecordType()) { |
3736 | 43 | TD = Type->castAs<RecordType>()->getDecl(); |
3737 | 43 | } |
3738 | 126 | else if (Type->isEnumeralType()) { |
3739 | 13 | TD = Type->castAs<EnumType>()->getDecl(); |
3740 | 13 | } |
3741 | | |
3742 | 169 | if (TD) { |
3743 | 56 | if (GlobalDefinedTags.count(TD)) |
3744 | 17 | return; |
3745 | | |
3746 | 39 | bool IsNamedDefinition = false; |
3747 | 39 | if (IsTagDefinedInsideClass(IDecl, TD, IsNamedDefinition)) { |
3748 | 14 | RewriteObjCFieldDeclType(Type, Result); |
3749 | 14 | Result += ";"; |
3750 | 14 | } |
3751 | 39 | if (IsNamedDefinition) |
3752 | 19 | GlobalDefinedTags.insert(TD); |
3753 | 39 | } |
3754 | 169 | } |
3755 | | |
3756 | 171 | unsigned RewriteModernObjC::ObjCIvarBitfieldGroupNo(ObjCIvarDecl *IV) { |
3757 | 171 | const ObjCInterfaceDecl *CDecl = IV->getContainingInterface(); |
3758 | 171 | if (ObjCInterefaceHasBitfieldGroups.count(CDecl)) { |
3759 | 160 | return IvarGroupNumber[IV]; |
3760 | 160 | } |
3761 | 11 | unsigned GroupNo = 0; |
3762 | 11 | SmallVector<const ObjCIvarDecl *, 8> IVars; |
3763 | 11 | for (const ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin(); |
3764 | 90 | IVD; IVD = IVD->getNextIvar()79 ) |
3765 | 79 | IVars.push_back(IVD); |
3766 | | |
3767 | 56 | for (unsigned i = 0, e = IVars.size(); i < e; i++45 ) |
3768 | 45 | if (IVars[i]->isBitField()) { |
3769 | 12 | IvarGroupNumber[IVars[i++]] = ++GroupNo; |
3770 | 46 | while (i < e && IVars[i]->isBitField()39 ) |
3771 | 34 | IvarGroupNumber[IVars[i++]] = GroupNo; |
3772 | 12 | if (i < e) |
3773 | 5 | --i; |
3774 | 12 | } |
3775 | | |
3776 | 11 | ObjCInterefaceHasBitfieldGroups.insert(CDecl); |
3777 | 11 | return IvarGroupNumber[IV]; |
3778 | 171 | } |
3779 | | |
3780 | | QualType RewriteModernObjC::SynthesizeBitfieldGroupStructType( |
3781 | | ObjCIvarDecl *IV, |
3782 | 12 | SmallVectorImpl<ObjCIvarDecl *> &IVars) { |
3783 | 12 | std::string StructTagName; |
3784 | 12 | ObjCIvarBitfieldGroupType(IV, StructTagName); |
3785 | 12 | RecordDecl *RD = RecordDecl::Create( |
3786 | 12 | *Context, TagTypeKind::Struct, Context->getTranslationUnitDecl(), |
3787 | 12 | SourceLocation(), SourceLocation(), &Context->Idents.get(StructTagName)); |
3788 | 58 | for (unsigned i=0, e = IVars.size(); i < e; i++46 ) { |
3789 | 46 | ObjCIvarDecl *Ivar = IVars[i]; |
3790 | 46 | RD->addDecl(FieldDecl::Create(*Context, RD, SourceLocation(), SourceLocation(), |
3791 | 46 | &Context->Idents.get(Ivar->getName()), |
3792 | 46 | Ivar->getType(), |
3793 | 46 | nullptr, /*Expr *BW */Ivar->getBitWidth(), |
3794 | 46 | false, ICIS_NoInit)); |
3795 | 46 | } |
3796 | 12 | RD->completeDefinition(); |
3797 | 12 | return Context->getTagDeclType(RD); |
3798 | 12 | } |
3799 | | |
3800 | 42 | QualType RewriteModernObjC::GetGroupRecordTypeForObjCIvarBitfield(ObjCIvarDecl *IV) { |
3801 | 42 | const ObjCInterfaceDecl *CDecl = IV->getContainingInterface(); |
3802 | 42 | unsigned GroupNo = ObjCIvarBitfieldGroupNo(IV); |
3803 | 42 | std::pair<const ObjCInterfaceDecl*, unsigned> tuple = std::make_pair(CDecl, GroupNo); |
3804 | 42 | if (GroupRecordType.count(tuple)) |
3805 | 31 | return GroupRecordType[tuple]; |
3806 | | |
3807 | 11 | SmallVector<ObjCIvarDecl *, 8> IVars; |
3808 | 11 | for (const ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin(); |
3809 | 90 | IVD; IVD = IVD->getNextIvar()79 ) { |
3810 | 79 | if (IVD->isBitField()) |
3811 | 46 | IVars.push_back(const_cast<ObjCIvarDecl *>(IVD)); |
3812 | 33 | else { |
3813 | 33 | if (!IVars.empty()) { |
3814 | 5 | unsigned GroupNo = ObjCIvarBitfieldGroupNo(IVars[0]); |
3815 | | // Generate the struct type for this group of bitfield ivars. |
3816 | 5 | GroupRecordType[std::make_pair(CDecl, GroupNo)] = |
3817 | 5 | SynthesizeBitfieldGroupStructType(IVars[0], IVars); |
3818 | 5 | IVars.clear(); |
3819 | 5 | } |
3820 | 33 | } |
3821 | 79 | } |
3822 | 11 | if (!IVars.empty()) { |
3823 | | // Do the last one. |
3824 | 7 | unsigned GroupNo = ObjCIvarBitfieldGroupNo(IVars[0]); |
3825 | 7 | GroupRecordType[std::make_pair(CDecl, GroupNo)] = |
3826 | 7 | SynthesizeBitfieldGroupStructType(IVars[0], IVars); |
3827 | 7 | } |
3828 | 11 | QualType RetQT = GroupRecordType[tuple]; |
3829 | 11 | assert(!RetQT.isNull() && "GetGroupRecordTypeForObjCIvarBitfield struct type is NULL"); |
3830 | | |
3831 | 11 | return RetQT; |
3832 | 11 | } |
3833 | | |
3834 | | /// ObjCIvarBitfieldGroupDecl - Names field decl. for ivar bitfield group. |
3835 | | /// Name would be: classname__GRBF_n where n is the group number for this ivar. |
3836 | | void RewriteModernObjC::ObjCIvarBitfieldGroupDecl(ObjCIvarDecl *IV, |
3837 | 82 | std::string &Result) { |
3838 | 82 | const ObjCInterfaceDecl *CDecl = IV->getContainingInterface(); |
3839 | 82 | Result += CDecl->getName(); |
3840 | 82 | Result += "__GRBF_"; |
3841 | 82 | unsigned GroupNo = ObjCIvarBitfieldGroupNo(IV); |
3842 | 82 | Result += utostr(GroupNo); |
3843 | 82 | } |
3844 | | |
3845 | | /// ObjCIvarBitfieldGroupType - Names struct type for ivar bitfield group. |
3846 | | /// Name of the struct would be: classname__T_n where n is the group number for |
3847 | | /// this ivar. |
3848 | | void RewriteModernObjC::ObjCIvarBitfieldGroupType(ObjCIvarDecl *IV, |
3849 | 24 | std::string &Result) { |
3850 | 24 | const ObjCInterfaceDecl *CDecl = IV->getContainingInterface(); |
3851 | 24 | Result += CDecl->getName(); |
3852 | 24 | Result += "__T_"; |
3853 | 24 | unsigned GroupNo = ObjCIvarBitfieldGroupNo(IV); |
3854 | 24 | Result += utostr(GroupNo); |
3855 | 24 | } |
3856 | | |
3857 | | /// ObjCIvarBitfieldGroupOffset - Names symbol for ivar bitfield group field offset. |
3858 | | /// Name would be: OBJC_IVAR_$_classname__GRBF_n where n is the group number for |
3859 | | /// this ivar. |
3860 | | void RewriteModernObjC::ObjCIvarBitfieldGroupOffset(ObjCIvarDecl *IV, |
3861 | 44 | std::string &Result) { |
3862 | 44 | Result += "OBJC_IVAR_$_"; |
3863 | 44 | ObjCIvarBitfieldGroupDecl(IV, Result); |
3864 | 44 | } |
3865 | | |
3866 | 46 | #define SKIP_BITFIELDS(IX, ENDIX, VEC) { \ |
3867 | 204 | while ((IX < ENDIX) && VEC[IX]->isBitField()178 ) \ |
3868 | 158 | ++IX; \ |
3869 | 46 | if (IX < ENDIX) \ |
3870 | 46 | --IX20 ; \ |
3871 | 46 | } |
3872 | | |
3873 | | /// RewriteObjCInternalStruct - Rewrite one internal struct corresponding to |
3874 | | /// an objective-c class with ivars. |
3875 | | void RewriteModernObjC::RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl, |
3876 | 152 | std::string &Result) { |
3877 | 152 | assert(CDecl && "Class missing in SynthesizeObjCInternalStruct"); |
3878 | 152 | assert(CDecl->getName() != "" && |
3879 | 152 | "Name missing in SynthesizeObjCInternalStruct"); |
3880 | 152 | ObjCInterfaceDecl *RCDecl = CDecl->getSuperClass(); |
3881 | 152 | SmallVector<ObjCIvarDecl *, 8> IVars; |
3882 | 152 | for (ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin(); |
3883 | 365 | IVD; IVD = IVD->getNextIvar()213 ) |
3884 | 213 | IVars.push_back(IVD); |
3885 | | |
3886 | 152 | SourceLocation LocStart = CDecl->getBeginLoc(); |
3887 | 152 | SourceLocation LocEnd = CDecl->getEndOfDefinitionLoc(); |
3888 | | |
3889 | 152 | const char *startBuf = SM->getCharacterData(LocStart); |
3890 | 152 | const char *endBuf = SM->getCharacterData(LocEnd); |
3891 | | |
3892 | | // If no ivars and no root or if its root, directly or indirectly, |
3893 | | // have no ivars (thus not synthesized) then no need to synthesize this class. |
3894 | 152 | if ((!CDecl->isThisDeclarationADefinition() || IVars.size() == 0) && |
3895 | 152 | (88 !RCDecl88 || !ObjCSynthesizedStructs.count(RCDecl)15 )) { |
3896 | 86 | endBuf += Lexer::MeasureTokenLength(LocEnd, *SM, LangOpts); |
3897 | 86 | ReplaceText(LocStart, endBuf-startBuf, Result); |
3898 | 86 | return; |
3899 | 86 | } |
3900 | | |
3901 | | // Insert named struct/union definitions inside class to |
3902 | | // outer scope. This follows semantics of locally defined |
3903 | | // struct/unions in objective-c classes. |
3904 | 279 | for (unsigned i = 0, e = IVars.size(); 66 i < e; i++213 ) |
3905 | 213 | RewriteLocallyDefinedNamedAggregates(IVars[i], Result); |
3906 | | |
3907 | | // Insert named structs which are syntheized to group ivar bitfields |
3908 | | // to outer scope as well. |
3909 | 245 | for (unsigned i = 0, e = IVars.size(); i < e; i++179 ) |
3910 | 179 | if (IVars[i]->isBitField()) { |
3911 | 12 | ObjCIvarDecl *IV = IVars[i]; |
3912 | 12 | QualType QT = GetGroupRecordTypeForObjCIvarBitfield(IV); |
3913 | 12 | RewriteObjCFieldDeclType(QT, Result); |
3914 | 12 | Result += ";"; |
3915 | | // skip over ivar bitfields in this group. |
3916 | 12 | SKIP_BITFIELDS(i , e, IVars); |
3917 | 12 | } |
3918 | | |
3919 | 66 | Result += "\nstruct "; |
3920 | 66 | Result += CDecl->getNameAsString(); |
3921 | 66 | Result += "_IMPL {\n"; |
3922 | | |
3923 | 66 | if (RCDecl && ObjCSynthesizedStructs.count(RCDecl)14 ) { |
3924 | 9 | Result += "\tstruct "; Result += RCDecl->getNameAsString(); |
3925 | 9 | Result += "_IMPL "; Result += RCDecl->getNameAsString(); |
3926 | 9 | Result += "_IVARS;\n"; |
3927 | 9 | } |
3928 | | |
3929 | 245 | for (unsigned i = 0, e = IVars.size(); i < e; i++179 ) { |
3930 | 179 | if (IVars[i]->isBitField()) { |
3931 | 12 | ObjCIvarDecl *IV = IVars[i]; |
3932 | 12 | Result += "\tstruct "; |
3933 | 12 | ObjCIvarBitfieldGroupType(IV, Result); Result += " "; |
3934 | 12 | ObjCIvarBitfieldGroupDecl(IV, Result); Result += ";\n"; |
3935 | | // skip over ivar bitfields in this group. |
3936 | 12 | SKIP_BITFIELDS(i , e, IVars); |
3937 | 12 | } |
3938 | 167 | else |
3939 | 167 | RewriteObjCFieldDecl(IVars[i], Result); |
3940 | 179 | } |
3941 | | |
3942 | 66 | Result += "};\n"; |
3943 | 66 | endBuf += Lexer::MeasureTokenLength(LocEnd, *SM, LangOpts); |
3944 | 66 | ReplaceText(LocStart, endBuf-startBuf, Result); |
3945 | | // Mark this struct as having been generated. |
3946 | 66 | if (!ObjCSynthesizedStructs.insert(CDecl).second) |
3947 | 0 | llvm_unreachable("struct already synthesize- RewriteObjCInternalStruct"); |
3948 | 66 | } |
3949 | | |
3950 | | /// RewriteIvarOffsetSymbols - Rewrite ivar offset symbols of those ivars which |
3951 | | /// have been referenced in an ivar access expression. |
3952 | | void RewriteModernObjC::RewriteIvarOffsetSymbols(ObjCInterfaceDecl *CDecl, |
3953 | 152 | std::string &Result) { |
3954 | | // write out ivar offset symbols which have been referenced in an ivar |
3955 | | // access expression. |
3956 | 152 | llvm::SmallSetVector<ObjCIvarDecl *, 8> Ivars = ReferencedIvars[CDecl]; |
3957 | | |
3958 | 152 | if (Ivars.empty()) |
3959 | 109 | return; |
3960 | | |
3961 | 43 | llvm::DenseSet<std::pair<const ObjCInterfaceDecl*, unsigned> > GroupSymbolOutput; |
3962 | 85 | for (ObjCIvarDecl *IvarDecl : Ivars) { |
3963 | 85 | const ObjCInterfaceDecl *IDecl = IvarDecl->getContainingInterface(); |
3964 | 85 | unsigned GroupNo = 0; |
3965 | 85 | if (IvarDecl->isBitField()) { |
3966 | 11 | GroupNo = ObjCIvarBitfieldGroupNo(IvarDecl); |
3967 | 11 | if (GroupSymbolOutput.count(std::make_pair(IDecl, GroupNo))) |
3968 | 8 | continue; |
3969 | 11 | } |
3970 | 77 | Result += "\n"; |
3971 | 77 | if (LangOpts.MicrosoftExt) |
3972 | 77 | Result += "__declspec(allocate(\".objc_ivar$B\")) "; |
3973 | 77 | Result += "extern \"C\" "; |
3974 | 77 | if (LangOpts.MicrosoftExt && |
3975 | 77 | IvarDecl->getAccessControl() != ObjCIvarDecl::Private && |
3976 | 77 | IvarDecl->getAccessControl() != ObjCIvarDecl::Package50 ) |
3977 | 50 | Result += "__declspec(dllimport) "; |
3978 | | |
3979 | 77 | Result += "unsigned long "; |
3980 | 77 | if (IvarDecl->isBitField()) { |
3981 | 3 | ObjCIvarBitfieldGroupOffset(IvarDecl, Result); |
3982 | 3 | GroupSymbolOutput.insert(std::make_pair(IDecl, GroupNo)); |
3983 | 3 | } |
3984 | 74 | else |
3985 | 74 | WriteInternalIvarName(CDecl, IvarDecl, Result); |
3986 | 77 | Result += ";"; |
3987 | 77 | } |
3988 | 43 | } |
3989 | | |
3990 | | //===----------------------------------------------------------------------===// |
3991 | | // Meta Data Emission |
3992 | | //===----------------------------------------------------------------------===// |
3993 | | |
3994 | | /// RewriteImplementations - This routine rewrites all method implementations |
3995 | | /// and emits meta-data. |
3996 | | |
3997 | 52 | void RewriteModernObjC::RewriteImplementations() { |
3998 | 52 | int ClsDefCount = ClassImplementation.size(); |
3999 | 52 | int CatDefCount = CategoryImplementation.size(); |
4000 | | |
4001 | | // Rewrite implemented methods |
4002 | 140 | for (int i = 0; i < ClsDefCount; i++88 ) { |
4003 | 88 | ObjCImplementationDecl *OIMP = ClassImplementation[i]; |
4004 | 88 | ObjCInterfaceDecl *CDecl = OIMP->getClassInterface(); |
4005 | 88 | if (CDecl->isImplicitInterfaceDecl()) |
4006 | 0 | assert(false && |
4007 | 88 | "Legacy implicit interface rewriting not supported in moder abi"); |
4008 | 88 | RewriteImplementationDecl(OIMP); |
4009 | 88 | } |
4010 | | |
4011 | 57 | for (int i = 0; 52 i < CatDefCount; i++5 ) { |
4012 | 5 | ObjCCategoryImplDecl *CIMP = CategoryImplementation[i]; |
4013 | 5 | ObjCInterfaceDecl *CDecl = CIMP->getClassInterface(); |
4014 | 5 | if (CDecl->isImplicitInterfaceDecl()) |
4015 | 0 | assert(false && |
4016 | 5 | "Legacy implicit interface rewriting not supported in moder abi"); |
4017 | 5 | RewriteImplementationDecl(CIMP); |
4018 | 5 | } |
4019 | 52 | } |
4020 | | |
4021 | | void RewriteModernObjC::RewriteByRefString(std::string &ResultStr, |
4022 | | const std::string &Name, |
4023 | 291 | ValueDecl *VD, bool def) { |
4024 | 291 | assert(BlockByRefDeclNo.count(VD) && |
4025 | 291 | "RewriteByRefString: ByRef decl missing"); |
4026 | 291 | if (def) |
4027 | 83 | ResultStr += "struct "; |
4028 | 291 | ResultStr += "__Block_byref_" + Name + |
4029 | 291 | "_" + utostr(BlockByRefDeclNo[VD]) ; |
4030 | 291 | } |
4031 | | |
4032 | 907 | static bool HasLocalVariableExternalStorage(ValueDecl *VD) { |
4033 | 907 | if (VarDecl *Var = dyn_cast<VarDecl>(VD)) |
4034 | 436 | return (Var->isFunctionOrMethodVarDecl() && !Var->hasLocalStorage()176 ); |
4035 | 471 | return false; |
4036 | 907 | } |
4037 | | |
4038 | | std::string RewriteModernObjC::SynthesizeBlockFunc(BlockExpr *CE, int i, |
4039 | | StringRef funcName, |
4040 | 80 | std::string Tag) { |
4041 | 80 | const FunctionType *AFT = CE->getFunctionType(); |
4042 | 80 | QualType RT = AFT->getReturnType(); |
4043 | 80 | std::string StructRef = "struct " + Tag; |
4044 | 80 | SourceLocation BlockLoc = CE->getExprLoc(); |
4045 | 80 | std::string S; |
4046 | 80 | ConvertSourceLocationToLineDirective(BlockLoc, S); |
4047 | | |
4048 | 80 | S += "static " + RT.getAsString(Context->getPrintingPolicy()) + " __" + |
4049 | 80 | funcName.str() + "_block_func_" + utostr(i); |
4050 | | |
4051 | 80 | BlockDecl *BD = CE->getBlockDecl(); |
4052 | | |
4053 | 80 | if (isa<FunctionNoProtoType>(AFT)) { |
4054 | | // No user-supplied arguments. Still need to pass in a pointer to the |
4055 | | // block (to reference imported block decl refs). |
4056 | 0 | S += "(" + StructRef + " *__cself)"; |
4057 | 80 | } else if (BD->param_empty()) { |
4058 | 70 | S += "(" + StructRef + " *__cself)"; |
4059 | 70 | } else { |
4060 | 10 | const FunctionProtoType *FT = cast<FunctionProtoType>(AFT); |
4061 | 10 | assert(FT && "SynthesizeBlockFunc: No function proto"); |
4062 | 10 | S += '('; |
4063 | | // first add the implicit argument. |
4064 | 10 | S += StructRef + " *__cself, "; |
4065 | 10 | std::string ParamStr; |
4066 | 10 | for (BlockDecl::param_iterator AI = BD->param_begin(), |
4067 | 23 | E = BD->param_end(); AI != E; ++AI13 ) { |
4068 | 13 | if (AI != BD->param_begin()) S += ", "3 ; |
4069 | 13 | ParamStr = (*AI)->getNameAsString(); |
4070 | 13 | QualType QT = (*AI)->getType(); |
4071 | 13 | (void)convertBlockPointerToFunctionPointer(QT); |
4072 | 13 | QT.getAsStringInternal(ParamStr, Context->getPrintingPolicy()); |
4073 | 13 | S += ParamStr; |
4074 | 13 | } |
4075 | 10 | if (FT->isVariadic()) { |
4076 | 0 | if (!BD->param_empty()) S += ", "; |
4077 | 0 | S += "..."; |
4078 | 0 | } |
4079 | 10 | S += ')'; |
4080 | 10 | } |
4081 | 80 | S += " {\n"; |
4082 | | |
4083 | | // Create local declarations to avoid rewriting all closure decl ref exprs. |
4084 | | // First, emit a declaration for all "by ref" decls. |
4085 | 80 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(), |
4086 | 121 | E = BlockByRefDecls.end(); I != E; ++I41 ) { |
4087 | 41 | S += " "; |
4088 | 41 | std::string Name = (*I)->getNameAsString(); |
4089 | 41 | std::string TypeString; |
4090 | 41 | RewriteByRefString(TypeString, Name, (*I)); |
4091 | 41 | TypeString += " *"; |
4092 | 41 | Name = TypeString + Name; |
4093 | 41 | S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n"; |
4094 | 41 | } |
4095 | | // Next, emit a declaration for all "by copy" declarations. |
4096 | 80 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(), |
4097 | 116 | E = BlockByCopyDecls.end(); I != E; ++I36 ) { |
4098 | 36 | S += " "; |
4099 | | // Handle nested closure invocation. For example: |
4100 | | // |
4101 | | // void (^myImportedClosure)(void); |
4102 | | // myImportedClosure = ^(void) { setGlobalInt(x + y); }; |
4103 | | // |
4104 | | // void (^anotherClosure)(void); |
4105 | | // anotherClosure = ^(void) { |
4106 | | // myImportedClosure(); // import and invoke the closure |
4107 | | // }; |
4108 | | // |
4109 | 36 | if (isTopLevelBlockPointerType((*I)->getType())) { |
4110 | 2 | RewriteBlockPointerTypeVariable(S, (*I)); |
4111 | 2 | S += " = ("; |
4112 | 2 | RewriteBlockPointerType(S, (*I)->getType()); |
4113 | 2 | S += ")"; |
4114 | 2 | S += "__cself->" + (*I)->getNameAsString() + "; // bound by copy\n"; |
4115 | 2 | } |
4116 | 34 | else { |
4117 | 34 | std::string Name = (*I)->getNameAsString(); |
4118 | 34 | QualType QT = (*I)->getType(); |
4119 | 34 | if (HasLocalVariableExternalStorage(*I)) |
4120 | 0 | QT = Context->getPointerType(QT); |
4121 | 34 | QT.getAsStringInternal(Name, Context->getPrintingPolicy()); |
4122 | 34 | S += Name + " = __cself->" + |
4123 | 34 | (*I)->getNameAsString() + "; // bound by copy\n"; |
4124 | 34 | } |
4125 | 36 | } |
4126 | 80 | std::string RewrittenStr = RewrittenBlockExprs[CE]; |
4127 | 80 | const char *cstr = RewrittenStr.c_str(); |
4128 | 356 | while (*cstr++ != '{') ;276 |
4129 | 80 | S += cstr; |
4130 | 80 | S += "\n"; |
4131 | 80 | return S; |
4132 | 80 | } |
4133 | | |
4134 | | std::string RewriteModernObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i, |
4135 | | StringRef funcName, |
4136 | 29 | std::string Tag) { |
4137 | 29 | std::string StructRef = "struct " + Tag; |
4138 | 29 | std::string S = "static void __"; |
4139 | | |
4140 | 29 | S += funcName; |
4141 | 29 | S += "_block_copy_" + utostr(i); |
4142 | 29 | S += "(" + StructRef; |
4143 | 29 | S += "*dst, " + StructRef; |
4144 | 29 | S += "*src) {"; |
4145 | 44 | for (ValueDecl *VD : ImportedBlockDecls) { |
4146 | 44 | S += "_Block_object_assign((void*)&dst->"; |
4147 | 44 | S += VD->getNameAsString(); |
4148 | 44 | S += ", (void*)src->"; |
4149 | 44 | S += VD->getNameAsString(); |
4150 | 44 | if (BlockByRefDeclsPtrSet.count(VD)) |
4151 | 28 | S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);"; |
4152 | 16 | else if (VD->getType()->isBlockPointerType()) |
4153 | 2 | S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);"; |
4154 | 14 | else |
4155 | 14 | S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);"; |
4156 | 44 | } |
4157 | 29 | S += "}\n"; |
4158 | | |
4159 | 29 | S += "\nstatic void __"; |
4160 | 29 | S += funcName; |
4161 | 29 | S += "_block_dispose_" + utostr(i); |
4162 | 29 | S += "(" + StructRef; |
4163 | 29 | S += "*src) {"; |
4164 | 44 | for (ValueDecl *VD : ImportedBlockDecls) { |
4165 | 44 | S += "_Block_object_dispose((void*)src->"; |
4166 | 44 | S += VD->getNameAsString(); |
4167 | 44 | if (BlockByRefDeclsPtrSet.count(VD)) |
4168 | 28 | S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);"; |
4169 | 16 | else if (VD->getType()->isBlockPointerType()) |
4170 | 2 | S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);"; |
4171 | 14 | else |
4172 | 14 | S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);"; |
4173 | 44 | } |
4174 | 29 | S += "}\n"; |
4175 | 29 | return S; |
4176 | 29 | } |
4177 | | |
4178 | | std::string RewriteModernObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag, |
4179 | 80 | std::string Desc) { |
4180 | 80 | std::string S = "\nstruct " + Tag; |
4181 | 80 | std::string Constructor = " " + Tag; |
4182 | | |
4183 | 80 | S += " {\n struct __block_impl impl;\n"; |
4184 | 80 | S += " struct " + Desc; |
4185 | 80 | S += "* Desc;\n"; |
4186 | | |
4187 | 80 | Constructor += "(void *fp, "; // Invoke function pointer. |
4188 | 80 | Constructor += "struct " + Desc; // Descriptor pointer. |
4189 | 80 | Constructor += " *desc"; |
4190 | | |
4191 | 80 | if (BlockDeclRefs.size()) { |
4192 | | // Output all "by copy" declarations. |
4193 | 43 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(), |
4194 | 79 | E = BlockByCopyDecls.end(); I != E; ++I36 ) { |
4195 | 36 | S += " "; |
4196 | 36 | std::string FieldName = (*I)->getNameAsString(); |
4197 | 36 | std::string ArgName = "_" + FieldName; |
4198 | | // Handle nested closure invocation. For example: |
4199 | | // |
4200 | | // void (^myImportedBlock)(void); |
4201 | | // myImportedBlock = ^(void) { setGlobalInt(x + y); }; |
4202 | | // |
4203 | | // void (^anotherBlock)(void); |
4204 | | // anotherBlock = ^(void) { |
4205 | | // myImportedBlock(); // import and invoke the closure |
4206 | | // }; |
4207 | | // |
4208 | 36 | if (isTopLevelBlockPointerType((*I)->getType())) { |
4209 | 2 | S += "struct __block_impl *"; |
4210 | 2 | Constructor += ", void *" + ArgName; |
4211 | 34 | } else { |
4212 | 34 | QualType QT = (*I)->getType(); |
4213 | 34 | if (HasLocalVariableExternalStorage(*I)) |
4214 | 0 | QT = Context->getPointerType(QT); |
4215 | 34 | QT.getAsStringInternal(FieldName, Context->getPrintingPolicy()); |
4216 | 34 | QT.getAsStringInternal(ArgName, Context->getPrintingPolicy()); |
4217 | 34 | Constructor += ", " + ArgName; |
4218 | 34 | } |
4219 | 36 | S += FieldName + ";\n"; |
4220 | 36 | } |
4221 | | // Output all "by ref" declarations. |
4222 | 43 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(), |
4223 | 84 | E = BlockByRefDecls.end(); I != E; ++I41 ) { |
4224 | 41 | S += " "; |
4225 | 41 | std::string FieldName = (*I)->getNameAsString(); |
4226 | 41 | std::string ArgName = "_" + FieldName; |
4227 | 41 | { |
4228 | 41 | std::string TypeString; |
4229 | 41 | RewriteByRefString(TypeString, FieldName, (*I)); |
4230 | 41 | TypeString += " *"; |
4231 | 41 | FieldName = TypeString + FieldName; |
4232 | 41 | ArgName = TypeString + ArgName; |
4233 | 41 | Constructor += ", " + ArgName; |
4234 | 41 | } |
4235 | 41 | S += FieldName + "; // by ref\n"; |
4236 | 41 | } |
4237 | | // Finish writing the constructor. |
4238 | 43 | Constructor += ", int flags=0)"; |
4239 | | // Initialize all "by copy" arguments. |
4240 | 43 | bool firsTime = true; |
4241 | 43 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(), |
4242 | 79 | E = BlockByCopyDecls.end(); I != E; ++I36 ) { |
4243 | 36 | std::string Name = (*I)->getNameAsString(); |
4244 | 36 | if (firsTime) { |
4245 | 24 | Constructor += " : "; |
4246 | 24 | firsTime = false; |
4247 | 24 | } |
4248 | 12 | else |
4249 | 12 | Constructor += ", "; |
4250 | 36 | if (isTopLevelBlockPointerType((*I)->getType())) |
4251 | 2 | Constructor += Name + "((struct __block_impl *)_" + Name + ")"; |
4252 | 34 | else |
4253 | 34 | Constructor += Name + "(_" + Name + ")"; |
4254 | 36 | } |
4255 | | // Initialize all "by ref" arguments. |
4256 | 43 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(), |
4257 | 84 | E = BlockByRefDecls.end(); I != E; ++I41 ) { |
4258 | 41 | std::string Name = (*I)->getNameAsString(); |
4259 | 41 | if (firsTime) { |
4260 | 19 | Constructor += " : "; |
4261 | 19 | firsTime = false; |
4262 | 19 | } |
4263 | 22 | else |
4264 | 22 | Constructor += ", "; |
4265 | 41 | Constructor += Name + "(_" + Name + "->__forwarding)"; |
4266 | 41 | } |
4267 | | |
4268 | 43 | Constructor += " {\n"; |
4269 | 43 | if (GlobalVarDecl) |
4270 | 0 | Constructor += " impl.isa = &_NSConcreteGlobalBlock;\n"; |
4271 | 43 | else |
4272 | 43 | Constructor += " impl.isa = &_NSConcreteStackBlock;\n"; |
4273 | 43 | Constructor += " impl.Flags = flags;\n impl.FuncPtr = fp;\n"; |
4274 | | |
4275 | 43 | Constructor += " Desc = desc;\n"; |
4276 | 43 | } else { |
4277 | | // Finish writing the constructor. |
4278 | 37 | Constructor += ", int flags=0) {\n"; |
4279 | 37 | if (GlobalVarDecl) |
4280 | 6 | Constructor += " impl.isa = &_NSConcreteGlobalBlock;\n"; |
4281 | 31 | else |
4282 | 31 | Constructor += " impl.isa = &_NSConcreteStackBlock;\n"; |
4283 | 37 | Constructor += " impl.Flags = flags;\n impl.FuncPtr = fp;\n"; |
4284 | 37 | Constructor += " Desc = desc;\n"; |
4285 | 37 | } |
4286 | 80 | Constructor += " "; |
4287 | 80 | Constructor += "}\n"; |
4288 | 80 | S += Constructor; |
4289 | 80 | S += "};\n"; |
4290 | 80 | return S; |
4291 | 80 | } |
4292 | | |
4293 | | std::string RewriteModernObjC::SynthesizeBlockDescriptor(std::string DescTag, |
4294 | | std::string ImplTag, int i, |
4295 | | StringRef FunName, |
4296 | 80 | unsigned hasCopy) { |
4297 | 80 | std::string S = "\nstatic struct " + DescTag; |
4298 | | |
4299 | 80 | S += " {\n size_t reserved;\n"; |
4300 | 80 | S += " size_t Block_size;\n"; |
4301 | 80 | if (hasCopy) { |
4302 | 29 | S += " void (*copy)(struct "; |
4303 | 29 | S += ImplTag; S += "*, struct "; |
4304 | 29 | S += ImplTag; S += "*);\n"; |
4305 | | |
4306 | 29 | S += " void (*dispose)(struct "; |
4307 | 29 | S += ImplTag; S += "*);\n"; |
4308 | 29 | } |
4309 | 80 | S += "} "; |
4310 | | |
4311 | 80 | S += DescTag + "_DATA = { 0, sizeof(struct "; |
4312 | 80 | S += ImplTag + ")"; |
4313 | 80 | if (hasCopy) { |
4314 | 29 | S += ", __" + FunName.str() + "_block_copy_" + utostr(i); |
4315 | 29 | S += ", __" + FunName.str() + "_block_dispose_" + utostr(i); |
4316 | 29 | } |
4317 | 80 | S += "};\n"; |
4318 | 80 | return S; |
4319 | 80 | } |
4320 | | |
4321 | | void RewriteModernObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart, |
4322 | 171 | StringRef FunName) { |
4323 | 171 | bool RewriteSC = (GlobalVarDecl && |
4324 | 171 | !Blocks.empty()9 && |
4325 | 171 | GlobalVarDecl->getStorageClass() == SC_Static6 && |
4326 | 171 | GlobalVarDecl->getType().getCVRQualifiers()4 ); |
4327 | 171 | if (RewriteSC) { |
4328 | 4 | std::string SC(" void __"); |
4329 | 4 | SC += GlobalVarDecl->getNameAsString(); |
4330 | 4 | SC += "() {}"; |
4331 | 4 | InsertText(FunLocStart, SC); |
4332 | 4 | } |
4333 | | |
4334 | | // Insert closures that were part of the function. |
4335 | 251 | for (unsigned i = 0, count=0; i < Blocks.size(); i++80 ) { |
4336 | 80 | CollectBlockDeclRefInfo(Blocks[i]); |
4337 | | // Need to copy-in the inner copied-in variables not actually used in this |
4338 | | // block. |
4339 | 105 | for (int j = 0; j < InnerDeclRefsCount[i]; j++25 ) { |
4340 | 25 | DeclRefExpr *Exp = InnerDeclRefs[count++]; |
4341 | 25 | ValueDecl *VD = Exp->getDecl(); |
4342 | 25 | BlockDeclRefs.push_back(Exp); |
4343 | 25 | if (!VD->hasAttr<BlocksAttr>()) { |
4344 | 12 | if (!BlockByCopyDeclsPtrSet.count(VD)) { |
4345 | 12 | BlockByCopyDeclsPtrSet.insert(VD); |
4346 | 12 | BlockByCopyDecls.push_back(VD); |
4347 | 12 | } |
4348 | 12 | continue; |
4349 | 12 | } |
4350 | | |
4351 | 13 | if (!BlockByRefDeclsPtrSet.count(VD)) { |
4352 | 13 | BlockByRefDeclsPtrSet.insert(VD); |
4353 | 13 | BlockByRefDecls.push_back(VD); |
4354 | 13 | } |
4355 | | |
4356 | | // imported objects in the inner blocks not used in the outer |
4357 | | // blocks must be copied/disposed in the outer block as well. |
4358 | 13 | if (VD->getType()->isObjCObjectPointerType() || |
4359 | 13 | VD->getType()->isBlockPointerType()) |
4360 | 0 | ImportedBlockDecls.insert(VD); |
4361 | 13 | } |
4362 | | |
4363 | 80 | std::string ImplTag = "__" + FunName.str() + "_block_impl_" + utostr(i); |
4364 | 80 | std::string DescTag = "__" + FunName.str() + "_block_desc_" + utostr(i); |
4365 | | |
4366 | 80 | std::string CI = SynthesizeBlockImpl(Blocks[i], ImplTag, DescTag); |
4367 | | |
4368 | 80 | InsertText(FunLocStart, CI); |
4369 | | |
4370 | 80 | std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, ImplTag); |
4371 | | |
4372 | 80 | InsertText(FunLocStart, CF); |
4373 | | |
4374 | 80 | if (ImportedBlockDecls.size()) { |
4375 | 29 | std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, ImplTag); |
4376 | 29 | InsertText(FunLocStart, HF); |
4377 | 29 | } |
4378 | 80 | std::string BD = SynthesizeBlockDescriptor(DescTag, ImplTag, i, FunName, |
4379 | 80 | ImportedBlockDecls.size() > 0); |
4380 | 80 | InsertText(FunLocStart, BD); |
4381 | | |
4382 | 80 | BlockDeclRefs.clear(); |
4383 | 80 | BlockByRefDecls.clear(); |
4384 | 80 | BlockByRefDeclsPtrSet.clear(); |
4385 | 80 | BlockByCopyDecls.clear(); |
4386 | 80 | BlockByCopyDeclsPtrSet.clear(); |
4387 | 80 | ImportedBlockDecls.clear(); |
4388 | 80 | } |
4389 | 171 | if (RewriteSC) { |
4390 | | // Must insert any 'const/volatile/static here. Since it has been |
4391 | | // removed as result of rewriting of block literals. |
4392 | 4 | std::string SC; |
4393 | 4 | if (GlobalVarDecl->getStorageClass() == SC_Static) |
4394 | 4 | SC = "static "; |
4395 | 4 | if (GlobalVarDecl->getType().isConstQualified()) |
4396 | 4 | SC += "const "; |
4397 | 4 | if (GlobalVarDecl->getType().isVolatileQualified()) |
4398 | 0 | SC += "volatile "; |
4399 | 4 | if (GlobalVarDecl->getType().isRestrictQualified()) |
4400 | 0 | SC += "restrict "; |
4401 | 4 | InsertText(FunLocStart, SC); |
4402 | 4 | } |
4403 | 171 | if (GlobalConstructionExp) { |
4404 | | // extra fancy dance for global literal expression. |
4405 | | |
4406 | | // Always the latest block expression on the block stack. |
4407 | 6 | std::string Tag = "__"; |
4408 | 6 | Tag += FunName; |
4409 | 6 | Tag += "_block_impl_"; |
4410 | 6 | Tag += utostr(Blocks.size()-1); |
4411 | 6 | std::string globalBuf = "static "; |
4412 | 6 | globalBuf += Tag; globalBuf += " "; |
4413 | 6 | std::string SStr; |
4414 | | |
4415 | 6 | llvm::raw_string_ostream constructorExprBuf(SStr); |
4416 | 6 | GlobalConstructionExp->printPretty(constructorExprBuf, nullptr, |
4417 | 6 | PrintingPolicy(LangOpts)); |
4418 | 6 | globalBuf += constructorExprBuf.str(); |
4419 | 6 | globalBuf += ";\n"; |
4420 | 6 | InsertText(FunLocStart, globalBuf); |
4421 | 6 | GlobalConstructionExp = nullptr; |
4422 | 6 | } |
4423 | | |
4424 | 171 | Blocks.clear(); |
4425 | 171 | InnerDeclRefsCount.clear(); |
4426 | 171 | InnerDeclRefs.clear(); |
4427 | 171 | RewrittenBlockExprs.clear(); |
4428 | 171 | } |
4429 | | |
4430 | 99 | void RewriteModernObjC::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) { |
4431 | 99 | SourceLocation FunLocStart = |
4432 | 99 | (!Blocks.empty()) ? getFunctionSourceLocation(*this, FD)31 |
4433 | 99 | : FD->getTypeSpecStartLoc()68 ; |
4434 | 99 | StringRef FuncName = FD->getName(); |
4435 | | |
4436 | 99 | SynthesizeBlockLiterals(FunLocStart, FuncName); |
4437 | 99 | } |
4438 | | |
4439 | | static void BuildUniqueMethodName(std::string &Name, |
4440 | 84 | ObjCMethodDecl *MD) { |
4441 | 84 | ObjCInterfaceDecl *IFace = MD->getClassInterface(); |
4442 | 84 | Name = std::string(IFace->getName()); |
4443 | 84 | Name += "__" + MD->getSelector().getAsString(); |
4444 | | // Convert colons to underscores. |
4445 | 84 | std::string::size_type loc = 0; |
4446 | 114 | while ((loc = Name.find(':', loc)) != std::string::npos) |
4447 | 30 | Name.replace(loc, 1, "_"); |
4448 | 84 | } |
4449 | | |
4450 | 63 | void RewriteModernObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) { |
4451 | | // fprintf(stderr,"In InsertBlockLiteralsWitinMethod\n"); |
4452 | | // SourceLocation FunLocStart = MD->getBeginLoc(); |
4453 | 63 | SourceLocation FunLocStart = MD->getBeginLoc(); |
4454 | 63 | std::string FuncName; |
4455 | 63 | BuildUniqueMethodName(FuncName, MD); |
4456 | 63 | SynthesizeBlockLiterals(FunLocStart, FuncName); |
4457 | 63 | } |
4458 | | |
4459 | 1.91k | void RewriteModernObjC::GetBlockDeclRefExprs(Stmt *S) { |
4460 | 1.91k | for (Stmt *SubStmt : S->children()) |
4461 | 1.75k | if (SubStmt) { |
4462 | 1.75k | if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) |
4463 | 0 | GetBlockDeclRefExprs(CBE->getBody()); |
4464 | 1.75k | else |
4465 | 1.75k | GetBlockDeclRefExprs(SubStmt); |
4466 | 1.75k | } |
4467 | | // Handle specific things. |
4468 | 1.91k | if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) |
4469 | 448 | if (DRE->refersToEnclosingVariableOrCapture() || |
4470 | 448 | HasLocalVariableExternalStorage(DRE->getDecl())336 ) |
4471 | | // FIXME: Handle enums. |
4472 | 112 | BlockDeclRefs.push_back(DRE); |
4473 | 1.91k | } |
4474 | | |
4475 | | void RewriteModernObjC::GetInnerBlockDeclRefExprs(Stmt *S, |
4476 | | SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs, |
4477 | 720 | llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts) { |
4478 | 720 | for (Stmt *SubStmt : S->children()) |
4479 | 640 | if (SubStmt) { |
4480 | 640 | if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) { |
4481 | 21 | InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl())); |
4482 | 21 | GetInnerBlockDeclRefExprs(CBE->getBody(), |
4483 | 21 | InnerBlockDeclRefs, |
4484 | 21 | InnerContexts); |
4485 | 21 | } |
4486 | 619 | else |
4487 | 619 | GetInnerBlockDeclRefExprs(SubStmt, InnerBlockDeclRefs, InnerContexts); |
4488 | 640 | } |
4489 | | // Handle specific things. |
4490 | 720 | if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) { |
4491 | 154 | if (DRE->refersToEnclosingVariableOrCapture() || |
4492 | 154 | HasLocalVariableExternalStorage(DRE->getDecl())61 ) { |
4493 | 93 | if (!InnerContexts.count(DRE->getDecl()->getDeclContext())) |
4494 | 88 | InnerBlockDeclRefs.push_back(DRE); |
4495 | 93 | if (VarDecl *Var = cast<VarDecl>(DRE->getDecl())) |
4496 | 93 | if (Var->isFunctionOrMethodVarDecl()) |
4497 | 70 | ImportedLocalExternalDecls.insert(Var); |
4498 | 93 | } |
4499 | 154 | } |
4500 | 720 | } |
4501 | | |
4502 | | /// convertObjCTypeToCStyleType - This routine converts such objc types |
4503 | | /// as qualified objects, and blocks to their closest c/c++ types that |
4504 | | /// it can. It returns true if input type was modified. |
4505 | 417 | bool RewriteModernObjC::convertObjCTypeToCStyleType(QualType &T) { |
4506 | 417 | QualType oldT = T; |
4507 | 417 | convertBlockPointerToFunctionPointer(T); |
4508 | 417 | if (T->isFunctionPointerType()) { |
4509 | 14 | QualType PointeeTy; |
4510 | 14 | if (const PointerType* PT = T->getAs<PointerType>()) { |
4511 | 14 | PointeeTy = PT->getPointeeType(); |
4512 | 14 | if (const FunctionType *FT = PointeeTy->getAs<FunctionType>()) { |
4513 | 14 | T = convertFunctionTypeOfBlocks(FT); |
4514 | 14 | T = Context->getPointerType(T); |
4515 | 14 | } |
4516 | 14 | } |
4517 | 14 | } |
4518 | | |
4519 | 417 | convertToUnqualifiedObjCType(T); |
4520 | 417 | return T != oldT; |
4521 | 417 | } |
4522 | | |
4523 | | /// convertFunctionTypeOfBlocks - This routine converts a function type |
4524 | | /// whose result type may be a block pointer or whose argument type(s) |
4525 | | /// might be block pointers to an equivalent function type replacing |
4526 | | /// all block pointers to function pointers. |
4527 | 94 | QualType RewriteModernObjC::convertFunctionTypeOfBlocks(const FunctionType *FT) { |
4528 | 94 | const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT); |
4529 | | // FTP will be null for closures that don't take arguments. |
4530 | | // Generate a funky cast. |
4531 | 94 | SmallVector<QualType, 8> ArgTypes; |
4532 | 94 | QualType Res = FT->getReturnType(); |
4533 | 94 | bool modified = convertObjCTypeToCStyleType(Res); |
4534 | | |
4535 | 94 | if (FTP) { |
4536 | 94 | for (auto &I : FTP->param_types()) { |
4537 | 31 | QualType t = I; |
4538 | | // Make sure we convert "t (^)(...)" to "t (*)(...)". |
4539 | 31 | if (convertObjCTypeToCStyleType(t)) |
4540 | 16 | modified = true; |
4541 | 31 | ArgTypes.push_back(t); |
4542 | 31 | } |
4543 | 94 | } |
4544 | 94 | QualType FuncType; |
4545 | 94 | if (modified) |
4546 | 12 | FuncType = getSimpleFunctionType(Res, ArgTypes); |
4547 | 82 | else FuncType = QualType(FT, 0); |
4548 | 94 | return FuncType; |
4549 | 94 | } |
4550 | | |
4551 | 14 | Stmt *RewriteModernObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) { |
4552 | | // Navigate to relevant type information. |
4553 | 14 | const BlockPointerType *CPT = nullptr; |
4554 | | |
4555 | 14 | if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(BlockExp)) { |
4556 | 0 | CPT = DRE->getType()->getAs<BlockPointerType>(); |
4557 | 14 | } else if (const MemberExpr *MExpr = dyn_cast<MemberExpr>(BlockExp)) { |
4558 | 0 | CPT = MExpr->getType()->getAs<BlockPointerType>(); |
4559 | 0 | } |
4560 | 14 | else if (const ParenExpr *PRE = dyn_cast<ParenExpr>(BlockExp)) { |
4561 | 0 | return SynthesizeBlockCall(Exp, PRE->getSubExpr()); |
4562 | 0 | } |
4563 | 14 | else if (const ImplicitCastExpr *IEXPR = dyn_cast<ImplicitCastExpr>(BlockExp)) |
4564 | 14 | CPT = IEXPR->getType()->getAs<BlockPointerType>(); |
4565 | 0 | else if (const ConditionalOperator *CEXPR = |
4566 | 0 | dyn_cast<ConditionalOperator>(BlockExp)) { |
4567 | 0 | Expr *LHSExp = CEXPR->getLHS(); |
4568 | 0 | Stmt *LHSStmt = SynthesizeBlockCall(Exp, LHSExp); |
4569 | 0 | Expr *RHSExp = CEXPR->getRHS(); |
4570 | 0 | Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp); |
4571 | 0 | Expr *CONDExp = CEXPR->getCond(); |
4572 | 0 | ConditionalOperator *CondExpr = new (Context) ConditionalOperator( |
4573 | 0 | CONDExp, SourceLocation(), cast<Expr>(LHSStmt), SourceLocation(), |
4574 | 0 | cast<Expr>(RHSStmt), Exp->getType(), VK_PRValue, OK_Ordinary); |
4575 | 0 | return CondExpr; |
4576 | 0 | } else if (const ObjCIvarRefExpr *IRE = dyn_cast<ObjCIvarRefExpr>(BlockExp)) { |
4577 | 0 | CPT = IRE->getType()->getAs<BlockPointerType>(); |
4578 | 0 | } else if (const PseudoObjectExpr *POE |
4579 | 0 | = dyn_cast<PseudoObjectExpr>(BlockExp)) { |
4580 | 0 | CPT = POE->getType()->castAs<BlockPointerType>(); |
4581 | 0 | } else { |
4582 | 0 | assert(false && "RewriteBlockClass: Bad type"); |
4583 | 0 | } |
4584 | 14 | assert(CPT && "RewriteBlockClass: Bad type"); |
4585 | 14 | const FunctionType *FT = CPT->getPointeeType()->getAs<FunctionType>(); |
4586 | 14 | assert(FT && "RewriteBlockClass: Bad type"); |
4587 | 14 | const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT); |
4588 | | // FTP will be null for closures that don't take arguments. |
4589 | | |
4590 | 14 | RecordDecl *RD = RecordDecl::Create(*Context, TagTypeKind::Struct, TUDecl, |
4591 | 14 | SourceLocation(), SourceLocation(), |
4592 | 14 | &Context->Idents.get("__block_impl")); |
4593 | 14 | QualType PtrBlock = Context->getPointerType(Context->getTagDeclType(RD)); |
4594 | | |
4595 | | // Generate a funky cast. |
4596 | 14 | SmallVector<QualType, 8> ArgTypes; |
4597 | | |
4598 | | // Push the block argument type. |
4599 | 14 | ArgTypes.push_back(PtrBlock); |
4600 | 14 | if (FTP) { |
4601 | 14 | for (auto &I : FTP->param_types()) { |
4602 | 8 | QualType t = I; |
4603 | | // Make sure we convert "t (^)(...)" to "t (*)(...)". |
4604 | 8 | if (!convertBlockPointerToFunctionPointer(t)) |
4605 | 8 | convertToUnqualifiedObjCType(t); |
4606 | 8 | ArgTypes.push_back(t); |
4607 | 8 | } |
4608 | 14 | } |
4609 | | // Now do the pointer to function cast. |
4610 | 14 | QualType PtrToFuncCastType = getSimpleFunctionType(Exp->getType(), ArgTypes); |
4611 | | |
4612 | 14 | PtrToFuncCastType = Context->getPointerType(PtrToFuncCastType); |
4613 | | |
4614 | 14 | CastExpr *BlkCast = NoTypeInfoCStyleCastExpr(Context, PtrBlock, |
4615 | 14 | CK_BitCast, |
4616 | 14 | const_cast<Expr*>(BlockExp)); |
4617 | | // Don't forget the parens to enforce the proper binding. |
4618 | 14 | ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), |
4619 | 14 | BlkCast); |
4620 | | //PE->dump(); |
4621 | | |
4622 | 14 | FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
4623 | 14 | SourceLocation(), |
4624 | 14 | &Context->Idents.get("FuncPtr"), |
4625 | 14 | Context->VoidPtrTy, nullptr, |
4626 | 14 | /*BitWidth=*/nullptr, /*Mutable=*/true, |
4627 | 14 | ICIS_NoInit); |
4628 | 14 | MemberExpr *ME = MemberExpr::CreateImplicit( |
4629 | 14 | *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary); |
4630 | | |
4631 | 14 | CastExpr *FunkCast = NoTypeInfoCStyleCastExpr(Context, PtrToFuncCastType, |
4632 | 14 | CK_BitCast, ME); |
4633 | 14 | PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), FunkCast); |
4634 | | |
4635 | 14 | SmallVector<Expr*, 8> BlkExprs; |
4636 | | // Add the implicit argument. |
4637 | 14 | BlkExprs.push_back(BlkCast); |
4638 | | // Add the user arguments. |
4639 | 14 | for (CallExpr::arg_iterator I = Exp->arg_begin(), |
4640 | 22 | E = Exp->arg_end(); I != E; ++I8 ) { |
4641 | 8 | BlkExprs.push_back(*I); |
4642 | 8 | } |
4643 | 14 | CallExpr *CE = |
4644 | 14 | CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(), VK_PRValue, |
4645 | 14 | SourceLocation(), FPOptionsOverride()); |
4646 | 14 | return CE; |
4647 | 14 | } |
4648 | | |
4649 | | // We need to return the rewritten expression to handle cases where the |
4650 | | // DeclRefExpr is embedded in another expression being rewritten. |
4651 | | // For example: |
4652 | | // |
4653 | | // int main() { |
4654 | | // __block Foo *f; |
4655 | | // __block int i; |
4656 | | // |
4657 | | // void (^myblock)() = ^() { |
4658 | | // [f test]; // f is a DeclRefExpr embedded in a message (which is being rewritten). |
4659 | | // i = 77; |
4660 | | // }; |
4661 | | //} |
4662 | 36 | Stmt *RewriteModernObjC::RewriteBlockDeclRefExpr(DeclRefExpr *DeclRefExp) { |
4663 | | // Rewrite the byref variable into BYREFVAR->__forwarding->BYREFVAR |
4664 | | // for each DeclRefExp where BYREFVAR is name of the variable. |
4665 | 36 | ValueDecl *VD = DeclRefExp->getDecl(); |
4666 | 36 | bool isArrow = DeclRefExp->refersToEnclosingVariableOrCapture() || |
4667 | 36 | HasLocalVariableExternalStorage(DeclRefExp->getDecl())8 ; |
4668 | | |
4669 | 36 | FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
4670 | 36 | SourceLocation(), |
4671 | 36 | &Context->Idents.get("__forwarding"), |
4672 | 36 | Context->VoidPtrTy, nullptr, |
4673 | 36 | /*BitWidth=*/nullptr, /*Mutable=*/true, |
4674 | 36 | ICIS_NoInit); |
4675 | 36 | MemberExpr *ME = MemberExpr::CreateImplicit( |
4676 | 36 | *Context, DeclRefExp, isArrow, FD, FD->getType(), VK_LValue, OK_Ordinary); |
4677 | | |
4678 | 36 | StringRef Name = VD->getName(); |
4679 | 36 | FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), SourceLocation(), |
4680 | 36 | &Context->Idents.get(Name), |
4681 | 36 | Context->VoidPtrTy, nullptr, |
4682 | 36 | /*BitWidth=*/nullptr, /*Mutable=*/true, |
4683 | 36 | ICIS_NoInit); |
4684 | 36 | ME = MemberExpr::CreateImplicit(*Context, ME, true, FD, DeclRefExp->getType(), |
4685 | 36 | VK_LValue, OK_Ordinary); |
4686 | | |
4687 | | // Need parens to enforce precedence. |
4688 | 36 | ParenExpr *PE = new (Context) ParenExpr(DeclRefExp->getExprLoc(), |
4689 | 36 | DeclRefExp->getExprLoc(), |
4690 | 36 | ME); |
4691 | 36 | ReplaceStmt(DeclRefExp, PE); |
4692 | 36 | return PE; |
4693 | 36 | } |
4694 | | |
4695 | | // Rewrites the imported local variable V with external storage |
4696 | | // (static, extern, etc.) as *V |
4697 | | // |
4698 | 0 | Stmt *RewriteModernObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) { |
4699 | 0 | ValueDecl *VD = DRE->getDecl(); |
4700 | 0 | if (VarDecl *Var = dyn_cast<VarDecl>(VD)) |
4701 | 0 | if (!ImportedLocalExternalDecls.count(Var)) |
4702 | 0 | return DRE; |
4703 | 0 | Expr *Exp = UnaryOperator::Create( |
4704 | 0 | const_cast<ASTContext &>(*Context), DRE, UO_Deref, DRE->getType(), |
4705 | 0 | VK_LValue, OK_Ordinary, DRE->getLocation(), false, FPOptionsOverride()); |
4706 | | // Need parens to enforce precedence. |
4707 | 0 | ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), |
4708 | 0 | Exp); |
4709 | 0 | ReplaceStmt(DRE, PE); |
4710 | 0 | return PE; |
4711 | 0 | } |
4712 | | |
4713 | 30 | void RewriteModernObjC::RewriteCastExpr(CStyleCastExpr *CE) { |
4714 | 30 | SourceLocation LocStart = CE->getLParenLoc(); |
4715 | 30 | SourceLocation LocEnd = CE->getRParenLoc(); |
4716 | | |
4717 | | // Need to avoid trying to rewrite synthesized casts. |
4718 | 30 | if (LocStart.isInvalid()) |
4719 | 0 | return; |
4720 | | // Need to avoid trying to rewrite casts contained in macros. |
4721 | 30 | if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd)) |
4722 | 0 | return; |
4723 | | |
4724 | 30 | const char *startBuf = SM->getCharacterData(LocStart); |
4725 | 30 | const char *endBuf = SM->getCharacterData(LocEnd); |
4726 | 30 | QualType QT = CE->getType(); |
4727 | 30 | const Type* TypePtr = QT->getAs<Type>(); |
4728 | 30 | if (isa<TypeOfExprType>(TypePtr)) { |
4729 | 4 | const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr); |
4730 | 4 | QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType(); |
4731 | 4 | std::string TypeAsString = "("; |
4732 | 4 | RewriteBlockPointerType(TypeAsString, QT); |
4733 | 4 | TypeAsString += ")"; |
4734 | 4 | ReplaceText(LocStart, endBuf-startBuf+1, TypeAsString); |
4735 | 4 | return; |
4736 | 4 | } |
4737 | | // advance the location to startArgList. |
4738 | 26 | const char *argPtr = startBuf; |
4739 | | |
4740 | 221 | while (*argPtr++ && (argPtr < endBuf)) { |
4741 | 195 | switch (*argPtr) { |
4742 | 0 | case '^': |
4743 | | // Replace the '^' with '*'. |
4744 | 0 | LocStart = LocStart.getLocWithOffset(argPtr-startBuf); |
4745 | 0 | ReplaceText(LocStart, 1, "*"); |
4746 | 0 | break; |
4747 | 195 | } |
4748 | 195 | } |
4749 | 26 | } |
4750 | | |
4751 | 604 | void RewriteModernObjC::RewriteImplicitCastObjCExpr(CastExpr *IC) { |
4752 | 604 | CastKind CastKind = IC->getCastKind(); |
4753 | 604 | if (CastKind != CK_BlockPointerToObjCPointerCast && |
4754 | 604 | CastKind != CK_AnyPointerToBlockPointerCast599 ) |
4755 | 595 | return; |
4756 | | |
4757 | 9 | QualType QT = IC->getType(); |
4758 | 9 | (void)convertBlockPointerToFunctionPointer(QT); |
4759 | 9 | std::string TypeString(QT.getAsString(Context->getPrintingPolicy())); |
4760 | 9 | std::string Str = "("; |
4761 | 9 | Str += TypeString; |
4762 | 9 | Str += ")"; |
4763 | 9 | InsertText(IC->getSubExpr()->getBeginLoc(), Str); |
4764 | 9 | } |
4765 | | |
4766 | 26 | void RewriteModernObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) { |
4767 | 26 | SourceLocation DeclLoc = FD->getLocation(); |
4768 | 26 | unsigned parenCount = 0; |
4769 | | |
4770 | | // We have 1 or more arguments that have closure pointers. |
4771 | 26 | const char *startBuf = SM->getCharacterData(DeclLoc); |
4772 | 26 | const char *startArgList = strchr(startBuf, '('); |
4773 | | |
4774 | 26 | assert((*startArgList == '(') && "Rewriter fuzzy parser confused"); |
4775 | | |
4776 | 26 | parenCount++; |
4777 | | // advance the location to startArgList. |
4778 | 26 | DeclLoc = DeclLoc.getLocWithOffset(startArgList-startBuf); |
4779 | 26 | assert((DeclLoc.isValid()) && "Invalid DeclLoc"); |
4780 | | |
4781 | 26 | const char *argPtr = startArgList; |
4782 | | |
4783 | 488 | while (*argPtr++ && parenCount) { |
4784 | 462 | switch (*argPtr) { |
4785 | 26 | case '^': |
4786 | | // Replace the '^' with '*'. |
4787 | 26 | DeclLoc = DeclLoc.getLocWithOffset(argPtr-startArgList); |
4788 | 26 | ReplaceText(DeclLoc, 1, "*"); |
4789 | 26 | break; |
4790 | 52 | case '(': |
4791 | 52 | parenCount++; |
4792 | 52 | break; |
4793 | 78 | case ')': |
4794 | 78 | parenCount--; |
4795 | 78 | break; |
4796 | 462 | } |
4797 | 462 | } |
4798 | 26 | } |
4799 | | |
4800 | 50 | bool RewriteModernObjC::PointerTypeTakesAnyBlockArguments(QualType QT) { |
4801 | 50 | const FunctionProtoType *FTP; |
4802 | 50 | const PointerType *PT = QT->getAs<PointerType>(); |
4803 | 50 | if (PT) { |
4804 | 2 | FTP = PT->getPointeeType()->getAs<FunctionProtoType>(); |
4805 | 48 | } else { |
4806 | 48 | const BlockPointerType *BPT = QT->getAs<BlockPointerType>(); |
4807 | 48 | assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type"); |
4808 | 48 | FTP = BPT->getPointeeType()->getAs<FunctionProtoType>(); |
4809 | 48 | } |
4810 | 50 | if (FTP) { |
4811 | 50 | for (const auto &I : FTP->param_types()) |
4812 | 29 | if (isTopLevelBlockPointerType(I)) |
4813 | 3 | return true; |
4814 | 50 | } |
4815 | 47 | return false; |
4816 | 50 | } |
4817 | | |
4818 | 45 | bool RewriteModernObjC::PointerTypeTakesAnyObjCQualifiedType(QualType QT) { |
4819 | 45 | const FunctionProtoType *FTP; |
4820 | 45 | const PointerType *PT = QT->getAs<PointerType>(); |
4821 | 45 | if (PT) { |
4822 | 0 | FTP = PT->getPointeeType()->getAs<FunctionProtoType>(); |
4823 | 45 | } else { |
4824 | 45 | const BlockPointerType *BPT = QT->getAs<BlockPointerType>(); |
4825 | 45 | assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type"); |
4826 | 45 | FTP = BPT->getPointeeType()->getAs<FunctionProtoType>(); |
4827 | 45 | } |
4828 | 45 | if (FTP) { |
4829 | 45 | for (const auto &I : FTP->param_types()) { |
4830 | 15 | if (I->isObjCQualifiedIdType()) |
4831 | 5 | return true; |
4832 | 10 | if (I->isObjCObjectPointerType() && |
4833 | 10 | I->getPointeeType()->isObjCQualifiedInterfaceType()6 ) |
4834 | 1 | return true; |
4835 | 10 | } |
4836 | | |
4837 | 45 | } |
4838 | 39 | return false; |
4839 | 45 | } |
4840 | | |
4841 | | void RewriteModernObjC::GetExtentOfArgList(const char *Name, const char *&LParen, |
4842 | 9 | const char *&RParen) { |
4843 | 9 | const char *argPtr = strchr(Name, '('); |
4844 | 9 | assert((*argPtr == '(') && "Rewriter fuzzy parser confused"); |
4845 | | |
4846 | 9 | LParen = argPtr; // output the start. |
4847 | 9 | argPtr++; // skip past the left paren. |
4848 | 9 | unsigned parenCount = 1; |
4849 | | |
4850 | 884 | while (*argPtr && parenCount) { |
4851 | 875 | switch (*argPtr) { |
4852 | 10 | case '(': parenCount++; break; |
4853 | 19 | case ')': parenCount--; break; |
4854 | 846 | default: break; |
4855 | 875 | } |
4856 | 875 | if (parenCount) argPtr++866 ; |
4857 | 875 | } |
4858 | 9 | assert((*argPtr == ')') && "Rewriter fuzzy parser confused"); |
4859 | 9 | RParen = argPtr; // output the end |
4860 | 9 | } |
4861 | | |
4862 | 74 | void RewriteModernObjC::RewriteBlockPointerDecl(NamedDecl *ND) { |
4863 | 74 | if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { |
4864 | 26 | RewriteBlockPointerFunctionArgs(FD); |
4865 | 26 | return; |
4866 | 26 | } |
4867 | | // Handle Variables and Typedefs. |
4868 | 48 | SourceLocation DeclLoc = ND->getLocation(); |
4869 | 48 | QualType DeclT; |
4870 | 48 | if (VarDecl *VD = dyn_cast<VarDecl>(ND)) |
4871 | 28 | DeclT = VD->getType(); |
4872 | 20 | else if (TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(ND)) |
4873 | 19 | DeclT = TDD->getUnderlyingType(); |
4874 | 1 | else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND)) |
4875 | 1 | DeclT = FD->getType(); |
4876 | 0 | else |
4877 | 0 | llvm_unreachable("RewriteBlockPointerDecl(): Decl type not yet handled"); |
4878 | | |
4879 | 48 | const char *startBuf = SM->getCharacterData(DeclLoc); |
4880 | 48 | const char *endBuf = startBuf; |
4881 | | // scan backward (from the decl location) for the end of the previous decl. |
4882 | 98 | while (*startBuf != '^' && *startBuf != ';'50 && startBuf != MainFileStart50 ) |
4883 | 50 | startBuf--; |
4884 | 48 | SourceLocation Start = DeclLoc.getLocWithOffset(startBuf-endBuf); |
4885 | 48 | std::string buf; |
4886 | 48 | unsigned OrigLength=0; |
4887 | | // *startBuf != '^' if we are dealing with a pointer to function that |
4888 | | // may take block argument types (which will be handled below). |
4889 | 48 | if (*startBuf == '^') { |
4890 | | // Replace the '^' with '*', computing a negative offset. |
4891 | 48 | buf = '*'; |
4892 | 48 | startBuf++; |
4893 | 48 | OrigLength++; |
4894 | 48 | } |
4895 | 432 | while (*startBuf != ')') { |
4896 | 384 | buf += *startBuf; |
4897 | 384 | startBuf++; |
4898 | 384 | OrigLength++; |
4899 | 384 | } |
4900 | 48 | buf += ')'; |
4901 | 48 | OrigLength++; |
4902 | | |
4903 | 48 | if (PointerTypeTakesAnyBlockArguments(DeclT) || |
4904 | 48 | PointerTypeTakesAnyObjCQualifiedType(DeclT)45 ) { |
4905 | | // Replace the '^' with '*' for arguments. |
4906 | | // Replace id<P> with id/*<>*/ |
4907 | 9 | DeclLoc = ND->getLocation(); |
4908 | 9 | startBuf = SM->getCharacterData(DeclLoc); |
4909 | 9 | const char *argListBegin, *argListEnd; |
4910 | 9 | GetExtentOfArgList(startBuf, argListBegin, argListEnd); |
4911 | 453 | while (argListBegin < argListEnd) { |
4912 | 444 | if (*argListBegin == '^') |
4913 | 5 | buf += '*'; |
4914 | 439 | else if (*argListBegin == '<') { |
4915 | 17 | buf += "/*"; |
4916 | 17 | buf += *argListBegin++; |
4917 | 17 | OrigLength++; |
4918 | 431 | while (*argListBegin != '>') { |
4919 | 414 | buf += *argListBegin++; |
4920 | 414 | OrigLength++; |
4921 | 414 | } |
4922 | 17 | buf += *argListBegin; |
4923 | 17 | buf += "*/"; |
4924 | 17 | } |
4925 | 422 | else |
4926 | 422 | buf += *argListBegin; |
4927 | 444 | argListBegin++; |
4928 | 444 | OrigLength++; |
4929 | 444 | } |
4930 | 9 | buf += ')'; |
4931 | 9 | OrigLength++; |
4932 | 9 | } |
4933 | 48 | ReplaceText(Start, OrigLength, buf); |
4934 | 48 | } |
4935 | | |
4936 | | /// SynthesizeByrefCopyDestroyHelper - This routine synthesizes: |
4937 | | /// void __Block_byref_id_object_copy(struct Block_byref_id_object *dst, |
4938 | | /// struct Block_byref_id_object *src) { |
4939 | | /// _Block_object_assign (&_dest->object, _src->object, |
4940 | | /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT |
4941 | | /// [|BLOCK_FIELD_IS_WEAK]) // object |
4942 | | /// _Block_object_assign(&_dest->object, _src->object, |
4943 | | /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK |
4944 | | /// [|BLOCK_FIELD_IS_WEAK]) // block |
4945 | | /// } |
4946 | | /// And: |
4947 | | /// void __Block_byref_id_object_dispose(struct Block_byref_id_object *_src) { |
4948 | | /// _Block_object_dispose(_src->object, |
4949 | | /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT |
4950 | | /// [|BLOCK_FIELD_IS_WEAK]) // object |
4951 | | /// _Block_object_dispose(_src->object, |
4952 | | /// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK |
4953 | | /// [|BLOCK_FIELD_IS_WEAK]) // block |
4954 | | /// } |
4955 | | |
4956 | | std::string RewriteModernObjC::SynthesizeByrefCopyDestroyHelper(VarDecl *VD, |
4957 | 6 | int flag) { |
4958 | 6 | std::string S; |
4959 | 6 | if (CopyDestroyCache.count(flag)) |
4960 | 2 | return S; |
4961 | 4 | CopyDestroyCache.insert(flag); |
4962 | 4 | S = "static void __Block_byref_id_object_copy_"; |
4963 | 4 | S += utostr(flag); |
4964 | 4 | S += "(void *dst, void *src) {\n"; |
4965 | | |
4966 | | // offset into the object pointer is computed as: |
4967 | | // void * + void* + int + int + void* + void * |
4968 | 4 | unsigned IntSize = |
4969 | 4 | static_cast<unsigned>(Context->getTypeSize(Context->IntTy)); |
4970 | 4 | unsigned VoidPtrSize = |
4971 | 4 | static_cast<unsigned>(Context->getTypeSize(Context->VoidPtrTy)); |
4972 | | |
4973 | 4 | unsigned offset = (VoidPtrSize*4 + IntSize + IntSize)/Context->getCharWidth(); |
4974 | 4 | S += " _Block_object_assign((char*)dst + "; |
4975 | 4 | S += utostr(offset); |
4976 | 4 | S += ", *(void * *) ((char*)src + "; |
4977 | 4 | S += utostr(offset); |
4978 | 4 | S += "), "; |
4979 | 4 | S += utostr(flag); |
4980 | 4 | S += ");\n}\n"; |
4981 | | |
4982 | 4 | S += "static void __Block_byref_id_object_dispose_"; |
4983 | 4 | S += utostr(flag); |
4984 | 4 | S += "(void *src) {\n"; |
4985 | 4 | S += " _Block_object_dispose(*(void * *) ((char*)src + "; |
4986 | 4 | S += utostr(offset); |
4987 | 4 | S += "), "; |
4988 | 4 | S += utostr(flag); |
4989 | 4 | S += ");\n}\n"; |
4990 | 4 | return S; |
4991 | 6 | } |
4992 | | |
4993 | | /// RewriteByRefVar - For each __block typex ND variable this routine transforms |
4994 | | /// the declaration into: |
4995 | | /// struct __Block_byref_ND { |
4996 | | /// void *__isa; // NULL for everything except __weak pointers |
4997 | | /// struct __Block_byref_ND *__forwarding; |
4998 | | /// int32_t __flags; |
4999 | | /// int32_t __size; |
5000 | | /// void *__Block_byref_id_object_copy; // If variable is __block ObjC object |
5001 | | /// void *__Block_byref_id_object_dispose; // If variable is __block ObjC object |
5002 | | /// typex ND; |
5003 | | /// }; |
5004 | | /// |
5005 | | /// It then replaces declaration of ND variable with: |
5006 | | /// struct __Block_byref_ND ND = {__isa=0B, __forwarding=&ND, __flags=some_flag, |
5007 | | /// __size=sizeof(struct __Block_byref_ND), |
5008 | | /// ND=initializer-if-any}; |
5009 | | /// |
5010 | | /// |
5011 | | void RewriteModernObjC::RewriteByRefVar(VarDecl *ND, bool firstDecl, |
5012 | 42 | bool lastDecl) { |
5013 | 42 | int flag = 0; |
5014 | 42 | int isa = 0; |
5015 | 42 | SourceLocation DeclLoc = ND->getTypeSpecStartLoc(); |
5016 | 42 | if (DeclLoc.isInvalid()) |
5017 | | // If type location is missing, it is because of missing type (a warning). |
5018 | | // Use variable's location which is good for this case. |
5019 | 0 | DeclLoc = ND->getLocation(); |
5020 | 42 | const char *startBuf = SM->getCharacterData(DeclLoc); |
5021 | 42 | SourceLocation X = ND->getEndLoc(); |
5022 | 42 | X = SM->getExpansionLoc(X); |
5023 | 42 | const char *endBuf = SM->getCharacterData(X); |
5024 | 42 | std::string Name(ND->getNameAsString()); |
5025 | 42 | std::string ByrefType; |
5026 | 42 | RewriteByRefString(ByrefType, Name, ND, true); |
5027 | 42 | ByrefType += " {\n"; |
5028 | 42 | ByrefType += " void *__isa;\n"; |
5029 | 42 | RewriteByRefString(ByrefType, Name, ND); |
5030 | 42 | ByrefType += " *__forwarding;\n"; |
5031 | 42 | ByrefType += " int __flags;\n"; |
5032 | 42 | ByrefType += " int __size;\n"; |
5033 | | // Add void *__Block_byref_id_object_copy; |
5034 | | // void *__Block_byref_id_object_dispose; if needed. |
5035 | 42 | QualType Ty = ND->getType(); |
5036 | 42 | bool HasCopyAndDispose = Context->BlockRequiresCopying(Ty, ND); |
5037 | 42 | if (HasCopyAndDispose) { |
5038 | 6 | ByrefType += " void (*__Block_byref_id_object_copy)(void*, void*);\n"; |
5039 | 6 | ByrefType += " void (*__Block_byref_id_object_dispose)(void*);\n"; |
5040 | 6 | } |
5041 | | |
5042 | 42 | QualType T = Ty; |
5043 | 42 | (void)convertBlockPointerToFunctionPointer(T); |
5044 | 42 | T.getAsStringInternal(Name, Context->getPrintingPolicy()); |
5045 | | |
5046 | 42 | ByrefType += " " + Name + ";\n"; |
5047 | 42 | ByrefType += "};\n"; |
5048 | | // Insert this type in global scope. It is needed by helper function. |
5049 | 42 | SourceLocation FunLocStart; |
5050 | 42 | if (CurFunctionDef) |
5051 | 33 | FunLocStart = getFunctionSourceLocation(*this, CurFunctionDef); |
5052 | 9 | else { |
5053 | 9 | assert(CurMethodDef && "RewriteByRefVar - CurMethodDef is null"); |
5054 | 9 | FunLocStart = CurMethodDef->getBeginLoc(); |
5055 | 9 | } |
5056 | 42 | InsertText(FunLocStart, ByrefType); |
5057 | | |
5058 | 42 | if (Ty.isObjCGCWeak()) { |
5059 | 0 | flag |= BLOCK_FIELD_IS_WEAK; |
5060 | 0 | isa = 1; |
5061 | 0 | } |
5062 | 42 | if (HasCopyAndDispose) { |
5063 | 6 | flag = BLOCK_BYREF_CALLER; |
5064 | 6 | QualType Ty = ND->getType(); |
5065 | | // FIXME. Handle __weak variable (BLOCK_FIELD_IS_WEAK) as well. |
5066 | 6 | if (Ty->isBlockPointerType()) |
5067 | 4 | flag |= BLOCK_FIELD_IS_BLOCK; |
5068 | 2 | else |
5069 | 2 | flag |= BLOCK_FIELD_IS_OBJECT; |
5070 | 6 | std::string HF = SynthesizeByrefCopyDestroyHelper(ND, flag); |
5071 | 6 | if (!HF.empty()) |
5072 | 4 | Preamble += HF; |
5073 | 6 | } |
5074 | | |
5075 | | // struct __Block_byref_ND ND = |
5076 | | // {0, &ND, some_flag, __size=sizeof(struct __Block_byref_ND), |
5077 | | // initializer-if-any}; |
5078 | 42 | bool hasInit = (ND->getInit() != nullptr); |
5079 | | // FIXME. rewriter does not support __block c++ objects which |
5080 | | // require construction. |
5081 | 42 | if (hasInit) |
5082 | 26 | if (CXXConstructExpr *CExp = dyn_cast<CXXConstructExpr>(ND->getInit())) { |
5083 | 1 | CXXConstructorDecl *CXXDecl = CExp->getConstructor(); |
5084 | 1 | if (CXXDecl && CXXDecl->isDefaultConstructor()) |
5085 | 1 | hasInit = false; |
5086 | 1 | } |
5087 | | |
5088 | 42 | unsigned flags = 0; |
5089 | 42 | if (HasCopyAndDispose) |
5090 | 6 | flags |= BLOCK_HAS_COPY_DISPOSE; |
5091 | 42 | Name = ND->getNameAsString(); |
5092 | 42 | ByrefType.clear(); |
5093 | 42 | RewriteByRefString(ByrefType, Name, ND); |
5094 | 42 | std::string ForwardingCastType("("); |
5095 | 42 | ForwardingCastType += ByrefType + " *)"; |
5096 | 42 | ByrefType += " " + Name + " = {(void*)"; |
5097 | 42 | ByrefType += utostr(isa); |
5098 | 42 | ByrefType += "," + ForwardingCastType + "&" + Name + ", "; |
5099 | 42 | ByrefType += utostr(flags); |
5100 | 42 | ByrefType += ", "; |
5101 | 42 | ByrefType += "sizeof("; |
5102 | 42 | RewriteByRefString(ByrefType, Name, ND); |
5103 | 42 | ByrefType += ")"; |
5104 | 42 | if (HasCopyAndDispose) { |
5105 | 6 | ByrefType += ", __Block_byref_id_object_copy_"; |
5106 | 6 | ByrefType += utostr(flag); |
5107 | 6 | ByrefType += ", __Block_byref_id_object_dispose_"; |
5108 | 6 | ByrefType += utostr(flag); |
5109 | 6 | } |
5110 | | |
5111 | 42 | if (!firstDecl) { |
5112 | | // In multiple __block declarations, and for all but 1st declaration, |
5113 | | // find location of the separating comma. This would be start location |
5114 | | // where new text is to be inserted. |
5115 | 10 | DeclLoc = ND->getLocation(); |
5116 | 10 | const char *startDeclBuf = SM->getCharacterData(DeclLoc); |
5117 | 10 | const char *commaBuf = startDeclBuf; |
5118 | 37 | while (*commaBuf != ',') |
5119 | 27 | commaBuf--; |
5120 | 10 | assert((*commaBuf == ',') && "RewriteByRefVar: can't find ','"); |
5121 | 10 | DeclLoc = DeclLoc.getLocWithOffset(commaBuf - startDeclBuf); |
5122 | 10 | startBuf = commaBuf; |
5123 | 10 | } |
5124 | | |
5125 | 42 | if (!hasInit) { |
5126 | 17 | ByrefType += "};\n"; |
5127 | 17 | unsigned nameSize = Name.size(); |
5128 | | // for block or function pointer declaration. Name is already |
5129 | | // part of the declaration. |
5130 | 17 | if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()13 ) |
5131 | 4 | nameSize = 1; |
5132 | 17 | ReplaceText(DeclLoc, endBuf-startBuf+nameSize, ByrefType); |
5133 | 17 | } |
5134 | 25 | else { |
5135 | 25 | ByrefType += ", "; |
5136 | 25 | SourceLocation startLoc; |
5137 | 25 | Expr *E = ND->getInit(); |
5138 | 25 | if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) |
5139 | 1 | startLoc = ECE->getLParenLoc(); |
5140 | 24 | else |
5141 | 24 | startLoc = E->getBeginLoc(); |
5142 | 25 | startLoc = SM->getExpansionLoc(startLoc); |
5143 | 25 | endBuf = SM->getCharacterData(startLoc); |
5144 | 25 | ReplaceText(DeclLoc, endBuf-startBuf, ByrefType); |
5145 | | |
5146 | 25 | const char separator = lastDecl ? ';'21 : ','4 ; |
5147 | 25 | const char *startInitializerBuf = SM->getCharacterData(startLoc); |
5148 | 25 | const char *separatorBuf = strchr(startInitializerBuf, separator); |
5149 | 25 | assert((*separatorBuf == separator) && |
5150 | 25 | "RewriteByRefVar: can't find ';' or ','"); |
5151 | 25 | SourceLocation separatorLoc = |
5152 | 25 | startLoc.getLocWithOffset(separatorBuf-startInitializerBuf); |
5153 | | |
5154 | 25 | InsertText(separatorLoc, lastDecl ? "}"21 : "};\n"4 ); |
5155 | 25 | } |
5156 | 42 | } |
5157 | | |
5158 | 160 | void RewriteModernObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) { |
5159 | | // Add initializers for any closure decl refs. |
5160 | 160 | GetBlockDeclRefExprs(Exp->getBody()); |
5161 | 160 | if (BlockDeclRefs.size()) { |
5162 | | // Unique all "by copy" declarations. |
5163 | 180 | for (unsigned i = 0; i < BlockDeclRefs.size(); i++112 ) |
5164 | 112 | if (!BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>()) { |
5165 | 54 | if (!BlockByCopyDeclsPtrSet.count(BlockDeclRefs[i]->getDecl())) { |
5166 | 48 | BlockByCopyDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl()); |
5167 | 48 | BlockByCopyDecls.push_back(BlockDeclRefs[i]->getDecl()); |
5168 | 48 | } |
5169 | 54 | } |
5170 | | // Unique all "by ref" declarations. |
5171 | 180 | for (unsigned i = 0; i < BlockDeclRefs.size(); i++112 ) |
5172 | 112 | if (BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>()) { |
5173 | 58 | if (!BlockByRefDeclsPtrSet.count(BlockDeclRefs[i]->getDecl())) { |
5174 | 56 | BlockByRefDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl()); |
5175 | 56 | BlockByRefDecls.push_back(BlockDeclRefs[i]->getDecl()); |
5176 | 56 | } |
5177 | 58 | } |
5178 | | // Find any imported blocks...they will need special attention. |
5179 | 180 | for (unsigned i = 0; i < BlockDeclRefs.size(); i++112 ) |
5180 | 112 | if (BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() || |
5181 | 112 | BlockDeclRefs[i]->getType()->isObjCObjectPointerType()54 || |
5182 | 112 | BlockDeclRefs[i]->getType()->isBlockPointerType()22 ) |
5183 | 96 | ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl()); |
5184 | 68 | } |
5185 | 160 | } |
5186 | | |
5187 | 244 | FunctionDecl *RewriteModernObjC::SynthBlockInitFunctionDecl(StringRef name) { |
5188 | 244 | IdentifierInfo *ID = &Context->Idents.get(name); |
5189 | 244 | QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy); |
5190 | 244 | return FunctionDecl::Create(*Context, TUDecl, SourceLocation(), |
5191 | 244 | SourceLocation(), ID, FType, nullptr, SC_Extern, |
5192 | 244 | false, false); |
5193 | 244 | } |
5194 | | |
5195 | | Stmt *RewriteModernObjC::SynthBlockInitExpr(BlockExpr *Exp, |
5196 | 80 | const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs) { |
5197 | 80 | const BlockDecl *block = Exp->getBlockDecl(); |
5198 | | |
5199 | 80 | Blocks.push_back(Exp); |
5200 | | |
5201 | 80 | CollectBlockDeclRefInfo(Exp); |
5202 | | |
5203 | | // Add inner imported variables now used in current block. |
5204 | 80 | int countOfInnerDecls = 0; |
5205 | 80 | if (!InnerBlockDeclRefs.empty()) { |
5206 | 130 | for (unsigned i = 0; i < InnerBlockDeclRefs.size(); i++88 ) { |
5207 | 88 | DeclRefExpr *Exp = InnerBlockDeclRefs[i]; |
5208 | 88 | ValueDecl *VD = Exp->getDecl(); |
5209 | 88 | if (!VD->hasAttr<BlocksAttr>() && !BlockByCopyDeclsPtrSet.count(VD)39 ) { |
5210 | | // We need to save the copied-in variables in nested |
5211 | | // blocks because it is needed at the end for some of the API generations. |
5212 | | // See SynthesizeBlockLiterals routine. |
5213 | 12 | InnerDeclRefs.push_back(Exp); countOfInnerDecls++; |
5214 | 12 | BlockDeclRefs.push_back(Exp); |
5215 | 12 | BlockByCopyDeclsPtrSet.insert(VD); |
5216 | 12 | BlockByCopyDecls.push_back(VD); |
5217 | 12 | } |
5218 | 88 | if (VD->hasAttr<BlocksAttr>() && !BlockByRefDeclsPtrSet.count(VD)49 ) { |
5219 | 13 | InnerDeclRefs.push_back(Exp); countOfInnerDecls++; |
5220 | 13 | BlockDeclRefs.push_back(Exp); |
5221 | 13 | BlockByRefDeclsPtrSet.insert(VD); |
5222 | 13 | BlockByRefDecls.push_back(VD); |
5223 | 13 | } |
5224 | 88 | } |
5225 | | // Find any imported blocks...they will need special attention. |
5226 | 130 | for (unsigned i = 0; i < InnerBlockDeclRefs.size(); i++88 ) |
5227 | 88 | if (InnerBlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() || |
5228 | 88 | InnerBlockDeclRefs[i]->getType()->isObjCObjectPointerType()39 || |
5229 | 88 | InnerBlockDeclRefs[i]->getType()->isBlockPointerType()11 ) |
5230 | 79 | ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl()); |
5231 | 42 | } |
5232 | 80 | InnerDeclRefsCount.push_back(countOfInnerDecls); |
5233 | | |
5234 | 80 | std::string FuncName; |
5235 | | |
5236 | 80 | if (CurFunctionDef) |
5237 | 53 | FuncName = CurFunctionDef->getNameAsString(); |
5238 | 27 | else if (CurMethodDef) |
5239 | 21 | BuildUniqueMethodName(FuncName, CurMethodDef); |
5240 | 6 | else if (GlobalVarDecl) |
5241 | 6 | FuncName = std::string(GlobalVarDecl->getNameAsString()); |
5242 | | |
5243 | 80 | bool GlobalBlockExpr = |
5244 | 80 | block->getDeclContext()->getRedeclContext()->isFileContext(); |
5245 | | |
5246 | 80 | if (GlobalBlockExpr && !GlobalVarDecl6 ) { |
5247 | 0 | Diags.Report(block->getLocation(), GlobalBlockRewriteFailedDiag); |
5248 | 0 | GlobalBlockExpr = false; |
5249 | 0 | } |
5250 | | |
5251 | 80 | std::string BlockNumber = utostr(Blocks.size()-1); |
5252 | | |
5253 | 80 | std::string Func = "__" + FuncName + "_block_func_" + BlockNumber; |
5254 | | |
5255 | | // Get a pointer to the function type so we can cast appropriately. |
5256 | 80 | QualType BFT = convertFunctionTypeOfBlocks(Exp->getFunctionType()); |
5257 | 80 | QualType FType = Context->getPointerType(BFT); |
5258 | | |
5259 | 80 | FunctionDecl *FD; |
5260 | 80 | Expr *NewRep; |
5261 | | |
5262 | | // Simulate a constructor call... |
5263 | 80 | std::string Tag; |
5264 | | |
5265 | 80 | if (GlobalBlockExpr) |
5266 | 6 | Tag = "__global_"; |
5267 | 74 | else |
5268 | 74 | Tag = "__"; |
5269 | 80 | Tag += FuncName + "_block_impl_" + BlockNumber; |
5270 | | |
5271 | 80 | FD = SynthBlockInitFunctionDecl(Tag); |
5272 | 80 | DeclRefExpr *DRE = new (Context) |
5273 | 80 | DeclRefExpr(*Context, FD, false, FType, VK_PRValue, SourceLocation()); |
5274 | | |
5275 | 80 | SmallVector<Expr*, 4> InitExprs; |
5276 | | |
5277 | | // Initialize the block function. |
5278 | 80 | FD = SynthBlockInitFunctionDecl(Func); |
5279 | 80 | DeclRefExpr *Arg = new (Context) DeclRefExpr( |
5280 | 80 | *Context, FD, false, FD->getType(), VK_LValue, SourceLocation()); |
5281 | 80 | CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, |
5282 | 80 | CK_BitCast, Arg); |
5283 | 80 | InitExprs.push_back(castExpr); |
5284 | | |
5285 | | // Initialize the block descriptor. |
5286 | 80 | std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA"; |
5287 | | |
5288 | 80 | VarDecl *NewVD = VarDecl::Create( |
5289 | 80 | *Context, TUDecl, SourceLocation(), SourceLocation(), |
5290 | 80 | &Context->Idents.get(DescData), Context->VoidPtrTy, nullptr, SC_Static); |
5291 | 80 | UnaryOperator *DescRefExpr = UnaryOperator::Create( |
5292 | 80 | const_cast<ASTContext &>(*Context), |
5293 | 80 | new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy, |
5294 | 80 | VK_LValue, SourceLocation()), |
5295 | 80 | UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_PRValue, |
5296 | 80 | OK_Ordinary, SourceLocation(), false, FPOptionsOverride()); |
5297 | 80 | InitExprs.push_back(DescRefExpr); |
5298 | | |
5299 | | // Add initializers for any closure decl refs. |
5300 | 80 | if (BlockDeclRefs.size()) { |
5301 | 43 | Expr *Exp; |
5302 | | // Output all "by copy" declarations. |
5303 | 43 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(), |
5304 | 79 | E = BlockByCopyDecls.end(); I != E; ++I36 ) { |
5305 | 36 | if (isObjCType((*I)->getType())) { |
5306 | | // FIXME: Conform to ABI ([[obj retain] autorelease]). |
5307 | 3 | FD = SynthBlockInitFunctionDecl((*I)->getName()); |
5308 | 3 | Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), |
5309 | 3 | VK_LValue, SourceLocation()); |
5310 | 3 | if (HasLocalVariableExternalStorage(*I)) { |
5311 | 0 | QualType QT = (*I)->getType(); |
5312 | 0 | QT = Context->getPointerType(QT); |
5313 | 0 | Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp, |
5314 | 0 | UO_AddrOf, QT, VK_PRValue, OK_Ordinary, |
5315 | 0 | SourceLocation(), false, |
5316 | 0 | FPOptionsOverride()); |
5317 | 0 | } |
5318 | 33 | } else if (isTopLevelBlockPointerType((*I)->getType())) { |
5319 | 2 | FD = SynthBlockInitFunctionDecl((*I)->getName()); |
5320 | 2 | Arg = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), |
5321 | 2 | VK_LValue, SourceLocation()); |
5322 | 2 | Exp = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, |
5323 | 2 | CK_BitCast, Arg); |
5324 | 31 | } else { |
5325 | 31 | FD = SynthBlockInitFunctionDecl((*I)->getName()); |
5326 | 31 | Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), |
5327 | 31 | VK_LValue, SourceLocation()); |
5328 | 31 | if (HasLocalVariableExternalStorage(*I)) { |
5329 | 0 | QualType QT = (*I)->getType(); |
5330 | 0 | QT = Context->getPointerType(QT); |
5331 | 0 | Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp, |
5332 | 0 | UO_AddrOf, QT, VK_PRValue, OK_Ordinary, |
5333 | 0 | SourceLocation(), false, |
5334 | 0 | FPOptionsOverride()); |
5335 | 0 | } |
5336 | | |
5337 | 31 | } |
5338 | 36 | InitExprs.push_back(Exp); |
5339 | 36 | } |
5340 | | // Output all "by ref" declarations. |
5341 | 43 | for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(), |
5342 | 84 | E = BlockByRefDecls.end(); I != E; ++I41 ) { |
5343 | 41 | ValueDecl *ND = (*I); |
5344 | 41 | std::string Name(ND->getNameAsString()); |
5345 | 41 | std::string RecName; |
5346 | 41 | RewriteByRefString(RecName, Name, ND, true); |
5347 | 41 | IdentifierInfo *II = &Context->Idents.get(RecName.c_str() |
5348 | 41 | + sizeof("struct")); |
5349 | 41 | RecordDecl *RD = |
5350 | 41 | RecordDecl::Create(*Context, TagTypeKind::Struct, TUDecl, |
5351 | 41 | SourceLocation(), SourceLocation(), II); |
5352 | 41 | assert(RD && "SynthBlockInitExpr(): Can't find RecordDecl"); |
5353 | 41 | QualType castT = Context->getPointerType(Context->getTagDeclType(RD)); |
5354 | | |
5355 | 41 | FD = SynthBlockInitFunctionDecl((*I)->getName()); |
5356 | 41 | Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), |
5357 | 41 | VK_LValue, SourceLocation()); |
5358 | 41 | bool isNestedCapturedVar = false; |
5359 | 90 | for (const auto &CI : block->captures()) { |
5360 | 90 | const VarDecl *variable = CI.getVariable(); |
5361 | 90 | if (variable == ND && CI.isNested()40 ) { |
5362 | 17 | assert(CI.isByRef() && |
5363 | 17 | "SynthBlockInitExpr - captured block variable is not byref"); |
5364 | 17 | isNestedCapturedVar = true; |
5365 | 17 | break; |
5366 | 17 | } |
5367 | 90 | } |
5368 | | // captured nested byref variable has its address passed. Do not take |
5369 | | // its address again. |
5370 | 41 | if (!isNestedCapturedVar) |
5371 | 24 | Exp = UnaryOperator::Create( |
5372 | 24 | const_cast<ASTContext &>(*Context), Exp, UO_AddrOf, |
5373 | 24 | Context->getPointerType(Exp->getType()), VK_PRValue, OK_Ordinary, |
5374 | 24 | SourceLocation(), false, FPOptionsOverride()); |
5375 | 41 | Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp); |
5376 | 41 | InitExprs.push_back(Exp); |
5377 | 41 | } |
5378 | 43 | } |
5379 | 80 | if (ImportedBlockDecls.size()) { |
5380 | | // generate BLOCK_HAS_COPY_DISPOSE(have helper funcs) | BLOCK_HAS_DESCRIPTOR |
5381 | 37 | int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR); |
5382 | 37 | unsigned IntSize = |
5383 | 37 | static_cast<unsigned>(Context->getTypeSize(Context->IntTy)); |
5384 | 37 | Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag), |
5385 | 37 | Context->IntTy, SourceLocation()); |
5386 | 37 | InitExprs.push_back(FlagExp); |
5387 | 37 | } |
5388 | 80 | NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue, |
5389 | 80 | SourceLocation(), FPOptionsOverride()); |
5390 | | |
5391 | 80 | if (GlobalBlockExpr) { |
5392 | 6 | assert (!GlobalConstructionExp && |
5393 | 6 | "SynthBlockInitExpr - GlobalConstructionExp must be null"); |
5394 | 6 | GlobalConstructionExp = NewRep; |
5395 | 6 | NewRep = DRE; |
5396 | 6 | } |
5397 | | |
5398 | 80 | NewRep = UnaryOperator::Create( |
5399 | 80 | const_cast<ASTContext &>(*Context), NewRep, UO_AddrOf, |
5400 | 80 | Context->getPointerType(NewRep->getType()), VK_PRValue, OK_Ordinary, |
5401 | 80 | SourceLocation(), false, FPOptionsOverride()); |
5402 | 80 | NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast, |
5403 | 80 | NewRep); |
5404 | | // Put Paren around the call. |
5405 | 80 | NewRep = new (Context) ParenExpr(SourceLocation(), SourceLocation(), |
5406 | 80 | NewRep); |
5407 | | |
5408 | 80 | BlockDeclRefs.clear(); |
5409 | 80 | BlockByRefDecls.clear(); |
5410 | 80 | BlockByRefDeclsPtrSet.clear(); |
5411 | 80 | BlockByCopyDecls.clear(); |
5412 | 80 | BlockByCopyDeclsPtrSet.clear(); |
5413 | 80 | ImportedBlockDecls.clear(); |
5414 | 80 | return NewRep; |
5415 | 80 | } |
5416 | | |
5417 | 5 | bool RewriteModernObjC::IsDeclStmtInForeachHeader(DeclStmt *DS) { |
5418 | 5 | if (const ObjCForCollectionStmt * CS = |
5419 | 5 | dyn_cast<ObjCForCollectionStmt>(Stmts.back())) |
5420 | 5 | return CS->getElement() == DS; |
5421 | 0 | return false; |
5422 | 5 | } |
5423 | | |
5424 | | //===----------------------------------------------------------------------===// |
5425 | | // Function Body / Expression rewriting |
5426 | | //===----------------------------------------------------------------------===// |
5427 | | |
5428 | 2.70k | Stmt *RewriteModernObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { |
5429 | 2.70k | if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || |
5430 | 2.70k | isa<DoStmt>(S)2.69k || isa<ForStmt>(S)2.69k ) |
5431 | 5 | Stmts.push_back(S); |
5432 | 2.69k | else if (isa<ObjCForCollectionStmt>(S)) { |
5433 | 5 | Stmts.push_back(S); |
5434 | 5 | ObjCBcLabelNo.push_back(++BcLabelCount); |
5435 | 5 | } |
5436 | | |
5437 | | // Pseudo-object operations and ivar references need special |
5438 | | // treatment because we're going to recursively rewrite them. |
5439 | 2.70k | if (PseudoObjectExpr *PseudoOp = dyn_cast<PseudoObjectExpr>(S)) { |
5440 | 33 | if (isa<BinaryOperator>(PseudoOp->getSyntacticForm())) { |
5441 | 13 | return RewritePropertyOrImplicitSetter(PseudoOp); |
5442 | 20 | } else { |
5443 | 20 | return RewritePropertyOrImplicitGetter(PseudoOp); |
5444 | 20 | } |
5445 | 2.67k | } else if (ObjCIvarRefExpr *IvarRefExpr = dyn_cast<ObjCIvarRefExpr>(S)) { |
5446 | 97 | return RewriteObjCIvarRefExpr(IvarRefExpr); |
5447 | 97 | } |
5448 | 2.57k | else if (isa<OpaqueValueExpr>(S)) |
5449 | 12 | S = cast<OpaqueValueExpr>(S)->getSourceExpr(); |
5450 | | |
5451 | 2.57k | SourceRange OrigStmtRange = S->getSourceRange(); |
5452 | | |
5453 | | // Perform a bottom up rewrite of all children. |
5454 | 2.57k | for (Stmt *&childStmt : S->children()) |
5455 | 2.30k | if (childStmt) { |
5456 | 2.30k | Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt); |
5457 | 2.30k | if (newStmt) { |
5458 | 2.27k | childStmt = newStmt; |
5459 | 2.27k | } |
5460 | 2.30k | } |
5461 | | |
5462 | 2.57k | if (BlockExpr *BE = dyn_cast<BlockExpr>(S)) { |
5463 | 80 | SmallVector<DeclRefExpr *, 8> InnerBlockDeclRefs; |
5464 | 80 | llvm::SmallPtrSet<const DeclContext *, 8> InnerContexts; |
5465 | 80 | InnerContexts.insert(BE->getBlockDecl()); |
5466 | 80 | ImportedLocalExternalDecls.clear(); |
5467 | 80 | GetInnerBlockDeclRefExprs(BE->getBody(), |
5468 | 80 | InnerBlockDeclRefs, InnerContexts); |
5469 | | // Rewrite the block body in place. |
5470 | 80 | Stmt *SaveCurrentBody = CurrentBody; |
5471 | 80 | CurrentBody = BE->getBody(); |
5472 | 80 | PropParentMap = nullptr; |
5473 | | // block literal on rhs of a property-dot-sytax assignment |
5474 | | // must be replaced by its synthesize ast so getRewrittenText |
5475 | | // works as expected. In this case, what actually ends up on RHS |
5476 | | // is the blockTranscribed which is the helper function for the |
5477 | | // block literal; as in: self.c = ^() {[ace ARR];}; |
5478 | 80 | bool saveDisableReplaceStmt = DisableReplaceStmt; |
5479 | 80 | DisableReplaceStmt = false; |
5480 | 80 | RewriteFunctionBodyOrGlobalInitializer(BE->getBody()); |
5481 | 80 | DisableReplaceStmt = saveDisableReplaceStmt; |
5482 | 80 | CurrentBody = SaveCurrentBody; |
5483 | 80 | PropParentMap = nullptr; |
5484 | 80 | ImportedLocalExternalDecls.clear(); |
5485 | | // Now we snarf the rewritten text and stash it away for later use. |
5486 | 80 | std::string Str = Rewrite.getRewrittenText(BE->getSourceRange()); |
5487 | 80 | RewrittenBlockExprs[BE] = Str; |
5488 | | |
5489 | 80 | Stmt *blockTranscribed = SynthBlockInitExpr(BE, InnerBlockDeclRefs); |
5490 | | |
5491 | | //blockTranscribed->dump(); |
5492 | 80 | ReplaceStmt(S, blockTranscribed); |
5493 | 80 | return blockTranscribed; |
5494 | 80 | } |
5495 | | // Handle specific things. |
5496 | 2.49k | if (ObjCEncodeExpr *AtEncode = dyn_cast<ObjCEncodeExpr>(S)) |
5497 | 3 | return RewriteAtEncode(AtEncode); |
5498 | | |
5499 | 2.49k | if (ObjCSelectorExpr *AtSelector = dyn_cast<ObjCSelectorExpr>(S)) |
5500 | 0 | return RewriteAtSelector(AtSelector); |
5501 | | |
5502 | 2.49k | if (ObjCStringLiteral *AtString = dyn_cast<ObjCStringLiteral>(S)) |
5503 | 13 | return RewriteObjCStringLiteral(AtString); |
5504 | | |
5505 | 2.47k | if (ObjCBoolLiteralExpr *BoolLitExpr = dyn_cast<ObjCBoolLiteralExpr>(S)) |
5506 | 16 | return RewriteObjCBoolLiteralExpr(BoolLitExpr); |
5507 | | |
5508 | 2.46k | if (ObjCBoxedExpr *BoxedExpr = dyn_cast<ObjCBoxedExpr>(S)) |
5509 | 36 | return RewriteObjCBoxedExpr(BoxedExpr); |
5510 | | |
5511 | 2.42k | if (ObjCArrayLiteral *ArrayLitExpr = dyn_cast<ObjCArrayLiteral>(S)) |
5512 | 5 | return RewriteObjCArrayLiteralExpr(ArrayLitExpr); |
5513 | | |
5514 | 2.42k | if (ObjCDictionaryLiteral *DictionaryLitExpr = |
5515 | 2.42k | dyn_cast<ObjCDictionaryLiteral>(S)) |
5516 | 2 | return RewriteObjCDictionaryLiteralExpr(DictionaryLitExpr); |
5517 | | |
5518 | 2.41k | if (ObjCMessageExpr *MessExpr = dyn_cast<ObjCMessageExpr>(S)) { |
5519 | | #if 0 |
5520 | | // Before we rewrite it, put the original message expression in a comment. |
5521 | | SourceLocation startLoc = MessExpr->getBeginLoc(); |
5522 | | SourceLocation endLoc = MessExpr->getEndLoc(); |
5523 | | |
5524 | | const char *startBuf = SM->getCharacterData(startLoc); |
5525 | | const char *endBuf = SM->getCharacterData(endLoc); |
5526 | | |
5527 | | std::string messString; |
5528 | | messString += "// "; |
5529 | | messString.append(startBuf, endBuf-startBuf+1); |
5530 | | messString += "\n"; |
5531 | | |
5532 | | // FIXME: Missing definition of |
5533 | | // InsertText(clang::SourceLocation, char const*, unsigned int). |
5534 | | // InsertText(startLoc, messString); |
5535 | | // Tried this, but it didn't work either... |
5536 | | // ReplaceText(startLoc, 0, messString.c_str(), messString.size()); |
5537 | | #endif |
5538 | 71 | return RewriteMessageExpr(MessExpr); |
5539 | 71 | } |
5540 | | |
5541 | 2.34k | if (ObjCAutoreleasePoolStmt *StmtAutoRelease = |
5542 | 2.34k | dyn_cast<ObjCAutoreleasePoolStmt>(S)) { |
5543 | 1 | return RewriteObjCAutoreleasePoolStmt(StmtAutoRelease); |
5544 | 1 | } |
5545 | | |
5546 | 2.34k | if (ObjCAtTryStmt *StmtTry = dyn_cast<ObjCAtTryStmt>(S)) |
5547 | 14 | return RewriteObjCTryStmt(StmtTry); |
5548 | | |
5549 | 2.33k | if (ObjCAtSynchronizedStmt *StmtTry = dyn_cast<ObjCAtSynchronizedStmt>(S)) |
5550 | 4 | return RewriteObjCSynchronizedStmt(StmtTry); |
5551 | | |
5552 | 2.32k | if (ObjCAtThrowStmt *StmtThrow = dyn_cast<ObjCAtThrowStmt>(S)) |
5553 | 5 | return RewriteObjCThrowStmt(StmtThrow); |
5554 | | |
5555 | 2.32k | if (ObjCProtocolExpr *ProtocolExp = dyn_cast<ObjCProtocolExpr>(S)) |
5556 | 2 | return RewriteObjCProtocolExpr(ProtocolExp); |
5557 | | |
5558 | 2.32k | if (ObjCForCollectionStmt *StmtForCollection = |
5559 | 2.32k | dyn_cast<ObjCForCollectionStmt>(S)) |
5560 | 5 | return RewriteObjCForCollectionStmt(StmtForCollection, |
5561 | 5 | OrigStmtRange.getEnd()); |
5562 | 2.31k | if (BreakStmt *StmtBreakStmt = |
5563 | 2.31k | dyn_cast<BreakStmt>(S)) |
5564 | 5 | return RewriteBreakStmt(StmtBreakStmt); |
5565 | 2.31k | if (ContinueStmt *StmtContinueStmt = |
5566 | 2.31k | dyn_cast<ContinueStmt>(S)) |
5567 | 0 | return RewriteContinueStmt(StmtContinueStmt); |
5568 | | |
5569 | | // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls |
5570 | | // and cast exprs. |
5571 | 2.31k | if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) { |
5572 | | // FIXME: What we're doing here is modifying the type-specifier that |
5573 | | // precedes the first Decl. In the future the DeclGroup should have |
5574 | | // a separate type-specifier that we can rewrite. |
5575 | | // NOTE: We need to avoid rewriting the DeclStmt if it is within |
5576 | | // the context of an ObjCForCollectionStmt. For example: |
5577 | | // NSArray *someArray; |
5578 | | // for (id <FooProtocol> index in someArray) ; |
5579 | | // This is because RewriteObjCForCollectionStmt() does textual rewriting |
5580 | | // and it depends on the original text locations/positions. |
5581 | 177 | if (Stmts.empty() || !IsDeclStmtInForeachHeader(DS)5 ) |
5582 | 172 | RewriteObjCQualifiedInterfaceTypes(*DS->decl_begin()); |
5583 | | |
5584 | | // Blocks rewrite rules. |
5585 | 177 | for (DeclStmt::decl_iterator DI = DS->decl_begin(), DE = DS->decl_end(); |
5586 | 365 | DI != DE; ++DI188 ) { |
5587 | 188 | Decl *SD = *DI; |
5588 | 188 | if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) { |
5589 | 188 | if (isTopLevelBlockPointerType(ND->getType())) |
5590 | 22 | RewriteBlockPointerDecl(ND); |
5591 | 166 | else if (ND->getType()->isFunctionPointerType()) |
5592 | 2 | CheckFunctionPointerDecl(ND->getType(), ND); |
5593 | 188 | if (VarDecl *VD = dyn_cast<VarDecl>(SD)) { |
5594 | 188 | if (VD->hasAttr<BlocksAttr>()) { |
5595 | 42 | static unsigned uniqueByrefDeclCount = 0; |
5596 | 42 | assert(!BlockByRefDeclNo.count(ND) && |
5597 | 42 | "RewriteFunctionBodyOrGlobalInitializer: Duplicate byref decl"); |
5598 | 42 | BlockByRefDeclNo[ND] = uniqueByrefDeclCount++; |
5599 | 42 | RewriteByRefVar(VD, (DI == DS->decl_begin()), ((DI+1) == DE)); |
5600 | 42 | } |
5601 | 146 | else |
5602 | 146 | RewriteTypeOfDecl(VD); |
5603 | 188 | } |
5604 | 188 | } |
5605 | 188 | if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) { |
5606 | 0 | if (isTopLevelBlockPointerType(TD->getUnderlyingType())) |
5607 | 0 | RewriteBlockPointerDecl(TD); |
5608 | 0 | else if (TD->getUnderlyingType()->isFunctionPointerType()) |
5609 | 0 | CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); |
5610 | 0 | } |
5611 | 188 | } |
5612 | 177 | } |
5613 | | |
5614 | 2.31k | if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) |
5615 | 30 | RewriteObjCQualifiedInterfaceTypes(CE); |
5616 | | |
5617 | 2.31k | if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) || |
5618 | 2.31k | isa<DoStmt>(S)2.30k || isa<ForStmt>(S)2.30k ) { |
5619 | 5 | assert(!Stmts.empty() && "Statement stack is empty"); |
5620 | 5 | assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) || |
5621 | 5 | isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back())) |
5622 | 5 | && "Statement stack mismatch"); |
5623 | 5 | Stmts.pop_back(); |
5624 | 5 | } |
5625 | | // Handle blocks rewriting. |
5626 | 2.31k | if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) { |
5627 | 436 | ValueDecl *VD = DRE->getDecl(); |
5628 | 436 | if (VD->hasAttr<BlocksAttr>()) |
5629 | 36 | return RewriteBlockDeclRefExpr(DRE); |
5630 | 400 | if (HasLocalVariableExternalStorage(VD)) |
5631 | 0 | return RewriteLocalVariableExternalStorage(DRE); |
5632 | 400 | } |
5633 | | |
5634 | 2.27k | if (CallExpr *CE = dyn_cast<CallExpr>(S)) { |
5635 | 156 | if (CE->getCallee()->getType()->isBlockPointerType()) { |
5636 | 14 | Stmt *BlockCall = SynthesizeBlockCall(CE, CE->getCallee()); |
5637 | 14 | ReplaceStmt(S, BlockCall); |
5638 | 14 | return BlockCall; |
5639 | 14 | } |
5640 | 156 | } |
5641 | 2.26k | if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) { |
5642 | 30 | RewriteCastExpr(CE); |
5643 | 30 | } |
5644 | 2.26k | if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) { |
5645 | 604 | RewriteImplicitCastObjCExpr(ICE); |
5646 | 604 | } |
5647 | | #if 0 |
5648 | | |
5649 | | if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) { |
5650 | | CastExpr *Replacement = new (Context) CastExpr(ICE->getType(), |
5651 | | ICE->getSubExpr(), |
5652 | | SourceLocation()); |
5653 | | // Get the new text. |
5654 | | std::string SStr; |
5655 | | llvm::raw_string_ostream Buf(SStr); |
5656 | | Replacement->printPretty(Buf); |
5657 | | const std::string &Str = Buf.str(); |
5658 | | |
5659 | | printf("CAST = %s\n", &Str[0]); |
5660 | | InsertText(ICE->getSubExpr()->getBeginLoc(), Str); |
5661 | | delete S; |
5662 | | return Replacement; |
5663 | | } |
5664 | | #endif |
5665 | | // Return this stmt unmodified. |
5666 | 2.26k | return S; |
5667 | 2.27k | } |
5668 | | |
5669 | 22 | void RewriteModernObjC::RewriteRecordBody(RecordDecl *RD) { |
5670 | 35 | for (auto *FD : RD->fields()) { |
5671 | 35 | if (isTopLevelBlockPointerType(FD->getType())) |
5672 | 1 | RewriteBlockPointerDecl(FD); |
5673 | 35 | if (FD->getType()->isObjCQualifiedIdType() || |
5674 | 35 | FD->getType()->isObjCQualifiedInterfaceType()) |
5675 | 0 | RewriteObjCQualifiedInterfaceTypes(FD); |
5676 | 35 | } |
5677 | 22 | } |
5678 | | |
5679 | | /// HandleDeclInMainFile - This is called for each top-level decl defined in the |
5680 | | /// main file of the input. |
5681 | 541 | void RewriteModernObjC::HandleDeclInMainFile(Decl *D) { |
5682 | 541 | switch (D->getKind()) { |
5683 | 192 | case Decl::Function: { |
5684 | 192 | FunctionDecl *FD = cast<FunctionDecl>(D); |
5685 | 192 | if (FD->isOverloadedOperator()) |
5686 | 0 | return; |
5687 | | |
5688 | | // Since function prototypes don't have ParmDecl's, we check the function |
5689 | | // prototype. This enables us to rewrite function declarations and |
5690 | | // definitions using the same code. |
5691 | 192 | RewriteBlocksInFunctionProtoType(FD->getType(), FD); |
5692 | | |
5693 | 192 | if (!FD->isThisDeclarationADefinition()) |
5694 | 93 | break; |
5695 | | |
5696 | | // FIXME: If this should support Obj-C++, support CXXTryStmt |
5697 | 99 | if (CompoundStmt *Body = dyn_cast_or_null<CompoundStmt>(FD->getBody())) { |
5698 | 99 | CurFunctionDef = FD; |
5699 | 99 | CurrentBody = Body; |
5700 | 99 | Body = |
5701 | 99 | cast_or_null<CompoundStmt>(RewriteFunctionBodyOrGlobalInitializer(Body)); |
5702 | 99 | FD->setBody(Body); |
5703 | 99 | CurrentBody = nullptr; |
5704 | 99 | if (PropParentMap) { |
5705 | 0 | delete PropParentMap; |
5706 | 0 | PropParentMap = nullptr; |
5707 | 0 | } |
5708 | | // This synthesizes and inserts the block "impl" struct, invoke function, |
5709 | | // and any copy/dispose helper functions. |
5710 | 99 | InsertBlockLiteralsWithinFunction(FD); |
5711 | 99 | RewriteLineDirective(D); |
5712 | 99 | CurFunctionDef = nullptr; |
5713 | 99 | } |
5714 | 99 | break; |
5715 | 192 | } |
5716 | 63 | case Decl::ObjCMethod: { |
5717 | 63 | ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D); |
5718 | 63 | if (CompoundStmt *Body = MD->getCompoundBody()) { |
5719 | 63 | CurMethodDef = MD; |
5720 | 63 | CurrentBody = Body; |
5721 | 63 | Body = |
5722 | 63 | cast_or_null<CompoundStmt>(RewriteFunctionBodyOrGlobalInitializer(Body)); |
5723 | 63 | MD->setBody(Body); |
5724 | 63 | CurrentBody = nullptr; |
5725 | 63 | if (PropParentMap) { |
5726 | 0 | delete PropParentMap; |
5727 | 0 | PropParentMap = nullptr; |
5728 | 0 | } |
5729 | 63 | InsertBlockLiteralsWithinMethod(MD); |
5730 | 63 | RewriteLineDirective(D); |
5731 | 63 | CurMethodDef = nullptr; |
5732 | 63 | } |
5733 | 63 | break; |
5734 | 192 | } |
5735 | 88 | case Decl::ObjCImplementation: { |
5736 | 88 | ObjCImplementationDecl *CI = cast<ObjCImplementationDecl>(D); |
5737 | 88 | ClassImplementation.push_back(CI); |
5738 | 88 | break; |
5739 | 192 | } |
5740 | 5 | case Decl::ObjCCategoryImpl: { |
5741 | 5 | ObjCCategoryImplDecl *CI = cast<ObjCCategoryImplDecl>(D); |
5742 | 5 | CategoryImplementation.push_back(CI); |
5743 | 5 | break; |
5744 | 192 | } |
5745 | 21 | case Decl::Var: { |
5746 | 21 | VarDecl *VD = cast<VarDecl>(D); |
5747 | 21 | RewriteObjCQualifiedInterfaceTypes(VD); |
5748 | 21 | if (isTopLevelBlockPointerType(VD->getType())) |
5749 | 6 | RewriteBlockPointerDecl(VD); |
5750 | 15 | else if (VD->getType()->isFunctionPointerType()) { |
5751 | 0 | CheckFunctionPointerDecl(VD->getType(), VD); |
5752 | 0 | if (VD->getInit()) { |
5753 | 0 | if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) { |
5754 | 0 | RewriteCastExpr(CE); |
5755 | 0 | } |
5756 | 0 | } |
5757 | 15 | } else if (VD->getType()->isRecordType()) { |
5758 | 1 | RecordDecl *RD = VD->getType()->castAs<RecordType>()->getDecl(); |
5759 | 1 | if (RD->isCompleteDefinition()) |
5760 | 1 | RewriteRecordBody(RD); |
5761 | 1 | } |
5762 | 21 | if (VD->getInit()) { |
5763 | 9 | GlobalVarDecl = VD; |
5764 | 9 | CurrentBody = VD->getInit(); |
5765 | 9 | RewriteFunctionBodyOrGlobalInitializer(VD->getInit()); |
5766 | 9 | CurrentBody = nullptr; |
5767 | 9 | if (PropParentMap) { |
5768 | 0 | delete PropParentMap; |
5769 | 0 | PropParentMap = nullptr; |
5770 | 0 | } |
5771 | 9 | SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), VD->getName()); |
5772 | 9 | GlobalVarDecl = nullptr; |
5773 | | |
5774 | | // This is needed for blocks. |
5775 | 9 | if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) { |
5776 | 0 | RewriteCastExpr(CE); |
5777 | 0 | } |
5778 | 9 | } |
5779 | 21 | break; |
5780 | 192 | } |
5781 | 0 | case Decl::TypeAlias: |
5782 | 87 | case Decl::Typedef: { |
5783 | 87 | if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { |
5784 | 87 | if (isTopLevelBlockPointerType(TD->getUnderlyingType())) |
5785 | 18 | RewriteBlockPointerDecl(TD); |
5786 | 69 | else if (TD->getUnderlyingType()->isFunctionPointerType()) |
5787 | 0 | CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); |
5788 | 69 | else |
5789 | 69 | RewriteObjCQualifiedInterfaceTypes(TD); |
5790 | 87 | } |
5791 | 87 | break; |
5792 | 0 | } |
5793 | 18 | case Decl::CXXRecord: |
5794 | 26 | case Decl::Record: { |
5795 | 26 | RecordDecl *RD = cast<RecordDecl>(D); |
5796 | 26 | if (RD->isCompleteDefinition()) |
5797 | 21 | RewriteRecordBody(RD); |
5798 | 26 | break; |
5799 | 18 | } |
5800 | 59 | default: |
5801 | 59 | break; |
5802 | 541 | } |
5803 | | // Nothing yet. |
5804 | 541 | } |
5805 | | |
5806 | | /// Write_ProtocolExprReferencedMetadata - This routine writer out the |
5807 | | /// protocol reference symbols in the for of: |
5808 | | /// struct _protocol_t *PROTOCOL_REF = &PROTOCOL_METADATA. |
5809 | | static void Write_ProtocolExprReferencedMetadata(ASTContext *Context, |
5810 | | ObjCProtocolDecl *PDecl, |
5811 | 2 | std::string &Result) { |
5812 | | // Also output .objc_protorefs$B section and its meta-data. |
5813 | 2 | if (Context->getLangOpts().MicrosoftExt) |
5814 | 2 | Result += "static "; |
5815 | 2 | Result += "struct _protocol_t *"; |
5816 | 2 | Result += "_OBJC_PROTOCOL_REFERENCE_$_"; |
5817 | 2 | Result += PDecl->getNameAsString(); |
5818 | 2 | Result += " = &"; |
5819 | 2 | Result += "_OBJC_PROTOCOL_"; Result += PDecl->getNameAsString(); |
5820 | 2 | Result += ";\n"; |
5821 | 2 | } |
5822 | | |
5823 | 78 | void RewriteModernObjC::HandleTranslationUnit(ASTContext &C) { |
5824 | 78 | if (Diags.hasErrorOccurred()) |
5825 | 0 | return; |
5826 | | |
5827 | 78 | RewriteInclude(); |
5828 | | |
5829 | 172 | for (unsigned i = 0, e = FunctionDefinitionsSeen.size(); i < e; i++94 ) { |
5830 | | // translation of function bodies were postponed until all class and |
5831 | | // their extensions and implementations are seen. This is because, we |
5832 | | // cannot build grouping structs for bitfields until they are all seen. |
5833 | 94 | FunctionDecl *FDecl = FunctionDefinitionsSeen[i]; |
5834 | 94 | HandleTopLevelSingleDecl(FDecl); |
5835 | 94 | } |
5836 | | |
5837 | | // Here's a great place to add any extra declarations that may be needed. |
5838 | | // Write out meta data for each @protocol(<expr>). |
5839 | 78 | for (ObjCProtocolDecl *ProtDecl : ProtocolExprDecls) { |
5840 | 2 | RewriteObjCProtocolMetaData(ProtDecl, Preamble); |
5841 | 2 | Write_ProtocolExprReferencedMetadata(Context, ProtDecl, Preamble); |
5842 | 2 | } |
5843 | | |
5844 | 78 | InsertText(SM->getLocForStartOfFile(MainFileID), Preamble, false); |
5845 | | |
5846 | 78 | if (ClassImplementation.size() || CategoryImplementation.size()26 ) |
5847 | 52 | RewriteImplementations(); |
5848 | | |
5849 | 230 | for (unsigned i = 0, e = ObjCInterfacesSeen.size(); i < e; i++152 ) { |
5850 | 152 | ObjCInterfaceDecl *CDecl = ObjCInterfacesSeen[i]; |
5851 | | // Write struct declaration for the class matching its ivar declarations. |
5852 | | // Note that for modern abi, this is postponed until the end of TU |
5853 | | // because class extensions and the implementation might declare their own |
5854 | | // private ivars. |
5855 | 152 | RewriteInterfaceDecl(CDecl); |
5856 | 152 | } |
5857 | | |
5858 | | // Get the buffer corresponding to MainFileID. If we haven't changed it, then |
5859 | | // we are done. |
5860 | 78 | if (const RewriteBuffer *RewriteBuf = |
5861 | 78 | Rewrite.getRewriteBufferFor(MainFileID)) { |
5862 | | //printf("Changed:\n"); |
5863 | 78 | *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end()); |
5864 | 78 | } else { |
5865 | 0 | llvm::errs() << "No changes\n"; |
5866 | 0 | } |
5867 | | |
5868 | 78 | if (ClassImplementation.size() || CategoryImplementation.size()26 || |
5869 | 78 | ProtocolExprDecls.size()26 ) { |
5870 | | // Rewrite Objective-c meta data* |
5871 | 52 | std::string ResultStr; |
5872 | 52 | RewriteMetaDataIntoBuffer(ResultStr); |
5873 | | // Emit metadata. |
5874 | 52 | *OutFile << ResultStr; |
5875 | 52 | } |
5876 | | // Emit ImageInfo; |
5877 | 78 | { |
5878 | 78 | std::string ResultStr; |
5879 | 78 | WriteImageInfo(ResultStr); |
5880 | 78 | *OutFile << ResultStr; |
5881 | 78 | } |
5882 | 78 | OutFile->flush(); |
5883 | 78 | } |
5884 | | |
5885 | 78 | void RewriteModernObjC::Initialize(ASTContext &context) { |
5886 | 78 | InitializeCommon(context); |
5887 | | |
5888 | 78 | Preamble += "#ifndef __OBJC2__\n"; |
5889 | 78 | Preamble += "#define __OBJC2__\n"; |
5890 | 78 | Preamble += "#endif\n"; |
5891 | | |
5892 | | // declaring objc_selector outside the parameter list removes a silly |
5893 | | // scope related warning... |
5894 | 78 | if (IsHeader) |
5895 | 0 | Preamble = "#pragma once\n"; |
5896 | 78 | Preamble += "struct objc_selector; struct objc_class;\n"; |
5897 | 78 | Preamble += "struct __rw_objc_super { \n\tstruct objc_object *object; "; |
5898 | 78 | Preamble += "\n\tstruct objc_object *superClass; "; |
5899 | | // Add a constructor for creating temporary objects. |
5900 | 78 | Preamble += "\n\t__rw_objc_super(struct objc_object *o, struct objc_object *s) "; |
5901 | 78 | Preamble += ": object(o), superClass(s) {} "; |
5902 | 78 | Preamble += "\n};\n"; |
5903 | | |
5904 | 78 | if (LangOpts.MicrosoftExt) { |
5905 | | // Define all sections using syntax that makes sense. |
5906 | | // These are currently generated. |
5907 | 78 | Preamble += "\n#pragma section(\".objc_classlist$B\", long, read, write)\n"; |
5908 | 78 | Preamble += "#pragma section(\".objc_catlist$B\", long, read, write)\n"; |
5909 | 78 | Preamble += "#pragma section(\".objc_imageinfo$B\", long, read, write)\n"; |
5910 | 78 | Preamble += "#pragma section(\".objc_nlclslist$B\", long, read, write)\n"; |
5911 | 78 | Preamble += "#pragma section(\".objc_nlcatlist$B\", long, read, write)\n"; |
5912 | | // These are generated but not necessary for functionality. |
5913 | 78 | Preamble += "#pragma section(\".cat_cls_meth$B\", long, read, write)\n"; |
5914 | 78 | Preamble += "#pragma section(\".inst_meth$B\", long, read, write)\n"; |
5915 | 78 | Preamble += "#pragma section(\".cls_meth$B\", long, read, write)\n"; |
5916 | 78 | Preamble += "#pragma section(\".objc_ivar$B\", long, read, write)\n"; |
5917 | | |
5918 | | // These need be generated for performance. Currently they are not, |
5919 | | // using API calls instead. |
5920 | 78 | Preamble += "#pragma section(\".objc_selrefs$B\", long, read, write)\n"; |
5921 | 78 | Preamble += "#pragma section(\".objc_classrefs$B\", long, read, write)\n"; |
5922 | 78 | Preamble += "#pragma section(\".objc_superrefs$B\", long, read, write)\n"; |
5923 | | |
5924 | 78 | } |
5925 | 78 | Preamble += "#ifndef _REWRITER_typedef_Protocol\n"; |
5926 | 78 | Preamble += "typedef struct objc_object Protocol;\n"; |
5927 | 78 | Preamble += "#define _REWRITER_typedef_Protocol\n"; |
5928 | 78 | Preamble += "#endif\n"; |
5929 | 78 | if (LangOpts.MicrosoftExt) { |
5930 | 78 | Preamble += "#define __OBJC_RW_DLLIMPORT extern \"C\" __declspec(dllimport)\n"; |
5931 | 78 | Preamble += "#define __OBJC_RW_STATICIMPORT extern \"C\"\n"; |
5932 | 78 | } |
5933 | 0 | else |
5934 | 0 | Preamble += "#define __OBJC_RW_DLLIMPORT extern\n"; |
5935 | | |
5936 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_msgSend(void);\n"; |
5937 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_msgSendSuper(void);\n"; |
5938 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_msgSend_stret(void);\n"; |
5939 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_msgSendSuper_stret(void);\n"; |
5940 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_msgSend_fpret(void);\n"; |
5941 | | |
5942 | 78 | Preamble += "__OBJC_RW_DLLIMPORT struct objc_class *objc_getClass"; |
5943 | 78 | Preamble += "(const char *);\n"; |
5944 | 78 | Preamble += "__OBJC_RW_DLLIMPORT struct objc_class *class_getSuperclass"; |
5945 | 78 | Preamble += "(struct objc_class *);\n"; |
5946 | 78 | Preamble += "__OBJC_RW_DLLIMPORT struct objc_class *objc_getMetaClass"; |
5947 | 78 | Preamble += "(const char *);\n"; |
5948 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_throw( struct objc_object *);\n"; |
5949 | | // @synchronized hooks. |
5950 | 78 | Preamble += "__OBJC_RW_DLLIMPORT int objc_sync_enter( struct objc_object *);\n"; |
5951 | 78 | Preamble += "__OBJC_RW_DLLIMPORT int objc_sync_exit( struct objc_object *);\n"; |
5952 | 78 | Preamble += "__OBJC_RW_DLLIMPORT Protocol *objc_getProtocol(const char *);\n"; |
5953 | 78 | Preamble += "#ifdef _WIN64\n"; |
5954 | 78 | Preamble += "typedef unsigned long long _WIN_NSUInteger;\n"; |
5955 | 78 | Preamble += "#else\n"; |
5956 | 78 | Preamble += "typedef unsigned int _WIN_NSUInteger;\n"; |
5957 | 78 | Preamble += "#endif\n"; |
5958 | 78 | Preamble += "#ifndef __FASTENUMERATIONSTATE\n"; |
5959 | 78 | Preamble += "struct __objcFastEnumerationState {\n\t"; |
5960 | 78 | Preamble += "unsigned long state;\n\t"; |
5961 | 78 | Preamble += "void **itemsPtr;\n\t"; |
5962 | 78 | Preamble += "unsigned long *mutationsPtr;\n\t"; |
5963 | 78 | Preamble += "unsigned long extra[5];\n};\n"; |
5964 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void objc_enumerationMutation(struct objc_object *);\n"; |
5965 | 78 | Preamble += "#define __FASTENUMERATIONSTATE\n"; |
5966 | 78 | Preamble += "#endif\n"; |
5967 | 78 | Preamble += "#ifndef __NSCONSTANTSTRINGIMPL\n"; |
5968 | 78 | Preamble += "struct __NSConstantStringImpl {\n"; |
5969 | 78 | Preamble += " int *isa;\n"; |
5970 | 78 | Preamble += " int flags;\n"; |
5971 | 78 | Preamble += " char *str;\n"; |
5972 | 78 | Preamble += "#if _WIN64\n"; |
5973 | 78 | Preamble += " long long length;\n"; |
5974 | 78 | Preamble += "#else\n"; |
5975 | 78 | Preamble += " long length;\n"; |
5976 | 78 | Preamble += "#endif\n"; |
5977 | 78 | Preamble += "};\n"; |
5978 | 78 | Preamble += "#ifdef CF_EXPORT_CONSTANT_STRING\n"; |
5979 | 78 | Preamble += "extern \"C\" __declspec(dllexport) int __CFConstantStringClassReference[];\n"; |
5980 | 78 | Preamble += "#else\n"; |
5981 | 78 | Preamble += "__OBJC_RW_DLLIMPORT int __CFConstantStringClassReference[];\n"; |
5982 | 78 | Preamble += "#endif\n"; |
5983 | 78 | Preamble += "#define __NSCONSTANTSTRINGIMPL\n"; |
5984 | 78 | Preamble += "#endif\n"; |
5985 | | // Blocks preamble. |
5986 | 78 | Preamble += "#ifndef BLOCK_IMPL\n"; |
5987 | 78 | Preamble += "#define BLOCK_IMPL\n"; |
5988 | 78 | Preamble += "struct __block_impl {\n"; |
5989 | 78 | Preamble += " void *isa;\n"; |
5990 | 78 | Preamble += " int Flags;\n"; |
5991 | 78 | Preamble += " int Reserved;\n"; |
5992 | 78 | Preamble += " void *FuncPtr;\n"; |
5993 | 78 | Preamble += "};\n"; |
5994 | 78 | Preamble += "// Runtime copy/destroy helper functions (from Block_private.h)\n"; |
5995 | 78 | Preamble += "#ifdef __OBJC_EXPORT_BLOCKS\n"; |
5996 | 78 | Preamble += "extern \"C\" __declspec(dllexport) " |
5997 | 78 | "void _Block_object_assign(void *, const void *, const int);\n"; |
5998 | 78 | Preamble += "extern \"C\" __declspec(dllexport) void _Block_object_dispose(const void *, const int);\n"; |
5999 | 78 | Preamble += "extern \"C\" __declspec(dllexport) void *_NSConcreteGlobalBlock[32];\n"; |
6000 | 78 | Preamble += "extern \"C\" __declspec(dllexport) void *_NSConcreteStackBlock[32];\n"; |
6001 | 78 | Preamble += "#else\n"; |
6002 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void _Block_object_assign(void *, const void *, const int);\n"; |
6003 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void _Block_object_dispose(const void *, const int);\n"; |
6004 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void *_NSConcreteGlobalBlock[32];\n"; |
6005 | 78 | Preamble += "__OBJC_RW_DLLIMPORT void *_NSConcreteStackBlock[32];\n"; |
6006 | 78 | Preamble += "#endif\n"; |
6007 | 78 | Preamble += "#endif\n"; |
6008 | 78 | if (LangOpts.MicrosoftExt) { |
6009 | 78 | Preamble += "#undef __OBJC_RW_DLLIMPORT\n"; |
6010 | 78 | Preamble += "#undef __OBJC_RW_STATICIMPORT\n"; |
6011 | 78 | Preamble += "#ifndef KEEP_ATTRIBUTES\n"; // We use this for clang tests. |
6012 | 78 | Preamble += "#define __attribute__(X)\n"; |
6013 | 78 | Preamble += "#endif\n"; |
6014 | 78 | Preamble += "#ifndef __weak\n"; |
6015 | 78 | Preamble += "#define __weak\n"; |
6016 | 78 | Preamble += "#endif\n"; |
6017 | 78 | Preamble += "#ifndef __block\n"; |
6018 | 78 | Preamble += "#define __block\n"; |
6019 | 78 | Preamble += "#endif\n"; |
6020 | 78 | } |
6021 | 0 | else { |
6022 | 0 | Preamble += "#define __block\n"; |
6023 | 0 | Preamble += "#define __weak\n"; |
6024 | 0 | } |
6025 | | |
6026 | | // Declarations required for modern objective-c array and dictionary literals. |
6027 | 78 | Preamble += "\n#include <stdarg.h>\n"; |
6028 | 78 | Preamble += "struct __NSContainer_literal {\n"; |
6029 | 78 | Preamble += " void * *arr;\n"; |
6030 | 78 | Preamble += " __NSContainer_literal (unsigned int count, ...) {\n"; |
6031 | 78 | Preamble += "\tva_list marker;\n"; |
6032 | 78 | Preamble += "\tva_start(marker, count);\n"; |
6033 | 78 | Preamble += "\tarr = new void *[count];\n"; |
6034 | 78 | Preamble += "\tfor (unsigned i = 0; i < count; i++)\n"; |
6035 | 78 | Preamble += "\t arr[i] = va_arg(marker, void *);\n"; |
6036 | 78 | Preamble += "\tva_end( marker );\n"; |
6037 | 78 | Preamble += " };\n"; |
6038 | 78 | Preamble += " ~__NSContainer_literal() {\n"; |
6039 | 78 | Preamble += "\tdelete[] arr;\n"; |
6040 | 78 | Preamble += " }\n"; |
6041 | 78 | Preamble += "};\n"; |
6042 | | |
6043 | | // Declaration required for implementation of @autoreleasepool statement. |
6044 | 78 | Preamble += "extern \"C\" __declspec(dllimport) void * objc_autoreleasePoolPush(void);\n"; |
6045 | 78 | Preamble += "extern \"C\" __declspec(dllimport) void objc_autoreleasePoolPop(void *);\n\n"; |
6046 | 78 | Preamble += "struct __AtAutoreleasePool {\n"; |
6047 | 78 | Preamble += " __AtAutoreleasePool() {atautoreleasepoolobj = objc_autoreleasePoolPush();}\n"; |
6048 | 78 | Preamble += " ~__AtAutoreleasePool() {objc_autoreleasePoolPop(atautoreleasepoolobj);}\n"; |
6049 | 78 | Preamble += " void * atautoreleasepoolobj;\n"; |
6050 | 78 | Preamble += "};\n"; |
6051 | | |
6052 | | // NOTE! Windows uses LLP64 for 64bit mode. So, cast pointer to long long |
6053 | | // as this avoids warning in any 64bit/32bit compilation model. |
6054 | 78 | Preamble += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)\n"; |
6055 | 78 | } |
6056 | | |
6057 | | /// RewriteIvarOffsetComputation - This routine synthesizes computation of |
6058 | | /// ivar offset. |
6059 | | void RewriteModernObjC::RewriteIvarOffsetComputation(ObjCIvarDecl *ivar, |
6060 | 206 | std::string &Result) { |
6061 | 206 | Result += "__OFFSETOFIVAR__(struct "; |
6062 | 206 | Result += ivar->getContainingInterface()->getNameAsString(); |
6063 | 206 | if (LangOpts.MicrosoftExt) |
6064 | 206 | Result += "_IMPL"; |
6065 | 206 | Result += ", "; |
6066 | 206 | if (ivar->isBitField()) |
6067 | 15 | ObjCIvarBitfieldGroupDecl(ivar, Result); |
6068 | 191 | else |
6069 | 191 | Result += ivar->getNameAsString(); |
6070 | 206 | Result += ")"; |
6071 | 206 | } |
6072 | | |
6073 | | /// WriteModernMetadataDeclarations - Writes out metadata declarations for modern ABI. |
6074 | | /// struct _prop_t { |
6075 | | /// const char *name; |
6076 | | /// char *attributes; |
6077 | | /// } |
6078 | | |
6079 | | /// struct _prop_list_t { |
6080 | | /// uint32_t entsize; // sizeof(struct _prop_t) |
6081 | | /// uint32_t count_of_properties; |
6082 | | /// struct _prop_t prop_list[count_of_properties]; |
6083 | | /// } |
6084 | | |
6085 | | /// struct _protocol_t; |
6086 | | |
6087 | | /// struct _protocol_list_t { |
6088 | | /// long protocol_count; // Note, this is 32/64 bit |
6089 | | /// struct _protocol_t * protocol_list[protocol_count]; |
6090 | | /// } |
6091 | | |
6092 | | /// struct _objc_method { |
6093 | | /// SEL _cmd; |
6094 | | /// const char *method_type; |
6095 | | /// char *_imp; |
6096 | | /// } |
6097 | | |
6098 | | /// struct _method_list_t { |
6099 | | /// uint32_t entsize; // sizeof(struct _objc_method) |
6100 | | /// uint32_t method_count; |
6101 | | /// struct _objc_method method_list[method_count]; |
6102 | | /// } |
6103 | | |
6104 | | /// struct _protocol_t { |
6105 | | /// id isa; // NULL |
6106 | | /// const char *protocol_name; |
6107 | | /// const struct _protocol_list_t * protocol_list; // super protocols |
6108 | | /// const struct method_list_t *instance_methods; |
6109 | | /// const struct method_list_t *class_methods; |
6110 | | /// const struct method_list_t *optionalInstanceMethods; |
6111 | | /// const struct method_list_t *optionalClassMethods; |
6112 | | /// const struct _prop_list_t * properties; |
6113 | | /// const uint32_t size; // sizeof(struct _protocol_t) |
6114 | | /// const uint32_t flags; // = 0 |
6115 | | /// const char ** extendedMethodTypes; |
6116 | | /// } |
6117 | | |
6118 | | /// struct _ivar_t { |
6119 | | /// unsigned long int *offset; // pointer to ivar offset location |
6120 | | /// const char *name; |
6121 | | /// const char *type; |
6122 | | /// uint32_t alignment; |
6123 | | /// uint32_t size; |
6124 | | /// } |
6125 | | |
6126 | | /// struct _ivar_list_t { |
6127 | | /// uint32 entsize; // sizeof(struct _ivar_t) |
6128 | | /// uint32 count; |
6129 | | /// struct _ivar_t list[count]; |
6130 | | /// } |
6131 | | |
6132 | | /// struct _class_ro_t { |
6133 | | /// uint32_t flags; |
6134 | | /// uint32_t instanceStart; |
6135 | | /// uint32_t instanceSize; |
6136 | | /// uint32_t reserved; // only when building for 64bit targets |
6137 | | /// const uint8_t *ivarLayout; |
6138 | | /// const char *name; |
6139 | | /// const struct _method_list_t *baseMethods; |
6140 | | /// const struct _protocol_list_t *baseProtocols; |
6141 | | /// const struct _ivar_list_t *ivars; |
6142 | | /// const uint8_t *weakIvarLayout; |
6143 | | /// const struct _prop_list_t *properties; |
6144 | | /// } |
6145 | | |
6146 | | /// struct _class_t { |
6147 | | /// struct _class_t *isa; |
6148 | | /// struct _class_t *superclass; |
6149 | | /// void *cache; |
6150 | | /// IMP *vtable; |
6151 | | /// struct _class_ro_t *ro; |
6152 | | /// } |
6153 | | |
6154 | | /// struct _category_t { |
6155 | | /// const char *name; |
6156 | | /// struct _class_t *cls; |
6157 | | /// const struct _method_list_t *instance_methods; |
6158 | | /// const struct _method_list_t *class_methods; |
6159 | | /// const struct _protocol_list_t *protocols; |
6160 | | /// const struct _prop_list_t *properties; |
6161 | | /// } |
6162 | | |
6163 | | /// MessageRefTy - LLVM for: |
6164 | | /// struct _message_ref_t { |
6165 | | /// IMP messenger; |
6166 | | /// SEL name; |
6167 | | /// }; |
6168 | | |
6169 | | /// SuperMessageRefTy - LLVM for: |
6170 | | /// struct _super_message_ref_t { |
6171 | | /// SUPER_IMP messenger; |
6172 | | /// SEL name; |
6173 | | /// }; |
6174 | | |
6175 | 101 | static void WriteModernMetadataDeclarations(ASTContext *Context, std::string &Result) { |
6176 | 101 | static bool meta_data_declared = false; |
6177 | 101 | if (meta_data_declared) |
6178 | 49 | return; |
6179 | | |
6180 | 52 | Result += "\nstruct _prop_t {\n"; |
6181 | 52 | Result += "\tconst char *name;\n"; |
6182 | 52 | Result += "\tconst char *attributes;\n"; |
6183 | 52 | Result += "};\n"; |
6184 | | |
6185 | 52 | Result += "\nstruct _protocol_t;\n"; |
6186 | | |
6187 | 52 | Result += "\nstruct _objc_method {\n"; |
6188 | 52 | Result += "\tstruct objc_selector * _cmd;\n"; |
6189 | 52 | Result += "\tconst char *method_type;\n"; |
6190 | 52 | Result += "\tvoid *_imp;\n"; |
6191 | 52 | Result += "};\n"; |
6192 | | |
6193 | 52 | Result += "\nstruct _protocol_t {\n"; |
6194 | 52 | Result += "\tvoid * isa; // NULL\n"; |
6195 | 52 | Result += "\tconst char *protocol_name;\n"; |
6196 | 52 | Result += "\tconst struct _protocol_list_t * protocol_list; // super protocols\n"; |
6197 | 52 | Result += "\tconst struct method_list_t *instance_methods;\n"; |
6198 | 52 | Result += "\tconst struct method_list_t *class_methods;\n"; |
6199 | 52 | Result += "\tconst struct method_list_t *optionalInstanceMethods;\n"; |
6200 | 52 | Result += "\tconst struct method_list_t *optionalClassMethods;\n"; |
6201 | 52 | Result += "\tconst struct _prop_list_t * properties;\n"; |
6202 | 52 | Result += "\tconst unsigned int size; // sizeof(struct _protocol_t)\n"; |
6203 | 52 | Result += "\tconst unsigned int flags; // = 0\n"; |
6204 | 52 | Result += "\tconst char ** extendedMethodTypes;\n"; |
6205 | 52 | Result += "};\n"; |
6206 | | |
6207 | 52 | Result += "\nstruct _ivar_t {\n"; |
6208 | 52 | Result += "\tunsigned long int *offset; // pointer to ivar offset location\n"; |
6209 | 52 | Result += "\tconst char *name;\n"; |
6210 | 52 | Result += "\tconst char *type;\n"; |
6211 | 52 | Result += "\tunsigned int alignment;\n"; |
6212 | 52 | Result += "\tunsigned int size;\n"; |
6213 | 52 | Result += "};\n"; |
6214 | | |
6215 | 52 | Result += "\nstruct _class_ro_t {\n"; |
6216 | 52 | Result += "\tunsigned int flags;\n"; |
6217 | 52 | Result += "\tunsigned int instanceStart;\n"; |
6218 | 52 | Result += "\tunsigned int instanceSize;\n"; |
6219 | 52 | const llvm::Triple &Triple(Context->getTargetInfo().getTriple()); |
6220 | 52 | if (Triple.getArch() == llvm::Triple::x86_64) |
6221 | 49 | Result += "\tunsigned int reserved;\n"; |
6222 | 52 | Result += "\tconst unsigned char *ivarLayout;\n"; |
6223 | 52 | Result += "\tconst char *name;\n"; |
6224 | 52 | Result += "\tconst struct _method_list_t *baseMethods;\n"; |
6225 | 52 | Result += "\tconst struct _objc_protocol_list *baseProtocols;\n"; |
6226 | 52 | Result += "\tconst struct _ivar_list_t *ivars;\n"; |
6227 | 52 | Result += "\tconst unsigned char *weakIvarLayout;\n"; |
6228 | 52 | Result += "\tconst struct _prop_list_t *properties;\n"; |
6229 | 52 | Result += "};\n"; |
6230 | | |
6231 | 52 | Result += "\nstruct _class_t {\n"; |
6232 | 52 | Result += "\tstruct _class_t *isa;\n"; |
6233 | 52 | Result += "\tstruct _class_t *superclass;\n"; |
6234 | 52 | Result += "\tvoid *cache;\n"; |
6235 | 52 | Result += "\tvoid *vtable;\n"; |
6236 | 52 | Result += "\tstruct _class_ro_t *ro;\n"; |
6237 | 52 | Result += "};\n"; |
6238 | | |
6239 | 52 | Result += "\nstruct _category_t {\n"; |
6240 | 52 | Result += "\tconst char *name;\n"; |
6241 | 52 | Result += "\tstruct _class_t *cls;\n"; |
6242 | 52 | Result += "\tconst struct _method_list_t *instance_methods;\n"; |
6243 | 52 | Result += "\tconst struct _method_list_t *class_methods;\n"; |
6244 | 52 | Result += "\tconst struct _protocol_list_t *protocols;\n"; |
6245 | 52 | Result += "\tconst struct _prop_list_t *properties;\n"; |
6246 | 52 | Result += "};\n"; |
6247 | | |
6248 | 52 | Result += "extern \"C\" __declspec(dllimport) struct objc_cache _objc_empty_cache;\n"; |
6249 | 52 | Result += "#pragma warning(disable:4273)\n"; |
6250 | 52 | meta_data_declared = true; |
6251 | 52 | } |
6252 | | |
6253 | | static void Write_protocol_list_t_TypeDecl(std::string &Result, |
6254 | 6 | long super_protocol_count) { |
6255 | 6 | Result += "struct /*_protocol_list_t*/"; Result += " {\n"; |
6256 | 6 | Result += "\tlong protocol_count; // Note, this is 32/64 bit\n"; |
6257 | 6 | Result += "\tstruct _protocol_t *super_protocols["; |
6258 | 6 | Result += utostr(super_protocol_count); Result += "];\n"; |
6259 | 6 | Result += "}"; |
6260 | 6 | } |
6261 | | |
6262 | | static void Write_method_list_t_TypeDecl(std::string &Result, |
6263 | 68 | unsigned int method_count) { |
6264 | 68 | Result += "struct /*_method_list_t*/"; Result += " {\n"; |
6265 | 68 | Result += "\tunsigned int entsize; // sizeof(struct _objc_method)\n"; |
6266 | 68 | Result += "\tunsigned int method_count;\n"; |
6267 | 68 | Result += "\tstruct _objc_method method_list["; |
6268 | 68 | Result += utostr(method_count); Result += "];\n"; |
6269 | 68 | Result += "}"; |
6270 | 68 | } |
6271 | | |
6272 | | static void Write__prop_list_t_TypeDecl(std::string &Result, |
6273 | 15 | unsigned int property_count) { |
6274 | 15 | Result += "struct /*_prop_list_t*/"; Result += " {\n"; |
6275 | 15 | Result += "\tunsigned int entsize; // sizeof(struct _prop_t)\n"; |
6276 | 15 | Result += "\tunsigned int count_of_properties;\n"; |
6277 | 15 | Result += "\tstruct _prop_t prop_list["; |
6278 | 15 | Result += utostr(property_count); Result += "];\n"; |
6279 | 15 | Result += "}"; |
6280 | 15 | } |
6281 | | |
6282 | | static void Write__ivar_list_t_TypeDecl(std::string &Result, |
6283 | 49 | unsigned int ivar_count) { |
6284 | 49 | Result += "struct /*_ivar_list_t*/"; Result += " {\n"; |
6285 | 49 | Result += "\tunsigned int entsize; // sizeof(struct _prop_t)\n"; |
6286 | 49 | Result += "\tunsigned int count;\n"; |
6287 | 49 | Result += "\tstruct _ivar_t ivar_list["; |
6288 | 49 | Result += utostr(ivar_count); Result += "];\n"; |
6289 | 49 | Result += "}"; |
6290 | 49 | } |
6291 | | |
6292 | | static void Write_protocol_list_initializer(ASTContext *Context, std::string &Result, |
6293 | | ArrayRef<ObjCProtocolDecl *> SuperProtocols, |
6294 | | StringRef VarName, |
6295 | 101 | StringRef ProtocolName) { |
6296 | 101 | if (SuperProtocols.size() > 0) { |
6297 | 6 | Result += "\nstatic "; |
6298 | 6 | Write_protocol_list_t_TypeDecl(Result, SuperProtocols.size()); |
6299 | 6 | Result += " "; Result += VarName; |
6300 | 6 | Result += ProtocolName; |
6301 | 6 | Result += " __attribute__ ((used, section (\"__DATA,__objc_const\"))) = {\n"; |
6302 | 6 | Result += "\t"; Result += utostr(SuperProtocols.size()); Result += ",\n"; |
6303 | 14 | for (unsigned i = 0, e = SuperProtocols.size(); i < e; i++8 ) { |
6304 | 8 | ObjCProtocolDecl *SuperPD = SuperProtocols[i]; |
6305 | 8 | Result += "\t&"; Result += "_OBJC_PROTOCOL_"; |
6306 | 8 | Result += SuperPD->getNameAsString(); |
6307 | 8 | if (i == e-1) |
6308 | 6 | Result += "\n};\n"; |
6309 | 2 | else |
6310 | 2 | Result += ",\n"; |
6311 | 8 | } |
6312 | 6 | } |
6313 | 101 | } |
6314 | | |
6315 | | static void Write_method_list_t_initializer(RewriteModernObjC &RewriteObj, |
6316 | | ASTContext *Context, std::string &Result, |
6317 | | ArrayRef<ObjCMethodDecl *> Methods, |
6318 | | StringRef VarName, |
6319 | | StringRef TopLevelDeclName, |
6320 | 218 | bool MethodImpl) { |
6321 | 218 | if (Methods.size() > 0) { |
6322 | 68 | Result += "\nstatic "; |
6323 | 68 | Write_method_list_t_TypeDecl(Result, Methods.size()); |
6324 | 68 | Result += " "; Result += VarName; |
6325 | 68 | Result += TopLevelDeclName; |
6326 | 68 | Result += " __attribute__ ((used, section (\"__DATA,__objc_const\"))) = {\n"; |
6327 | 68 | Result += "\t"; Result += "sizeof(_objc_method)"; Result += ",\n"; |
6328 | 68 | Result += "\t"; Result += utostr(Methods.size()); Result += ",\n"; |
6329 | 240 | for (unsigned i = 0, e = Methods.size(); i < e; i++172 ) { |
6330 | 172 | ObjCMethodDecl *MD = Methods[i]; |
6331 | 172 | if (i == 0) |
6332 | 68 | Result += "\t{{(struct objc_selector *)\""; |
6333 | 104 | else |
6334 | 104 | Result += "\t{(struct objc_selector *)\""; |
6335 | 172 | Result += (MD)->getSelector().getAsString(); Result += "\""; |
6336 | 172 | Result += ", "; |
6337 | 172 | std::string MethodTypeString = Context->getObjCEncodingForMethodDecl(MD); |
6338 | 172 | Result += "\""; Result += MethodTypeString; Result += "\""; |
6339 | 172 | Result += ", "; |
6340 | 172 | if (!MethodImpl) |
6341 | 11 | Result += "0"; |
6342 | 161 | else { |
6343 | 161 | Result += "(void *)"; |
6344 | 161 | Result += RewriteObj.MethodInternalNames[MD]; |
6345 | 161 | } |
6346 | 172 | if (i == e-1) |
6347 | 68 | Result += "}}\n"; |
6348 | 104 | else |
6349 | 104 | Result += "},\n"; |
6350 | 172 | } |
6351 | 68 | Result += "};\n"; |
6352 | 68 | } |
6353 | 218 | } |
6354 | | |
6355 | | static void Write_prop_list_t_initializer(RewriteModernObjC &RewriteObj, |
6356 | | ASTContext *Context, std::string &Result, |
6357 | | ArrayRef<ObjCPropertyDecl *> Properties, |
6358 | | const Decl *Container, |
6359 | | StringRef VarName, |
6360 | 101 | StringRef ProtocolName) { |
6361 | 101 | if (Properties.size() > 0) { |
6362 | 15 | Result += "\nstatic "; |
6363 | 15 | Write__prop_list_t_TypeDecl(Result, Properties.size()); |
6364 | 15 | Result += " "; Result += VarName; |
6365 | 15 | Result += ProtocolName; |
6366 | 15 | Result += " __attribute__ ((used, section (\"__DATA,__objc_const\"))) = {\n"; |
6367 | 15 | Result += "\t"; Result += "sizeof(_prop_t)"; Result += ",\n"; |
6368 | 15 | Result += "\t"; Result += utostr(Properties.size()); Result += ",\n"; |
6369 | 45 | for (unsigned i = 0, e = Properties.size(); i < e; i++30 ) { |
6370 | 30 | ObjCPropertyDecl *PropDecl = Properties[i]; |
6371 | 30 | if (i == 0) |
6372 | 15 | Result += "\t{{\""; |
6373 | 15 | else |
6374 | 15 | Result += "\t{\""; |
6375 | 30 | Result += PropDecl->getName(); Result += "\","; |
6376 | 30 | std::string PropertyTypeString = |
6377 | 30 | Context->getObjCEncodingForPropertyDecl(PropDecl, Container); |
6378 | 30 | std::string QuotePropertyTypeString; |
6379 | 30 | RewriteObj.QuoteDoublequotes(PropertyTypeString, QuotePropertyTypeString); |
6380 | 30 | Result += "\""; Result += QuotePropertyTypeString; Result += "\""; |
6381 | 30 | if (i == e-1) |
6382 | 15 | Result += "}}\n"; |
6383 | 15 | else |
6384 | 15 | Result += "},\n"; |
6385 | 30 | } |
6386 | 15 | Result += "};\n"; |
6387 | 15 | } |
6388 | 101 | } |
6389 | | |
6390 | | // Metadata flags |
6391 | | enum MetaDataDlags { |
6392 | | CLS = 0x0, |
6393 | | CLS_META = 0x1, |
6394 | | CLS_ROOT = 0x2, |
6395 | | OBJC2_CLS_HIDDEN = 0x10, |
6396 | | CLS_EXCEPTION = 0x20, |
6397 | | |
6398 | | /// (Obsolete) ARC-specific: this class has a .release_ivars method |
6399 | | CLS_HAS_IVAR_RELEASER = 0x40, |
6400 | | /// class was compiled with -fobjc-arr |
6401 | | CLS_COMPILED_BY_ARC = 0x80 // (1<<7) |
6402 | | }; |
6403 | | |
6404 | | static void Write__class_ro_t_initializer(ASTContext *Context, std::string &Result, |
6405 | | unsigned int flags, |
6406 | | const std::string &InstanceStart, |
6407 | | const std::string &InstanceSize, |
6408 | | ArrayRef<ObjCMethodDecl *>baseMethods, |
6409 | | ArrayRef<ObjCProtocolDecl *>baseProtocols, |
6410 | | ArrayRef<ObjCIvarDecl *>ivars, |
6411 | | ArrayRef<ObjCPropertyDecl *>Properties, |
6412 | | StringRef VarName, |
6413 | 176 | StringRef ClassName) { |
6414 | 176 | Result += "\nstatic struct _class_ro_t "; |
6415 | 176 | Result += VarName; Result += ClassName; |
6416 | 176 | Result += " __attribute__ ((used, section (\"__DATA,__objc_const\"))) = {\n"; |
6417 | 176 | Result += "\t"; |
6418 | 176 | Result += llvm::utostr(flags); Result += ", "; |
6419 | 176 | Result += InstanceStart; Result += ", "; |
6420 | 176 | Result += InstanceSize; Result += ", \n"; |
6421 | 176 | Result += "\t"; |
6422 | 176 | const llvm::Triple &Triple(Context->getTargetInfo().getTriple()); |
6423 | 176 | if (Triple.getArch() == llvm::Triple::x86_64) |
6424 | | // uint32_t const reserved; // only when building for 64bit targets |
6425 | 158 | Result += "(unsigned int)0, \n\t"; |
6426 | | // const uint8_t * const ivarLayout; |
6427 | 176 | Result += "0, \n\t"; |
6428 | 176 | Result += "\""; Result += ClassName; Result += "\",\n\t"; |
6429 | 176 | bool metaclass = ((flags & CLS_META) != 0); |
6430 | 176 | if (baseMethods.size() > 0) { |
6431 | 63 | Result += "(const struct _method_list_t *)&"; |
6432 | 63 | if (metaclass) |
6433 | 7 | Result += "_OBJC_$_CLASS_METHODS_"; |
6434 | 56 | else |
6435 | 56 | Result += "_OBJC_$_INSTANCE_METHODS_"; |
6436 | 63 | Result += ClassName; |
6437 | 63 | Result += ",\n\t"; |
6438 | 63 | } |
6439 | 113 | else |
6440 | 113 | Result += "0, \n\t"; |
6441 | | |
6442 | 176 | if (!metaclass && baseProtocols.size() > 088 ) { |
6443 | 4 | Result += "(const struct _objc_protocol_list *)&"; |
6444 | 4 | Result += "_OBJC_CLASS_PROTOCOLS_$_"; Result += ClassName; |
6445 | 4 | Result += ",\n\t"; |
6446 | 4 | } |
6447 | 172 | else |
6448 | 172 | Result += "0, \n\t"; |
6449 | | |
6450 | 176 | if (!metaclass && ivars.size() > 088 ) { |
6451 | 49 | Result += "(const struct _ivar_list_t *)&"; |
6452 | 49 | Result += "_OBJC_$_INSTANCE_VARIABLES_"; Result += ClassName; |
6453 | 49 | Result += ",\n\t"; |
6454 | 49 | } |
6455 | 127 | else |
6456 | 127 | Result += "0, \n\t"; |
6457 | | |
6458 | | // weakIvarLayout |
6459 | 176 | Result += "0, \n\t"; |
6460 | 176 | if (!metaclass && Properties.size() > 088 ) { |
6461 | 13 | Result += "(const struct _prop_list_t *)&"; |
6462 | 13 | Result += "_OBJC_$_PROP_LIST_"; Result += ClassName; |
6463 | 13 | Result += ",\n"; |
6464 | 13 | } |
6465 | 163 | else |
6466 | 163 | Result += "0, \n"; |
6467 | | |
6468 | 176 | Result += "};\n"; |
6469 | 176 | } |
6470 | | |
6471 | | static void Write_class_t(ASTContext *Context, std::string &Result, |
6472 | | StringRef VarName, |
6473 | 176 | const ObjCInterfaceDecl *CDecl, bool metaclass) { |
6474 | 176 | bool rootClass = (!CDecl->getSuperClass()); |
6475 | 176 | const ObjCInterfaceDecl *RootClass = CDecl; |
6476 | | |
6477 | 176 | if (!rootClass) { |
6478 | | // Find the Root class |
6479 | 46 | RootClass = CDecl->getSuperClass(); |
6480 | 50 | while (RootClass->getSuperClass()) { |
6481 | 4 | RootClass = RootClass->getSuperClass(); |
6482 | 4 | } |
6483 | 46 | } |
6484 | | |
6485 | 176 | if (metaclass && rootClass88 ) { |
6486 | | // Need to handle a case of use of forward declaration. |
6487 | 65 | Result += "\n"; |
6488 | 65 | Result += "extern \"C\" "; |
6489 | 65 | if (CDecl->getImplementation()) |
6490 | 65 | Result += "__declspec(dllexport) "; |
6491 | 0 | else |
6492 | 0 | Result += "__declspec(dllimport) "; |
6493 | | |
6494 | 65 | Result += "struct _class_t OBJC_CLASS_$_"; |
6495 | 65 | Result += CDecl->getNameAsString(); |
6496 | 65 | Result += ";\n"; |
6497 | 65 | } |
6498 | | // Also, for possibility of 'super' metadata class not having been defined yet. |
6499 | 176 | if (!rootClass) { |
6500 | 46 | ObjCInterfaceDecl *SuperClass = CDecl->getSuperClass(); |
6501 | 46 | Result += "\n"; |
6502 | 46 | Result += "extern \"C\" "; |
6503 | 46 | if (SuperClass->getImplementation()) |
6504 | 8 | Result += "__declspec(dllexport) "; |
6505 | 38 | else |
6506 | 38 | Result += "__declspec(dllimport) "; |
6507 | | |
6508 | 46 | Result += "struct _class_t "; |
6509 | 46 | Result += VarName; |
6510 | 46 | Result += SuperClass->getNameAsString(); |
6511 | 46 | Result += ";\n"; |
6512 | | |
6513 | 46 | if (metaclass && RootClass != SuperClass23 ) { |
6514 | 2 | Result += "extern \"C\" "; |
6515 | 2 | if (RootClass->getImplementation()) |
6516 | 2 | Result += "__declspec(dllexport) "; |
6517 | 0 | else |
6518 | 0 | Result += "__declspec(dllimport) "; |
6519 | | |
6520 | 2 | Result += "struct _class_t "; |
6521 | 2 | Result += VarName; |
6522 | 2 | Result += RootClass->getNameAsString(); |
6523 | 2 | Result += ";\n"; |
6524 | 2 | } |
6525 | 46 | } |
6526 | | |
6527 | 176 | Result += "\nextern \"C\" __declspec(dllexport) struct _class_t "; |
6528 | 176 | Result += VarName; Result += CDecl->getNameAsString(); |
6529 | 176 | Result += " __attribute__ ((used, section (\"__DATA,__objc_data\"))) = {\n"; |
6530 | 176 | Result += "\t"; |
6531 | 176 | if (metaclass) { |
6532 | 88 | if (!rootClass) { |
6533 | 23 | Result += "0, // &"; Result += VarName; |
6534 | 23 | Result += RootClass->getNameAsString(); |
6535 | 23 | Result += ",\n\t"; |
6536 | 23 | Result += "0, // &"; Result += VarName; |
6537 | 23 | Result += CDecl->getSuperClass()->getNameAsString(); |
6538 | 23 | Result += ",\n\t"; |
6539 | 23 | } |
6540 | 65 | else { |
6541 | 65 | Result += "0, // &"; Result += VarName; |
6542 | 65 | Result += CDecl->getNameAsString(); |
6543 | 65 | Result += ",\n\t"; |
6544 | 65 | Result += "0, // &OBJC_CLASS_$_"; Result += CDecl->getNameAsString(); |
6545 | 65 | Result += ",\n\t"; |
6546 | 65 | } |
6547 | 88 | } |
6548 | 88 | else { |
6549 | 88 | Result += "0, // &OBJC_METACLASS_$_"; |
6550 | 88 | Result += CDecl->getNameAsString(); |
6551 | 88 | Result += ",\n\t"; |
6552 | 88 | if (!rootClass) { |
6553 | 23 | Result += "0, // &"; Result += VarName; |
6554 | 23 | Result += CDecl->getSuperClass()->getNameAsString(); |
6555 | 23 | Result += ",\n\t"; |
6556 | 23 | } |
6557 | 65 | else |
6558 | 65 | Result += "0,\n\t"; |
6559 | 88 | } |
6560 | 176 | Result += "0, // (void *)&_objc_empty_cache,\n\t"; |
6561 | 176 | Result += "0, // unused, was (void *)&_objc_empty_vtable,\n\t"; |
6562 | 176 | if (metaclass) |
6563 | 88 | Result += "&_OBJC_METACLASS_RO_$_"; |
6564 | 88 | else |
6565 | 88 | Result += "&_OBJC_CLASS_RO_$_"; |
6566 | 176 | Result += CDecl->getNameAsString(); |
6567 | 176 | Result += ",\n};\n"; |
6568 | | |
6569 | | // Add static function to initialize some of the meta-data fields. |
6570 | | // avoid doing it twice. |
6571 | 176 | if (metaclass) |
6572 | 88 | return; |
6573 | | |
6574 | 88 | const ObjCInterfaceDecl *SuperClass = |
6575 | 88 | rootClass ? CDecl65 : CDecl->getSuperClass()23 ; |
6576 | | |
6577 | 88 | Result += "static void OBJC_CLASS_SETUP_$_"; |
6578 | 88 | Result += CDecl->getNameAsString(); |
6579 | 88 | Result += "(void ) {\n"; |
6580 | 88 | Result += "\tOBJC_METACLASS_$_"; Result += CDecl->getNameAsString(); |
6581 | 88 | Result += ".isa = "; Result += "&OBJC_METACLASS_$_"; |
6582 | 88 | Result += RootClass->getNameAsString(); Result += ";\n"; |
6583 | | |
6584 | 88 | Result += "\tOBJC_METACLASS_$_"; Result += CDecl->getNameAsString(); |
6585 | 88 | Result += ".superclass = "; |
6586 | 88 | if (rootClass) |
6587 | 65 | Result += "&OBJC_CLASS_$_"; |
6588 | 23 | else |
6589 | 23 | Result += "&OBJC_METACLASS_$_"; |
6590 | | |
6591 | 88 | Result += SuperClass->getNameAsString(); Result += ";\n"; |
6592 | | |
6593 | 88 | Result += "\tOBJC_METACLASS_$_"; Result += CDecl->getNameAsString(); |
6594 | 88 | Result += ".cache = "; Result += "&_objc_empty_cache"; Result += ";\n"; |
6595 | | |
6596 | 88 | Result += "\tOBJC_CLASS_$_"; Result += CDecl->getNameAsString(); |
6597 | 88 | Result += ".isa = "; Result += "&OBJC_METACLASS_$_"; |
6598 | 88 | Result += CDecl->getNameAsString(); Result += ";\n"; |
6599 | | |
6600 | 88 | if (!rootClass) { |
6601 | 23 | Result += "\tOBJC_CLASS_$_"; Result += CDecl->getNameAsString(); |
6602 | 23 | Result += ".superclass = "; Result += "&OBJC_CLASS_$_"; |
6603 | 23 | Result += SuperClass->getNameAsString(); Result += ";\n"; |
6604 | 23 | } |
6605 | | |
6606 | 88 | Result += "\tOBJC_CLASS_$_"; Result += CDecl->getNameAsString(); |
6607 | 88 | Result += ".cache = "; Result += "&_objc_empty_cache"; Result += ";\n"; |
6608 | 88 | Result += "}\n"; |
6609 | 88 | } |
6610 | | |
6611 | | static void Write_category_t(RewriteModernObjC &RewriteObj, ASTContext *Context, |
6612 | | std::string &Result, |
6613 | | ObjCCategoryDecl *CatDecl, |
6614 | | ObjCInterfaceDecl *ClassDecl, |
6615 | | ArrayRef<ObjCMethodDecl *> InstanceMethods, |
6616 | | ArrayRef<ObjCMethodDecl *> ClassMethods, |
6617 | | ArrayRef<ObjCProtocolDecl *> RefedProtocols, |
6618 | 5 | ArrayRef<ObjCPropertyDecl *> ClassProperties) { |
6619 | 5 | StringRef CatName = CatDecl->getName(); |
6620 | 5 | StringRef ClassName = ClassDecl->getName(); |
6621 | | // must declare an extern class object in case this class is not implemented |
6622 | | // in this TU. |
6623 | 5 | Result += "\n"; |
6624 | 5 | Result += "extern \"C\" "; |
6625 | 5 | if (ClassDecl->getImplementation()) |
6626 | 4 | Result += "__declspec(dllexport) "; |
6627 | 1 | else |
6628 | 1 | Result += "__declspec(dllimport) "; |
6629 | | |
6630 | 5 | Result += "struct _class_t "; |
6631 | 5 | Result += "OBJC_CLASS_$_"; Result += ClassName; |
6632 | 5 | Result += ";\n"; |
6633 | | |
6634 | 5 | Result += "\nstatic struct _category_t "; |
6635 | 5 | Result += "_OBJC_$_CATEGORY_"; |
6636 | 5 | Result += ClassName; Result += "_$_"; Result += CatName; |
6637 | 5 | Result += " __attribute__ ((used, section (\"__DATA,__objc_const\"))) = \n"; |
6638 | 5 | Result += "{\n"; |
6639 | 5 | Result += "\t\""; Result += ClassName; Result += "\",\n"; |
6640 | 5 | Result += "\t0, // &"; Result += "OBJC_CLASS_$_"; Result += ClassName; |
6641 | 5 | Result += ",\n"; |
6642 | 5 | if (InstanceMethods.size() > 0) { |
6643 | 0 | Result += "\t(const struct _method_list_t *)&"; |
6644 | 0 | Result += "_OBJC_$_CATEGORY_INSTANCE_METHODS_"; |
6645 | 0 | Result += ClassName; Result += "_$_"; Result += CatName; |
6646 | 0 | Result += ",\n"; |
6647 | 0 | } |
6648 | 5 | else |
6649 | 5 | Result += "\t0,\n"; |
6650 | | |
6651 | 5 | if (ClassMethods.size() > 0) { |
6652 | 0 | Result += "\t(const struct _method_list_t *)&"; |
6653 | 0 | Result += "_OBJC_$_CATEGORY_CLASS_METHODS_"; |
6654 | 0 | Result += ClassName; Result += "_$_"; Result += CatName; |
6655 | 0 | Result += ",\n"; |
6656 | 0 | } |
6657 | 5 | else |
6658 | 5 | Result += "\t0,\n"; |
6659 | | |
6660 | 5 | if (RefedProtocols.size() > 0) { |
6661 | 0 | Result += "\t(const struct _protocol_list_t *)&"; |
6662 | 0 | Result += "_OBJC_CATEGORY_PROTOCOLS_$_"; |
6663 | 0 | Result += ClassName; Result += "_$_"; Result += CatName; |
6664 | 0 | Result += ",\n"; |
6665 | 0 | } |
6666 | 5 | else |
6667 | 5 | Result += "\t0,\n"; |
6668 | | |
6669 | 5 | if (ClassProperties.size() > 0) { |
6670 | 1 | Result += "\t(const struct _prop_list_t *)&"; Result += "_OBJC_$_PROP_LIST_"; |
6671 | 1 | Result += ClassName; Result += "_$_"; Result += CatName; |
6672 | 1 | Result += ",\n"; |
6673 | 1 | } |
6674 | 4 | else |
6675 | 4 | Result += "\t0,\n"; |
6676 | | |
6677 | 5 | Result += "};\n"; |
6678 | | |
6679 | | // Add static function to initialize the class pointer in the category structure. |
6680 | 5 | Result += "static void OBJC_CATEGORY_SETUP_$_"; |
6681 | 5 | Result += ClassDecl->getNameAsString(); |
6682 | 5 | Result += "_$_"; |
6683 | 5 | Result += CatName; |
6684 | 5 | Result += "(void ) {\n"; |
6685 | 5 | Result += "\t_OBJC_$_CATEGORY_"; |
6686 | 5 | Result += ClassDecl->getNameAsString(); |
6687 | 5 | Result += "_$_"; |
6688 | 5 | Result += CatName; |
6689 | 5 | Result += ".cls = "; Result += "&OBJC_CLASS_$_"; Result += ClassName; |
6690 | 5 | Result += ";\n}\n"; |
6691 | 5 | } |
6692 | | |
6693 | | static void Write__extendedMethodTypes_initializer(RewriteModernObjC &RewriteObj, |
6694 | | ASTContext *Context, std::string &Result, |
6695 | | ArrayRef<ObjCMethodDecl *> Methods, |
6696 | | StringRef VarName, |
6697 | 8 | StringRef ProtocolName) { |
6698 | 8 | if (Methods.size() == 0) |
6699 | 6 | return; |
6700 | | |
6701 | 2 | Result += "\nstatic const char *"; |
6702 | 2 | Result += VarName; Result += ProtocolName; |
6703 | 2 | Result += " [] __attribute__ ((used, section (\"__DATA,__objc_const\"))) = \n"; |
6704 | 2 | Result += "{\n"; |
6705 | 13 | for (unsigned i = 0, e = Methods.size(); i < e; i++11 ) { |
6706 | 11 | ObjCMethodDecl *MD = Methods[i]; |
6707 | 11 | std::string MethodTypeString = |
6708 | 11 | Context->getObjCEncodingForMethodDecl(MD, true); |
6709 | 11 | std::string QuoteMethodTypeString; |
6710 | 11 | RewriteObj.QuoteDoublequotes(MethodTypeString, QuoteMethodTypeString); |
6711 | 11 | Result += "\t\""; Result += QuoteMethodTypeString; Result += "\""; |
6712 | 11 | if (i == e-1) |
6713 | 2 | Result += "\n};\n"; |
6714 | 9 | else { |
6715 | 9 | Result += ",\n"; |
6716 | 9 | } |
6717 | 11 | } |
6718 | 2 | } |
6719 | | |
6720 | | static void Write_IvarOffsetVar(RewriteModernObjC &RewriteObj, |
6721 | | ASTContext *Context, |
6722 | | std::string &Result, |
6723 | | ArrayRef<ObjCIvarDecl *> Ivars, |
6724 | 49 | ObjCInterfaceDecl *CDecl) { |
6725 | | // FIXME. visibility of offset symbols may have to be set; for Darwin |
6726 | | // this is what happens: |
6727 | | /** |
6728 | | if (Ivar->getAccessControl() == ObjCIvarDecl::Private || |
6729 | | Ivar->getAccessControl() == ObjCIvarDecl::Package || |
6730 | | Class->getVisibility() == HiddenVisibility) |
6731 | | Visibility should be: HiddenVisibility; |
6732 | | else |
6733 | | Visibility should be: DefaultVisibility; |
6734 | | */ |
6735 | | |
6736 | 49 | Result += "\n"; |
6737 | 188 | for (unsigned i =0, e = Ivars.size(); i < e; i++139 ) { |
6738 | 139 | ObjCIvarDecl *IvarDecl = Ivars[i]; |
6739 | 139 | if (Context->getLangOpts().MicrosoftExt) |
6740 | 139 | Result += "__declspec(allocate(\".objc_ivar$B\")) "; |
6741 | | |
6742 | 139 | if (!Context->getLangOpts().MicrosoftExt || |
6743 | 139 | IvarDecl->getAccessControl() == ObjCIvarDecl::Private || |
6744 | 139 | IvarDecl->getAccessControl() == ObjCIvarDecl::Package87 ) |
6745 | 52 | Result += "extern \"C\" unsigned long int "; |
6746 | 87 | else |
6747 | 87 | Result += "extern \"C\" __declspec(dllexport) unsigned long int "; |
6748 | 139 | if (Ivars[i]->isBitField()) |
6749 | 11 | RewriteObj.ObjCIvarBitfieldGroupOffset(IvarDecl, Result); |
6750 | 128 | else |
6751 | 128 | WriteInternalIvarName(CDecl, IvarDecl, Result); |
6752 | 139 | Result += " __attribute__ ((used, section (\"__DATA,__objc_ivar\")))"; |
6753 | 139 | Result += " = "; |
6754 | 139 | RewriteObj.RewriteIvarOffsetComputation(IvarDecl, Result); |
6755 | 139 | Result += ";\n"; |
6756 | 139 | if (Ivars[i]->isBitField()) { |
6757 | | // skip over rest of the ivar bitfields. |
6758 | 11 | SKIP_BITFIELDS(i , e, Ivars); |
6759 | 11 | } |
6760 | 139 | } |
6761 | 49 | } |
6762 | | |
6763 | | static void Write__ivar_list_t_initializer(RewriteModernObjC &RewriteObj, |
6764 | | ASTContext *Context, std::string &Result, |
6765 | | ArrayRef<ObjCIvarDecl *> OriginalIvars, |
6766 | | StringRef VarName, |
6767 | 88 | ObjCInterfaceDecl *CDecl) { |
6768 | 88 | if (OriginalIvars.size() > 0) { |
6769 | 49 | Write_IvarOffsetVar(RewriteObj, Context, Result, OriginalIvars, CDecl); |
6770 | 49 | SmallVector<ObjCIvarDecl *, 8> Ivars; |
6771 | | // strip off all but the first ivar bitfield from each group of ivars. |
6772 | | // Such ivars in the ivar list table will be replaced by their grouping struct |
6773 | | // 'ivar'. |
6774 | 188 | for (unsigned i = 0, e = OriginalIvars.size(); i < e; i++139 ) { |
6775 | 139 | if (OriginalIvars[i]->isBitField()) { |
6776 | 11 | Ivars.push_back(OriginalIvars[i]); |
6777 | | // skip over rest of the ivar bitfields. |
6778 | 11 | SKIP_BITFIELDS(i , e, OriginalIvars); |
6779 | 11 | } |
6780 | 128 | else |
6781 | 128 | Ivars.push_back(OriginalIvars[i]); |
6782 | 139 | } |
6783 | | |
6784 | 49 | Result += "\nstatic "; |
6785 | 49 | Write__ivar_list_t_TypeDecl(Result, Ivars.size()); |
6786 | 49 | Result += " "; Result += VarName; |
6787 | 49 | Result += CDecl->getNameAsString(); |
6788 | 49 | Result += " __attribute__ ((used, section (\"__DATA,__objc_const\"))) = {\n"; |
6789 | 49 | Result += "\t"; Result += "sizeof(_ivar_t)"; Result += ",\n"; |
6790 | 49 | Result += "\t"; Result += utostr(Ivars.size()); Result += ",\n"; |
6791 | 188 | for (unsigned i =0, e = Ivars.size(); i < e; i++139 ) { |
6792 | 139 | ObjCIvarDecl *IvarDecl = Ivars[i]; |
6793 | 139 | if (i == 0) |
6794 | 49 | Result += "\t{{"; |
6795 | 90 | else |
6796 | 90 | Result += "\t {"; |
6797 | 139 | Result += "(unsigned long int *)&"; |
6798 | 139 | if (Ivars[i]->isBitField()) |
6799 | 11 | RewriteObj.ObjCIvarBitfieldGroupOffset(IvarDecl, Result); |
6800 | 128 | else |
6801 | 128 | WriteInternalIvarName(CDecl, IvarDecl, Result); |
6802 | 139 | Result += ", "; |
6803 | | |
6804 | 139 | Result += "\""; |
6805 | 139 | if (Ivars[i]->isBitField()) |
6806 | 11 | RewriteObj.ObjCIvarBitfieldGroupDecl(Ivars[i], Result); |
6807 | 128 | else |
6808 | 128 | Result += IvarDecl->getName(); |
6809 | 139 | Result += "\", "; |
6810 | | |
6811 | 139 | QualType IVQT = IvarDecl->getType(); |
6812 | 139 | if (IvarDecl->isBitField()) |
6813 | 11 | IVQT = RewriteObj.GetGroupRecordTypeForObjCIvarBitfield(IvarDecl); |
6814 | | |
6815 | 139 | std::string IvarTypeString, QuoteIvarTypeString; |
6816 | 139 | Context->getObjCEncodingForType(IVQT, IvarTypeString, |
6817 | 139 | IvarDecl); |
6818 | 139 | RewriteObj.QuoteDoublequotes(IvarTypeString, QuoteIvarTypeString); |
6819 | 139 | Result += "\""; Result += QuoteIvarTypeString; Result += "\", "; |
6820 | | |
6821 | | // FIXME. this alignment represents the host alignment and need be changed to |
6822 | | // represent the target alignment. |
6823 | 139 | unsigned Align = Context->getTypeAlign(IVQT)/8; |
6824 | 139 | Align = llvm::Log2_32(Align); |
6825 | 139 | Result += llvm::utostr(Align); Result += ", "; |
6826 | 139 | CharUnits Size = Context->getTypeSizeInChars(IVQT); |
6827 | 139 | Result += llvm::utostr(Size.getQuantity()); |
6828 | 139 | if (i == e-1) |
6829 | 49 | Result += "}}\n"; |
6830 | 90 | else |
6831 | 90 | Result += "},\n"; |
6832 | 139 | } |
6833 | 49 | Result += "};\n"; |
6834 | 49 | } |
6835 | 88 | } |
6836 | | |
6837 | | /// RewriteObjCProtocolMetaData - Rewrite protocols meta-data. |
6838 | | void RewriteModernObjC::RewriteObjCProtocolMetaData(ObjCProtocolDecl *PDecl, |
6839 | 10 | std::string &Result) { |
6840 | | |
6841 | | // Do not synthesize the protocol more than once. |
6842 | 10 | if (ObjCSynthesizedProtocols.count(PDecl->getCanonicalDecl())) |
6843 | 2 | return; |
6844 | 8 | WriteModernMetadataDeclarations(Context, Result); |
6845 | | |
6846 | 8 | if (ObjCProtocolDecl *Def = PDecl->getDefinition()) |
6847 | 8 | PDecl = Def; |
6848 | | // Must write out all protocol definitions in current qualifier list, |
6849 | | // and in their nested qualifiers before writing out current definition. |
6850 | 8 | for (auto *I : PDecl->protocols()) |
6851 | 3 | RewriteObjCProtocolMetaData(I, Result); |
6852 | | |
6853 | | // Construct method lists. |
6854 | 8 | std::vector<ObjCMethodDecl *> InstanceMethods, ClassMethods; |
6855 | 8 | std::vector<ObjCMethodDecl *> OptInstanceMethods, OptClassMethods; |
6856 | 8 | for (auto *MD : PDecl->instance_methods()) { |
6857 | 8 | if (MD->getImplementationControl() == ObjCImplementationControl::Optional) { |
6858 | 3 | OptInstanceMethods.push_back(MD); |
6859 | 5 | } else { |
6860 | 5 | InstanceMethods.push_back(MD); |
6861 | 5 | } |
6862 | 8 | } |
6863 | | |
6864 | 8 | for (auto *MD : PDecl->class_methods()) { |
6865 | 3 | if (MD->getImplementationControl() == ObjCImplementationControl::Optional) { |
6866 | 2 | OptClassMethods.push_back(MD); |
6867 | 2 | } else { |
6868 | 1 | ClassMethods.push_back(MD); |
6869 | 1 | } |
6870 | 3 | } |
6871 | 8 | std::vector<ObjCMethodDecl *> AllMethods; |
6872 | 13 | for (unsigned i = 0, e = InstanceMethods.size(); i < e; i++5 ) |
6873 | 5 | AllMethods.push_back(InstanceMethods[i]); |
6874 | 9 | for (unsigned i = 0, e = ClassMethods.size(); i < e; i++1 ) |
6875 | 1 | AllMethods.push_back(ClassMethods[i]); |
6876 | 11 | for (unsigned i = 0, e = OptInstanceMethods.size(); i < e; i++3 ) |
6877 | 3 | AllMethods.push_back(OptInstanceMethods[i]); |
6878 | 10 | for (unsigned i = 0, e = OptClassMethods.size(); i < e; i++2 ) |
6879 | 2 | AllMethods.push_back(OptClassMethods[i]); |
6880 | | |
6881 | 8 | Write__extendedMethodTypes_initializer(*this, Context, Result, |
6882 | 8 | AllMethods, |
6883 | 8 | "_OBJC_PROTOCOL_METHOD_TYPES_", |
6884 | 8 | PDecl->getNameAsString()); |
6885 | | // Protocol's super protocol list |
6886 | 8 | SmallVector<ObjCProtocolDecl *, 8> SuperProtocols(PDecl->protocols()); |
6887 | 8 | Write_protocol_list_initializer(Context, Result, SuperProtocols, |
6888 | 8 | "_OBJC_PROTOCOL_REFS_", |
6889 | 8 | PDecl->getNameAsString()); |
6890 | | |
6891 | 8 | Write_method_list_t_initializer(*this, Context, Result, InstanceMethods, |
6892 | 8 | "_OBJC_PROTOCOL_INSTANCE_METHODS_", |
6893 | 8 | PDecl->getNameAsString(), false); |
6894 | | |
6895 | 8 | Write_method_list_t_initializer(*this, Context, Result, ClassMethods, |
6896 | 8 | "_OBJC_PROTOCOL_CLASS_METHODS_", |
6897 | 8 | PDecl->getNameAsString(), false); |
6898 | | |
6899 | 8 | Write_method_list_t_initializer(*this, Context, Result, OptInstanceMethods, |
6900 | 8 | "_OBJC_PROTOCOL_OPT_INSTANCE_METHODS_", |
6901 | 8 | PDecl->getNameAsString(), false); |
6902 | | |
6903 | 8 | Write_method_list_t_initializer(*this, Context, Result, OptClassMethods, |
6904 | 8 | "_OBJC_PROTOCOL_OPT_CLASS_METHODS_", |
6905 | 8 | PDecl->getNameAsString(), false); |
6906 | | |
6907 | | // Protocol's property metadata. |
6908 | 8 | SmallVector<ObjCPropertyDecl *, 8> ProtocolProperties( |
6909 | 8 | PDecl->instance_properties()); |
6910 | 8 | Write_prop_list_t_initializer(*this, Context, Result, ProtocolProperties, |
6911 | 8 | /* Container */nullptr, |
6912 | 8 | "_OBJC_PROTOCOL_PROPERTIES_", |
6913 | 8 | PDecl->getNameAsString()); |
6914 | | |
6915 | | // Writer out root metadata for current protocol: struct _protocol_t |
6916 | 8 | Result += "\n"; |
6917 | 8 | if (LangOpts.MicrosoftExt) |
6918 | 8 | Result += "static "; |
6919 | 8 | Result += "struct _protocol_t _OBJC_PROTOCOL_"; |
6920 | 8 | Result += PDecl->getNameAsString(); |
6921 | 8 | Result += " __attribute__ ((used)) = {\n"; |
6922 | 8 | Result += "\t0,\n"; // id is; is null |
6923 | 8 | Result += "\t\""; Result += PDecl->getNameAsString(); Result += "\",\n"; |
6924 | 8 | if (SuperProtocols.size() > 0) { |
6925 | 2 | Result += "\t(const struct _protocol_list_t *)&"; Result += "_OBJC_PROTOCOL_REFS_"; |
6926 | 2 | Result += PDecl->getNameAsString(); Result += ",\n"; |
6927 | 2 | } |
6928 | 6 | else |
6929 | 6 | Result += "\t0,\n"; |
6930 | 8 | if (InstanceMethods.size() > 0) { |
6931 | 2 | Result += "\t(const struct method_list_t *)&_OBJC_PROTOCOL_INSTANCE_METHODS_"; |
6932 | 2 | Result += PDecl->getNameAsString(); Result += ",\n"; |
6933 | 2 | } |
6934 | 6 | else |
6935 | 6 | Result += "\t0,\n"; |
6936 | | |
6937 | 8 | if (ClassMethods.size() > 0) { |
6938 | 1 | Result += "\t(const struct method_list_t *)&_OBJC_PROTOCOL_CLASS_METHODS_"; |
6939 | 1 | Result += PDecl->getNameAsString(); Result += ",\n"; |
6940 | 1 | } |
6941 | 7 | else |
6942 | 7 | Result += "\t0,\n"; |
6943 | | |
6944 | 8 | if (OptInstanceMethods.size() > 0) { |
6945 | 1 | Result += "\t(const struct method_list_t *)&_OBJC_PROTOCOL_OPT_INSTANCE_METHODS_"; |
6946 | 1 | Result += PDecl->getNameAsString(); Result += ",\n"; |
6947 | 1 | } |
6948 | 7 | else |
6949 | 7 | Result += "\t0,\n"; |
6950 | | |
6951 | 8 | if (OptClassMethods.size() > 0) { |
6952 | 1 | Result += "\t(const struct method_list_t *)&_OBJC_PROTOCOL_OPT_CLASS_METHODS_"; |
6953 | 1 | Result += PDecl->getNameAsString(); Result += ",\n"; |
6954 | 1 | } |
6955 | 7 | else |
6956 | 7 | Result += "\t0,\n"; |
6957 | | |
6958 | 8 | if (ProtocolProperties.size() > 0) { |
6959 | 1 | Result += "\t(const struct _prop_list_t *)&_OBJC_PROTOCOL_PROPERTIES_"; |
6960 | 1 | Result += PDecl->getNameAsString(); Result += ",\n"; |
6961 | 1 | } |
6962 | 7 | else |
6963 | 7 | Result += "\t0,\n"; |
6964 | | |
6965 | 8 | Result += "\t"; Result += "sizeof(_protocol_t)"; Result += ",\n"; |
6966 | 8 | Result += "\t0,\n"; |
6967 | | |
6968 | 8 | if (AllMethods.size() > 0) { |
6969 | 2 | Result += "\t(const char **)&"; Result += "_OBJC_PROTOCOL_METHOD_TYPES_"; |
6970 | 2 | Result += PDecl->getNameAsString(); |
6971 | 2 | Result += "\n};\n"; |
6972 | 2 | } |
6973 | 6 | else |
6974 | 6 | Result += "\t0\n};\n"; |
6975 | | |
6976 | 8 | if (LangOpts.MicrosoftExt) |
6977 | 8 | Result += "static "; |
6978 | 8 | Result += "struct _protocol_t *"; |
6979 | 8 | Result += "_OBJC_LABEL_PROTOCOL_$_"; Result += PDecl->getNameAsString(); |
6980 | 8 | Result += " = &_OBJC_PROTOCOL_"; Result += PDecl->getNameAsString(); |
6981 | 8 | Result += ";\n"; |
6982 | | |
6983 | | // Mark this protocol as having been generated. |
6984 | 8 | if (!ObjCSynthesizedProtocols.insert(PDecl->getCanonicalDecl()).second) |
6985 | 0 | llvm_unreachable("protocol already synthesized"); |
6986 | 8 | } |
6987 | | |
6988 | | /// hasObjCExceptionAttribute - Return true if this class or any super |
6989 | | /// class has the __objc_exception__ attribute. |
6990 | | /// FIXME. Move this to ASTContext.cpp as it is also used for IRGen. |
6991 | | static bool hasObjCExceptionAttribute(ASTContext &Context, |
6992 | 113 | const ObjCInterfaceDecl *OID) { |
6993 | 113 | if (OID->hasAttr<ObjCExceptionAttr>()) |
6994 | 0 | return true; |
6995 | 113 | if (const ObjCInterfaceDecl *Super = OID->getSuperClass()) |
6996 | 25 | return hasObjCExceptionAttribute(Context, Super); |
6997 | 88 | return false; |
6998 | 113 | } |
6999 | | |
7000 | | void RewriteModernObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, |
7001 | 88 | std::string &Result) { |
7002 | 88 | ObjCInterfaceDecl *CDecl = IDecl->getClassInterface(); |
7003 | | |
7004 | | // Explicitly declared @interface's are already synthesized. |
7005 | 88 | if (CDecl->isImplicitInterfaceDecl()) |
7006 | 0 | assert(false && |
7007 | 88 | "Legacy implicit interface rewriting not supported in moder abi"); |
7008 | | |
7009 | 88 | WriteModernMetadataDeclarations(Context, Result); |
7010 | 88 | SmallVector<ObjCIvarDecl *, 8> IVars; |
7011 | | |
7012 | 88 | for (ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin(); |
7013 | 260 | IVD; IVD = IVD->getNextIvar()172 ) { |
7014 | | // Ignore unnamed bit-fields. |
7015 | 172 | if (!IVD->getDeclName()) |
7016 | 11 | continue; |
7017 | 161 | IVars.push_back(IVD); |
7018 | 161 | } |
7019 | | |
7020 | 88 | Write__ivar_list_t_initializer(*this, Context, Result, IVars, |
7021 | 88 | "_OBJC_$_INSTANCE_VARIABLES_", |
7022 | 88 | CDecl); |
7023 | | |
7024 | | // Build _objc_method_list for class's instance methods if needed |
7025 | 88 | SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instance_methods()); |
7026 | | |
7027 | | // If any of our property implementations have associated getters or |
7028 | | // setters, produce metadata for them as well. |
7029 | 88 | for (const auto *Prop : IDecl->property_impls()) { |
7030 | 30 | if (Prop->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) |
7031 | 2 | continue; |
7032 | 28 | if (!Prop->getPropertyIvarDecl()) |
7033 | 0 | continue; |
7034 | 28 | ObjCPropertyDecl *PD = Prop->getPropertyDecl(); |
7035 | 28 | if (!PD) |
7036 | 0 | continue; |
7037 | 28 | if (ObjCMethodDecl *Getter = Prop->getGetterMethodDecl()) |
7038 | 28 | if (mustSynthesizeSetterGetterMethod(IDecl, PD, true /*getter*/)) |
7039 | 26 | InstanceMethods.push_back(Getter); |
7040 | 28 | if (PD->isReadOnly()) |
7041 | 4 | continue; |
7042 | 24 | if (ObjCMethodDecl *Setter = Prop->getSetterMethodDecl()) |
7043 | 24 | if (mustSynthesizeSetterGetterMethod(IDecl, PD, false /*setter*/)) |
7044 | 22 | InstanceMethods.push_back(Setter); |
7045 | 24 | } |
7046 | | |
7047 | 88 | Write_method_list_t_initializer(*this, Context, Result, InstanceMethods, |
7048 | 88 | "_OBJC_$_INSTANCE_METHODS_", |
7049 | 88 | IDecl->getNameAsString(), true); |
7050 | | |
7051 | 88 | SmallVector<ObjCMethodDecl *, 32> ClassMethods(IDecl->class_methods()); |
7052 | | |
7053 | 88 | Write_method_list_t_initializer(*this, Context, Result, ClassMethods, |
7054 | 88 | "_OBJC_$_CLASS_METHODS_", |
7055 | 88 | IDecl->getNameAsString(), true); |
7056 | | |
7057 | | // Protocols referenced in class declaration? |
7058 | | // Protocol's super protocol list |
7059 | 88 | std::vector<ObjCProtocolDecl *> RefedProtocols; |
7060 | 88 | const ObjCList<ObjCProtocolDecl> &Protocols = CDecl->getReferencedProtocols(); |
7061 | 88 | for (ObjCList<ObjCProtocolDecl>::iterator I = Protocols.begin(), |
7062 | 88 | E = Protocols.end(); |
7063 | 93 | I != E; ++I5 ) { |
7064 | 5 | RefedProtocols.push_back(*I); |
7065 | | // Must write out all protocol definitions in current qualifier list, |
7066 | | // and in their nested qualifiers before writing out current definition. |
7067 | 5 | RewriteObjCProtocolMetaData(*I, Result); |
7068 | 5 | } |
7069 | | |
7070 | 88 | Write_protocol_list_initializer(Context, Result, |
7071 | 88 | RefedProtocols, |
7072 | 88 | "_OBJC_CLASS_PROTOCOLS_$_", |
7073 | 88 | IDecl->getNameAsString()); |
7074 | | |
7075 | | // Protocol's property metadata. |
7076 | 88 | SmallVector<ObjCPropertyDecl *, 8> ClassProperties( |
7077 | 88 | CDecl->instance_properties()); |
7078 | 88 | Write_prop_list_t_initializer(*this, Context, Result, ClassProperties, |
7079 | 88 | /* Container */IDecl, |
7080 | 88 | "_OBJC_$_PROP_LIST_", |
7081 | 88 | CDecl->getNameAsString()); |
7082 | | |
7083 | | // Data for initializing _class_ro_t metaclass meta-data |
7084 | 88 | uint32_t flags = CLS_META; |
7085 | 88 | std::string InstanceSize; |
7086 | 88 | std::string InstanceStart; |
7087 | | |
7088 | 88 | bool classIsHidden = CDecl->getVisibility() == HiddenVisibility; |
7089 | 88 | if (classIsHidden) |
7090 | 1 | flags |= OBJC2_CLS_HIDDEN; |
7091 | | |
7092 | 88 | if (!CDecl->getSuperClass()) |
7093 | | // class is root |
7094 | 65 | flags |= CLS_ROOT; |
7095 | 88 | InstanceSize = "sizeof(struct _class_t)"; |
7096 | 88 | InstanceStart = InstanceSize; |
7097 | 88 | Write__class_ro_t_initializer(Context, Result, flags, |
7098 | 88 | InstanceStart, InstanceSize, |
7099 | 88 | ClassMethods, |
7100 | 88 | nullptr, |
7101 | 88 | nullptr, |
7102 | 88 | nullptr, |
7103 | 88 | "_OBJC_METACLASS_RO_$_", |
7104 | 88 | CDecl->getNameAsString()); |
7105 | | |
7106 | | // Data for initializing _class_ro_t meta-data |
7107 | 88 | flags = CLS; |
7108 | 88 | if (classIsHidden) |
7109 | 1 | flags |= OBJC2_CLS_HIDDEN; |
7110 | | |
7111 | 88 | if (hasObjCExceptionAttribute(*Context, CDecl)) |
7112 | 0 | flags |= CLS_EXCEPTION; |
7113 | | |
7114 | 88 | if (!CDecl->getSuperClass()) |
7115 | | // class is root |
7116 | 65 | flags |= CLS_ROOT; |
7117 | | |
7118 | 88 | InstanceSize.clear(); |
7119 | 88 | InstanceStart.clear(); |
7120 | 88 | if (!ObjCSynthesizedStructs.count(CDecl)) { |
7121 | 37 | InstanceSize = "0"; |
7122 | 37 | InstanceStart = "0"; |
7123 | 37 | } |
7124 | 51 | else { |
7125 | 51 | InstanceSize = "sizeof(struct "; |
7126 | 51 | InstanceSize += CDecl->getNameAsString(); |
7127 | 51 | InstanceSize += "_IMPL)"; |
7128 | | |
7129 | 51 | ObjCIvarDecl *IVD = CDecl->all_declared_ivar_begin(); |
7130 | 51 | if (IVD) { |
7131 | 49 | RewriteIvarOffsetComputation(IVD, InstanceStart); |
7132 | 49 | } |
7133 | 2 | else |
7134 | 2 | InstanceStart = InstanceSize; |
7135 | 51 | } |
7136 | 88 | Write__class_ro_t_initializer(Context, Result, flags, |
7137 | 88 | InstanceStart, InstanceSize, |
7138 | 88 | InstanceMethods, |
7139 | 88 | RefedProtocols, |
7140 | 88 | IVars, |
7141 | 88 | ClassProperties, |
7142 | 88 | "_OBJC_CLASS_RO_$_", |
7143 | 88 | CDecl->getNameAsString()); |
7144 | | |
7145 | 88 | Write_class_t(Context, Result, |
7146 | 88 | "OBJC_METACLASS_$_", |
7147 | 88 | CDecl, /*metaclass*/true); |
7148 | | |
7149 | 88 | Write_class_t(Context, Result, |
7150 | 88 | "OBJC_CLASS_$_", |
7151 | 88 | CDecl, /*metaclass*/false); |
7152 | | |
7153 | 88 | if (ImplementationIsNonLazy(IDecl)) |
7154 | 0 | DefinedNonLazyClasses.push_back(CDecl); |
7155 | 88 | } |
7156 | | |
7157 | 52 | void RewriteModernObjC::RewriteClassSetupInitHook(std::string &Result) { |
7158 | 52 | int ClsDefCount = ClassImplementation.size(); |
7159 | 52 | if (!ClsDefCount) |
7160 | 0 | return; |
7161 | 52 | Result += "#pragma section(\".objc_inithooks$B\", long, read, write)\n"; |
7162 | 52 | Result += "__declspec(allocate(\".objc_inithooks$B\")) "; |
7163 | 52 | Result += "static void *OBJC_CLASS_SETUP[] = {\n"; |
7164 | 140 | for (int i = 0; i < ClsDefCount; i++88 ) { |
7165 | 88 | ObjCImplementationDecl *IDecl = ClassImplementation[i]; |
7166 | 88 | ObjCInterfaceDecl *CDecl = IDecl->getClassInterface(); |
7167 | 88 | Result += "\t(void *)&OBJC_CLASS_SETUP_$_"; |
7168 | 88 | Result += CDecl->getName(); Result += ",\n"; |
7169 | 88 | } |
7170 | 52 | Result += "};\n"; |
7171 | 52 | } |
7172 | | |
7173 | 52 | void RewriteModernObjC::RewriteMetaDataIntoBuffer(std::string &Result) { |
7174 | 52 | int ClsDefCount = ClassImplementation.size(); |
7175 | 52 | int CatDefCount = CategoryImplementation.size(); |
7176 | | |
7177 | | // For each implemented class, write out all its meta data. |
7178 | 140 | for (int i = 0; i < ClsDefCount; i++88 ) |
7179 | 88 | RewriteObjCClassMetaData(ClassImplementation[i], Result); |
7180 | | |
7181 | 52 | RewriteClassSetupInitHook(Result); |
7182 | | |
7183 | | // For each implemented category, write out all its meta data. |
7184 | 57 | for (int i = 0; i < CatDefCount; i++5 ) |
7185 | 5 | RewriteObjCCategoryImplDecl(CategoryImplementation[i], Result); |
7186 | | |
7187 | 52 | RewriteCategorySetupInitHook(Result); |
7188 | | |
7189 | 52 | if (ClsDefCount > 0) { |
7190 | 52 | if (LangOpts.MicrosoftExt) |
7191 | 52 | Result += "__declspec(allocate(\".objc_classlist$B\")) "; |
7192 | 52 | Result += "static struct _class_t *L_OBJC_LABEL_CLASS_$ ["; |
7193 | 52 | Result += llvm::utostr(ClsDefCount); Result += "]"; |
7194 | 52 | Result += |
7195 | 52 | " __attribute__((used, section (\"__DATA, __objc_classlist," |
7196 | 52 | "regular,no_dead_strip\")))= {\n"; |
7197 | 140 | for (int i = 0; i < ClsDefCount; i++88 ) { |
7198 | 88 | Result += "\t&OBJC_CLASS_$_"; |
7199 | 88 | Result += ClassImplementation[i]->getNameAsString(); |
7200 | 88 | Result += ",\n"; |
7201 | 88 | } |
7202 | 52 | Result += "};\n"; |
7203 | | |
7204 | 52 | if (!DefinedNonLazyClasses.empty()) { |
7205 | 0 | if (LangOpts.MicrosoftExt) |
7206 | 0 | Result += "__declspec(allocate(\".objc_nlclslist$B\")) \n"; |
7207 | 0 | Result += "static struct _class_t *_OBJC_LABEL_NONLAZY_CLASS_$[] = {\n\t"; |
7208 | 0 | for (unsigned i = 0, e = DefinedNonLazyClasses.size(); i < e; i++) { |
7209 | 0 | Result += "\t&OBJC_CLASS_$_"; Result += DefinedNonLazyClasses[i]->getNameAsString(); |
7210 | 0 | Result += ",\n"; |
7211 | 0 | } |
7212 | 0 | Result += "};\n"; |
7213 | 0 | } |
7214 | 52 | } |
7215 | | |
7216 | 52 | if (CatDefCount > 0) { |
7217 | 3 | if (LangOpts.MicrosoftExt) |
7218 | 3 | Result += "__declspec(allocate(\".objc_catlist$B\")) "; |
7219 | 3 | Result += "static struct _category_t *L_OBJC_LABEL_CATEGORY_$ ["; |
7220 | 3 | Result += llvm::utostr(CatDefCount); Result += "]"; |
7221 | 3 | Result += |
7222 | 3 | " __attribute__((used, section (\"__DATA, __objc_catlist," |
7223 | 3 | "regular,no_dead_strip\")))= {\n"; |
7224 | 8 | for (int i = 0; i < CatDefCount; i++5 ) { |
7225 | 5 | Result += "\t&_OBJC_$_CATEGORY_"; |
7226 | 5 | Result += |
7227 | 5 | CategoryImplementation[i]->getClassInterface()->getNameAsString(); |
7228 | 5 | Result += "_$_"; |
7229 | 5 | Result += CategoryImplementation[i]->getNameAsString(); |
7230 | 5 | Result += ",\n"; |
7231 | 5 | } |
7232 | 3 | Result += "};\n"; |
7233 | 3 | } |
7234 | | |
7235 | 52 | if (!DefinedNonLazyCategories.empty()) { |
7236 | 0 | if (LangOpts.MicrosoftExt) |
7237 | 0 | Result += "__declspec(allocate(\".objc_nlcatlist$B\")) \n"; |
7238 | 0 | Result += "static struct _category_t *_OBJC_LABEL_NONLAZY_CATEGORY_$[] = {\n\t"; |
7239 | 0 | for (unsigned i = 0, e = DefinedNonLazyCategories.size(); i < e; i++) { |
7240 | 0 | Result += "\t&_OBJC_$_CATEGORY_"; |
7241 | 0 | Result += |
7242 | 0 | DefinedNonLazyCategories[i]->getClassInterface()->getNameAsString(); |
7243 | 0 | Result += "_$_"; |
7244 | 0 | Result += DefinedNonLazyCategories[i]->getNameAsString(); |
7245 | 0 | Result += ",\n"; |
7246 | 0 | } |
7247 | 0 | Result += "};\n"; |
7248 | 0 | } |
7249 | 52 | } |
7250 | | |
7251 | 78 | void RewriteModernObjC::WriteImageInfo(std::string &Result) { |
7252 | 78 | if (LangOpts.MicrosoftExt) |
7253 | 78 | Result += "__declspec(allocate(\".objc_imageinfo$B\")) \n"; |
7254 | | |
7255 | 78 | Result += "static struct IMAGE_INFO { unsigned version; unsigned flag; } "; |
7256 | | // version 0, ObjCABI is 2 |
7257 | 78 | Result += "_OBJC_IMAGE_INFO = { 0, 2 };\n"; |
7258 | 78 | } |
7259 | | |
7260 | | /// RewriteObjCCategoryImplDecl - Rewrite metadata for each category |
7261 | | /// implementation. |
7262 | | void RewriteModernObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, |
7263 | 5 | std::string &Result) { |
7264 | 5 | WriteModernMetadataDeclarations(Context, Result); |
7265 | 5 | ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface(); |
7266 | | // Find category declaration for this implementation. |
7267 | 5 | ObjCCategoryDecl *CDecl |
7268 | 5 | = ClassDecl->FindCategoryDeclaration(IDecl->getIdentifier()); |
7269 | | |
7270 | 5 | std::string FullCategoryName = ClassDecl->getNameAsString(); |
7271 | 5 | FullCategoryName += "_$_"; |
7272 | 5 | FullCategoryName += CDecl->getNameAsString(); |
7273 | | |
7274 | | // Build _objc_method_list for class's instance methods if needed |
7275 | 5 | SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instance_methods()); |
7276 | | |
7277 | | // If any of our property implementations have associated getters or |
7278 | | // setters, produce metadata for them as well. |
7279 | 5 | for (const auto *Prop : IDecl->property_impls()) { |
7280 | 1 | if (Prop->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) |
7281 | 1 | continue; |
7282 | 0 | if (!Prop->getPropertyIvarDecl()) |
7283 | 0 | continue; |
7284 | 0 | ObjCPropertyDecl *PD = Prop->getPropertyDecl(); |
7285 | 0 | if (!PD) |
7286 | 0 | continue; |
7287 | 0 | if (ObjCMethodDecl *Getter = Prop->getGetterMethodDecl()) |
7288 | 0 | InstanceMethods.push_back(Getter); |
7289 | 0 | if (PD->isReadOnly()) |
7290 | 0 | continue; |
7291 | 0 | if (ObjCMethodDecl *Setter = Prop->getSetterMethodDecl()) |
7292 | 0 | InstanceMethods.push_back(Setter); |
7293 | 0 | } |
7294 | | |
7295 | 5 | Write_method_list_t_initializer(*this, Context, Result, InstanceMethods, |
7296 | 5 | "_OBJC_$_CATEGORY_INSTANCE_METHODS_", |
7297 | 5 | FullCategoryName, true); |
7298 | | |
7299 | 5 | SmallVector<ObjCMethodDecl *, 32> ClassMethods(IDecl->class_methods()); |
7300 | | |
7301 | 5 | Write_method_list_t_initializer(*this, Context, Result, ClassMethods, |
7302 | 5 | "_OBJC_$_CATEGORY_CLASS_METHODS_", |
7303 | 5 | FullCategoryName, true); |
7304 | | |
7305 | | // Protocols referenced in class declaration? |
7306 | | // Protocol's super protocol list |
7307 | 5 | SmallVector<ObjCProtocolDecl *, 8> RefedProtocols(CDecl->protocols()); |
7308 | 5 | for (auto *I : CDecl->protocols()) |
7309 | | // Must write out all protocol definitions in current qualifier list, |
7310 | | // and in their nested qualifiers before writing out current definition. |
7311 | 0 | RewriteObjCProtocolMetaData(I, Result); |
7312 | | |
7313 | 5 | Write_protocol_list_initializer(Context, Result, |
7314 | 5 | RefedProtocols, |
7315 | 5 | "_OBJC_CATEGORY_PROTOCOLS_$_", |
7316 | 5 | FullCategoryName); |
7317 | | |
7318 | | // Protocol's property metadata. |
7319 | 5 | SmallVector<ObjCPropertyDecl *, 8> ClassProperties( |
7320 | 5 | CDecl->instance_properties()); |
7321 | 5 | Write_prop_list_t_initializer(*this, Context, Result, ClassProperties, |
7322 | 5 | /* Container */IDecl, |
7323 | 5 | "_OBJC_$_PROP_LIST_", |
7324 | 5 | FullCategoryName); |
7325 | | |
7326 | 5 | Write_category_t(*this, Context, Result, |
7327 | 5 | CDecl, |
7328 | 5 | ClassDecl, |
7329 | 5 | InstanceMethods, |
7330 | 5 | ClassMethods, |
7331 | 5 | RefedProtocols, |
7332 | 5 | ClassProperties); |
7333 | | |
7334 | | // Determine if this category is also "non-lazy". |
7335 | 5 | if (ImplementationIsNonLazy(IDecl)) |
7336 | 0 | DefinedNonLazyCategories.push_back(CDecl); |
7337 | 5 | } |
7338 | | |
7339 | 52 | void RewriteModernObjC::RewriteCategorySetupInitHook(std::string &Result) { |
7340 | 52 | int CatDefCount = CategoryImplementation.size(); |
7341 | 52 | if (!CatDefCount) |
7342 | 49 | return; |
7343 | 3 | Result += "#pragma section(\".objc_inithooks$B\", long, read, write)\n"; |
7344 | 3 | Result += "__declspec(allocate(\".objc_inithooks$B\")) "; |
7345 | 3 | Result += "static void *OBJC_CATEGORY_SETUP[] = {\n"; |
7346 | 8 | for (int i = 0; i < CatDefCount; i++5 ) { |
7347 | 5 | ObjCCategoryImplDecl *IDecl = CategoryImplementation[i]; |
7348 | 5 | ObjCCategoryDecl *CatDecl= IDecl->getCategoryDecl(); |
7349 | 5 | ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface(); |
7350 | 5 | Result += "\t(void *)&OBJC_CATEGORY_SETUP_$_"; |
7351 | 5 | Result += ClassDecl->getName(); |
7352 | 5 | Result += "_$_"; |
7353 | 5 | Result += CatDecl->getName(); |
7354 | 5 | Result += ",\n"; |
7355 | 5 | } |
7356 | 3 | Result += "};\n"; |
7357 | 3 | } |
7358 | | |
7359 | | // RewriteObjCMethodsMetaData - Rewrite methods metadata for instance or |
7360 | | /// class methods. |
7361 | | template<typename MethodIterator> |
7362 | | void RewriteModernObjC::RewriteObjCMethodsMetaData(MethodIterator MethodBegin, |
7363 | | MethodIterator MethodEnd, |
7364 | | bool IsInstanceMethod, |
7365 | | StringRef prefix, |
7366 | | StringRef ClassName, |
7367 | | std::string &Result) { |
7368 | | if (MethodBegin == MethodEnd) return; |
7369 | | |
7370 | | if (!objc_impl_method) { |
7371 | | /* struct _objc_method { |
7372 | | SEL _cmd; |
7373 | | char *method_types; |
7374 | | void *_imp; |
7375 | | } |
7376 | | */ |
7377 | | Result += "\nstruct _objc_method {\n"; |
7378 | | Result += "\tSEL _cmd;\n"; |
7379 | | Result += "\tchar *method_types;\n"; |
7380 | | Result += "\tvoid *_imp;\n"; |
7381 | | Result += "};\n"; |
7382 | | |
7383 | | objc_impl_method = true; |
7384 | | } |
7385 | | |
7386 | | // Build _objc_method_list for class's methods if needed |
7387 | | |
7388 | | /* struct { |
7389 | | struct _objc_method_list *next_method; |
7390 | | int method_count; |
7391 | | struct _objc_method method_list[]; |
7392 | | } |
7393 | | */ |
7394 | | unsigned NumMethods = std::distance(MethodBegin, MethodEnd); |
7395 | | Result += "\n"; |
7396 | | if (LangOpts.MicrosoftExt) { |
7397 | | if (IsInstanceMethod) |
7398 | | Result += "__declspec(allocate(\".inst_meth$B\")) "; |
7399 | | else |
7400 | | Result += "__declspec(allocate(\".cls_meth$B\")) "; |
7401 | | } |
7402 | | Result += "static struct {\n"; |
7403 | | Result += "\tstruct _objc_method_list *next_method;\n"; |
7404 | | Result += "\tint method_count;\n"; |
7405 | | Result += "\tstruct _objc_method method_list["; |
7406 | | Result += utostr(NumMethods); |
7407 | | Result += "];\n} _OBJC_"; |
7408 | | Result += prefix; |
7409 | | Result += IsInstanceMethod ? "INSTANCE" : "CLASS"; |
7410 | | Result += "_METHODS_"; |
7411 | | Result += ClassName; |
7412 | | Result += " __attribute__ ((used, section (\"__OBJC, __"; |
7413 | | Result += IsInstanceMethod ? "inst" : "cls"; |
7414 | | Result += "_meth\")))= "; |
7415 | | Result += "{\n\t0, " + utostr(NumMethods) + "\n"; |
7416 | | |
7417 | | Result += "\t,{{(SEL)\""; |
7418 | | Result += (*MethodBegin)->getSelector().getAsString().c_str(); |
7419 | | std::string MethodTypeString; |
7420 | | Context->getObjCEncodingForMethodDecl(*MethodBegin, MethodTypeString); |
7421 | | Result += "\", \""; |
7422 | | Result += MethodTypeString; |
7423 | | Result += "\", (void *)"; |
7424 | | Result += MethodInternalNames[*MethodBegin]; |
7425 | | Result += "}\n"; |
7426 | | for (++MethodBegin; MethodBegin != MethodEnd; ++MethodBegin) { |
7427 | | Result += "\t ,{(SEL)\""; |
7428 | | Result += (*MethodBegin)->getSelector().getAsString().c_str(); |
7429 | | std::string MethodTypeString; |
7430 | | Context->getObjCEncodingForMethodDecl(*MethodBegin, MethodTypeString); |
7431 | | Result += "\", \""; |
7432 | | Result += MethodTypeString; |
7433 | | Result += "\", (void *)"; |
7434 | | Result += MethodInternalNames[*MethodBegin]; |
7435 | | Result += "}\n"; |
7436 | | } |
7437 | | Result += "\t }\n};\n"; |
7438 | | } |
7439 | | |
7440 | 97 | Stmt *RewriteModernObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) { |
7441 | 97 | SourceRange OldRange = IV->getSourceRange(); |
7442 | 97 | Expr *BaseExpr = IV->getBase(); |
7443 | | |
7444 | | // Rewrite the base, but without actually doing replaces. |
7445 | 97 | { |
7446 | 97 | DisableReplaceStmtScope S(*this); |
7447 | 97 | BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr)); |
7448 | 97 | IV->setBase(BaseExpr); |
7449 | 97 | } |
7450 | | |
7451 | 97 | ObjCIvarDecl *D = IV->getDecl(); |
7452 | | |
7453 | 97 | Expr *Replacement = IV; |
7454 | | |
7455 | 97 | if (BaseExpr->getType()->isObjCObjectPointerType()) { |
7456 | 97 | const ObjCInterfaceType *iFaceDecl = |
7457 | 97 | dyn_cast<ObjCInterfaceType>(BaseExpr->getType()->getPointeeType()); |
7458 | 97 | assert(iFaceDecl && "RewriteObjCIvarRefExpr - iFaceDecl is null"); |
7459 | | // lookup which class implements the instance variable. |
7460 | 97 | ObjCInterfaceDecl *clsDeclared = nullptr; |
7461 | 97 | iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), |
7462 | 97 | clsDeclared); |
7463 | 97 | assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class"); |
7464 | | |
7465 | | // Build name of symbol holding ivar offset. |
7466 | 97 | std::string IvarOffsetName; |
7467 | 97 | if (D->isBitField()) |
7468 | 15 | ObjCIvarBitfieldGroupOffset(D, IvarOffsetName); |
7469 | 82 | else |
7470 | 82 | WriteInternalIvarName(clsDeclared, D, IvarOffsetName); |
7471 | | |
7472 | 97 | ReferencedIvars[clsDeclared].insert(D); |
7473 | | |
7474 | | // cast offset to "char *". |
7475 | 97 | CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, |
7476 | 97 | Context->getPointerType(Context->CharTy), |
7477 | 97 | CK_BitCast, |
7478 | 97 | BaseExpr); |
7479 | 97 | VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(), |
7480 | 97 | SourceLocation(), &Context->Idents.get(IvarOffsetName), |
7481 | 97 | Context->UnsignedLongTy, nullptr, |
7482 | 97 | SC_Extern); |
7483 | 97 | DeclRefExpr *DRE = new (Context) |
7484 | 97 | DeclRefExpr(*Context, NewVD, false, Context->UnsignedLongTy, |
7485 | 97 | VK_LValue, SourceLocation()); |
7486 | 97 | BinaryOperator *addExpr = BinaryOperator::Create( |
7487 | 97 | *Context, castExpr, DRE, BO_Add, |
7488 | 97 | Context->getPointerType(Context->CharTy), VK_PRValue, OK_Ordinary, |
7489 | 97 | SourceLocation(), FPOptionsOverride()); |
7490 | | // Don't forget the parens to enforce the proper binding. |
7491 | 97 | ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), |
7492 | 97 | SourceLocation(), |
7493 | 97 | addExpr); |
7494 | 97 | QualType IvarT = D->getType(); |
7495 | 97 | if (D->isBitField()) |
7496 | 15 | IvarT = GetGroupRecordTypeForObjCIvarBitfield(D); |
7497 | | |
7498 | 97 | if (!IvarT->getAs<TypedefType>() && IvarT->isRecordType()80 ) { |
7499 | 50 | RecordDecl *RD = IvarT->castAs<RecordType>()->getDecl(); |
7500 | 50 | RD = RD->getDefinition(); |
7501 | 50 | if (RD && !RD->getDeclName().getAsIdentifierInfo()) { |
7502 | | // decltype(((Foo_IMPL*)0)->bar) * |
7503 | 12 | auto *CDecl = cast<ObjCContainerDecl>(D->getDeclContext()); |
7504 | | // ivar in class extensions requires special treatment. |
7505 | 12 | if (ObjCCategoryDecl *CatDecl = dyn_cast<ObjCCategoryDecl>(CDecl)) |
7506 | 1 | CDecl = CatDecl->getClassInterface(); |
7507 | 12 | std::string RecName = std::string(CDecl->getName()); |
7508 | 12 | RecName += "_IMPL"; |
7509 | 12 | RecordDecl *RD = RecordDecl::Create( |
7510 | 12 | *Context, TagTypeKind::Struct, TUDecl, SourceLocation(), |
7511 | 12 | SourceLocation(), &Context->Idents.get(RecName)); |
7512 | 12 | QualType PtrStructIMPL = Context->getPointerType(Context->getTagDeclType(RD)); |
7513 | 12 | unsigned UnsignedIntSize = |
7514 | 12 | static_cast<unsigned>(Context->getTypeSize(Context->UnsignedIntTy)); |
7515 | 12 | Expr *Zero = IntegerLiteral::Create(*Context, |
7516 | 12 | llvm::APInt(UnsignedIntSize, 0), |
7517 | 12 | Context->UnsignedIntTy, SourceLocation()); |
7518 | 12 | Zero = NoTypeInfoCStyleCastExpr(Context, PtrStructIMPL, CK_BitCast, Zero); |
7519 | 12 | ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), |
7520 | 12 | Zero); |
7521 | 12 | FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
7522 | 12 | SourceLocation(), |
7523 | 12 | &Context->Idents.get(D->getNameAsString()), |
7524 | 12 | IvarT, nullptr, |
7525 | 12 | /*BitWidth=*/nullptr, |
7526 | 12 | /*Mutable=*/true, ICIS_NoInit); |
7527 | 12 | MemberExpr *ME = MemberExpr::CreateImplicit( |
7528 | 12 | *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary); |
7529 | 12 | IvarT = Context->getDecltypeType(ME, ME->getType()); |
7530 | 12 | } |
7531 | 50 | } |
7532 | 97 | convertObjCTypeToCStyleType(IvarT); |
7533 | 97 | QualType castT = Context->getPointerType(IvarT); |
7534 | | |
7535 | 97 | castExpr = NoTypeInfoCStyleCastExpr(Context, |
7536 | 97 | castT, |
7537 | 97 | CK_BitCast, |
7538 | 97 | PE); |
7539 | | |
7540 | 97 | Expr *Exp = UnaryOperator::Create( |
7541 | 97 | const_cast<ASTContext &>(*Context), castExpr, UO_Deref, IvarT, |
7542 | 97 | VK_LValue, OK_Ordinary, SourceLocation(), false, FPOptionsOverride()); |
7543 | 97 | PE = new (Context) ParenExpr(OldRange.getBegin(), |
7544 | 97 | OldRange.getEnd(), |
7545 | 97 | Exp); |
7546 | | |
7547 | 97 | if (D->isBitField()) { |
7548 | 15 | FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), |
7549 | 15 | SourceLocation(), |
7550 | 15 | &Context->Idents.get(D->getNameAsString()), |
7551 | 15 | D->getType(), nullptr, |
7552 | 15 | /*BitWidth=*/D->getBitWidth(), |
7553 | 15 | /*Mutable=*/true, ICIS_NoInit); |
7554 | 15 | MemberExpr *ME = |
7555 | 15 | MemberExpr::CreateImplicit(*Context, PE, /*isArrow*/ false, FD, |
7556 | 15 | FD->getType(), VK_LValue, OK_Ordinary); |
7557 | 15 | Replacement = ME; |
7558 | | |
7559 | 15 | } |
7560 | 82 | else |
7561 | 82 | Replacement = PE; |
7562 | 97 | } |
7563 | | |
7564 | 97 | ReplaceStmtWithRange(IV, Replacement, OldRange); |
7565 | 97 | return Replacement; |
7566 | 97 | } |
7567 | | |
7568 | | #endif // CLANG_ENABLE_OBJC_REWRITER |