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