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