/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Frontend/Rewrite/RewriteObjC.cpp

Bug Summary

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

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name RewriteObjC.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Frontend/Rewrite -resource-dir /usr/lib/llvm-14/lib/clang/14.0.0 -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Frontend/Rewrite -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Frontend/Rewrite -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/include -I /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/llvm/include -D NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-14/lib/clang/14.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/build-llvm/tools/clang/lib/Frontend/Rewrite -fdebug-prefix-map=/build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2021-09-04-040900-46481-1 -x c++ /build/llvm-toolchain-snapshot-14~++20210903100615+fd66b44ec19e/clang/lib/Frontend/Rewrite/RewriteObjC.cpp

1//===--- RewriteObjC.cpp - Playground for the code rewriter ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Hacks and fun related to the code rewriter.
10//
11//===----------------------------------------------------------------------===//

13#include "clang/Rewrite/Frontend/ASTConsumers.h"
14#include "clang/AST/AST.h"
15#include "clang/AST/ASTConsumer.h"
16#include "clang/AST/Attr.h"
17#include "clang/AST/ParentMap.h"
18#include "clang/Basic/CharInfo.h"
19#include "clang/Basic/Diagnostic.h"
20#include "clang/Basic/IdentifierTable.h"
21#include "clang/Basic/SourceManager.h"
22#include "clang/Config/config.h"
23#include "clang/Lex/Lexer.h"
24#include "clang/Rewrite/Core/Rewriter.h"
25#include "llvm/ADT/DenseSet.h"
26#include "llvm/ADT/SmallPtrSet.h"
27#include "llvm/ADT/StringExtras.h"
28#include "llvm/Support/MemoryBuffer.h"
29#include "llvm/Support/raw_ostream.h"
30#include <memory>

32#if CLANG_ENABLE_OBJC_REWRITER1

34using namespace clang;
35using llvm::utostr;

37namespace {
class RewriteObjC : public ASTConsumer {
protected:
  enum {
    BLOCK_FIELD_IS_OBJECT   =  3,  /* id, NSObject, __attribute__((NSObject)),
                                      block, ... */
    BLOCK_FIELD_IS_BLOCK    =  7,  /* a block variable */
    BLOCK_FIELD_IS_BYREF    =  8,  /* the on stack structure holding the
                                      __block variable */
    BLOCK_FIELD_IS_WEAK     = 16,  /* declared __weak, only used in byref copy
                                      helpers */
    BLOCK_BYREF_CALLER      = 128, /* called from __block (byref) copy/dispose
                                      support routines */
    BLOCK_BYREF_CURRENT_MAX = 256
  };

  enum {
    BLOCK_NEEDS_FREE =        (1 << 24),
    BLOCK_HAS_COPY_DISPOSE =  (1 << 25),
    BLOCK_HAS_CXX_OBJ =       (1 << 26),
    BLOCK_IS_GC =             (1 << 27),
    BLOCK_IS_GLOBAL =         (1 << 28),
    BLOCK_HAS_DESCRIPTOR =    (1 << 29)
  };
  static const int OBJC_ABI_VERSION = 7;

  Rewriter Rewrite;
  DiagnosticsEngine &Diags;
  const LangOptions &LangOpts;
  ASTContext *Context;
  SourceManager *SM;
  TranslationUnitDecl *TUDecl;
  FileID MainFileID;
  const char *MainFileStart, *MainFileEnd;
  Stmt *CurrentBody;
  ParentMap *PropParentMap; // created lazily.
  std::string InFileName;
  std::unique_ptr<raw_ostream> OutFile;
  std::string Preamble;

  TypeDecl *ProtocolTypeDecl;
  VarDecl *GlobalVarDecl;
  unsigned RewriteFailedDiag;
  // ObjC string constant support.
  unsigned NumObjCStringLiterals;
  VarDecl *ConstantStringClassReference;
  RecordDecl *NSStringRecord;

  // ObjC foreach break/continue generation support.
  int BcLabelCount;

  unsigned TryFinallyContainsReturnDiag;
  // Needed for super.
  ObjCMethodDecl *CurMethodDef;
  RecordDecl *SuperStructDecl;
  RecordDecl *ConstantStringDecl;

  FunctionDecl *MsgSendFunctionDecl;
  FunctionDecl *MsgSendSuperFunctionDecl;
  FunctionDecl *MsgSendStretFunctionDecl;
  FunctionDecl *MsgSendSuperStretFunctionDecl;
  FunctionDecl *MsgSendFpretFunctionDecl;
  FunctionDecl *GetClassFunctionDecl;
  FunctionDecl *GetMetaClassFunctionDecl;
  FunctionDecl *GetSuperClassFunctionDecl;
  FunctionDecl *SelGetUidFunctionDecl;
  FunctionDecl *CFStringFunctionDecl;
  FunctionDecl *SuperConstructorFunctionDecl;
  FunctionDecl *CurFunctionDef;
  FunctionDecl *CurFunctionDeclToDeclareForBlock;

  /* Misc. containers needed for meta-data rewrite. */
  SmallVector<ObjCImplementationDecl *, 8> ClassImplementation;
  SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation;
  llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs;
  llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols;
  llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCForwardDecls;
  llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;
  SmallVector<Stmt *, 32> Stmts;
  SmallVector<int, 8> ObjCBcLabelNo;
  // Remember all the @protocol(<expr>) expressions.
  llvm::SmallPtrSet<ObjCProtocolDecl *, 32> ProtocolExprDecls;

  llvm::DenseSet<uint64_t> CopyDestroyCache;

  // Block expressions.
  SmallVector<BlockExpr *, 32> Blocks;
  SmallVector<int, 32> InnerDeclRefsCount;
  SmallVector<DeclRefExpr *, 32> InnerDeclRefs;

  SmallVector<DeclRefExpr *, 32> BlockDeclRefs;

  // Block related declarations.
  SmallVector<ValueDecl *, 8> BlockByCopyDecls;
  llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDeclsPtrSet;
  SmallVector<ValueDecl *, 8> BlockByRefDecls;
  llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDeclsPtrSet;
  llvm::DenseMap<ValueDecl *, unsigned> BlockByRefDeclNo;
  llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls;
  llvm::SmallPtrSet<VarDecl *, 8> ImportedLocalExternalDecls;

  llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;

  // This maps an original source AST to it's rewritten form. This allows
  // us to avoid rewriting the same node twice (which is very uncommon).
  // This is needed to support some of the exotic property rewriting.
  llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;

  // Needed for header files being rewritten
  bool IsHeader;
  bool SilenceRewriteMacroWarning;
  bool objc_impl_method;

  bool DisableReplaceStmt;
  class DisableReplaceStmtScope {
    RewriteObjC &R;
    bool SavedValue;

  public:
    DisableReplaceStmtScope(RewriteObjC &R)
      : R(R), SavedValue(R.DisableReplaceStmt) {
      R.DisableReplaceStmt = true;
    }

    ~DisableReplaceStmtScope() {
      R.DisableReplaceStmt = SavedValue;
    }
  };

  void InitializeCommon(ASTContext &context);

public:
  // Top Level Driver code.
  bool HandleTopLevelDecl(DeclGroupRef D) override {
    for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
      if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(*I)) {
        if (!Class->isThisDeclarationADefinition()) {
          RewriteForwardClassDecl(D);
          break;
        }
      }

      if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(*I)) {
        if (!Proto->isThisDeclarationADefinition()) {
          RewriteForwardProtocolDecl(D);
          break;
        }
      }

      HandleTopLevelSingleDecl(*I);
    }
    return true;
  }

  void HandleTopLevelSingleDecl(Decl *D);
  void HandleDeclInMainFile(Decl *D);
  RewriteObjC(std::string inFile, std::unique_ptr<raw_ostream> OS,
              DiagnosticsEngine &D, const LangOptions &LOpts,
              bool silenceMacroWarn);

  ~RewriteObjC() override {}

  void HandleTranslationUnit(ASTContext &C) override;

  void ReplaceStmt(Stmt *Old, Stmt *New) {
    ReplaceStmtWithRange(Old, New, Old->getSourceRange());
  }

  void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
    assert(Old != nullptr && New != nullptr && "Expected non-null Stmt's")(static_cast<void> (0));

    Stmt *ReplacingStmt = ReplacedNodes[Old];
    if (ReplacingStmt)
      return; // We can't rewrite the same node twice.

    if (DisableReplaceStmt)
      return;

    // Measure the old text.
    int Size = Rewrite.getRangeSize(SrcRange);
    if (Size == -1) {
      Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)
          << Old->getSourceRange();
      return;
    }
    // Get the new text.
    std::string SStr;
    llvm::raw_string_ostream S(SStr);
    New->printPretty(S, nullptr, PrintingPolicy(LangOpts));
    const std::string &Str = S.str();

    // If replacement succeeded or warning disabled return with no warning.
    if (!Rewrite.ReplaceText(SrcRange.getBegin(), Size, Str)) {
      ReplacedNodes[Old] = New;
      return;
    }
    if (SilenceRewriteMacroWarning)
      return;
    Diags.Report(Context->getFullLoc(Old->getBeginLoc()), RewriteFailedDiag)
        << Old->getSourceRange();
  }

  void InsertText(SourceLocation Loc, StringRef Str,
                  bool InsertAfter = true) {
    // If insertion succeeded or warning disabled return with no warning.
    if (!Rewrite.InsertText(Loc, Str, InsertAfter) ||
        SilenceRewriteMacroWarning)
      return;

    Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
  }

  void ReplaceText(SourceLocation Start, unsigned OrigLength,
                   StringRef Str) {
    // If removal succeeded or warning disabled return with no warning.
    if (!Rewrite.ReplaceText(Start, OrigLength, Str) ||
        SilenceRewriteMacroWarning)
      return;

    Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag);
  }

  // Syntactic Rewriting.
  void RewriteRecordBody(RecordDecl *RD);
  void RewriteInclude();
  void RewriteForwardClassDecl(DeclGroupRef D);
  void RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &DG);
  void RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,
                                   const std::string &typedefString);
  void RewriteImplementations();
  void RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
                               ObjCImplementationDecl *IMD,
                               ObjCCategoryImplDecl *CID);
  void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl);
  void RewriteImplementationDecl(Decl *Dcl);
  void RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,
                             ObjCMethodDecl *MDecl, std::string &ResultStr);
  void RewriteTypeIntoString(QualType T, std::string &ResultStr,
                             const FunctionType *&FPRetType);
  void RewriteByRefString(std::string &ResultStr, const std::string &Name,
                          ValueDecl *VD, bool def=false);
  void RewriteCategoryDecl(ObjCCategoryDecl *Dcl);
  void RewriteProtocolDecl(ObjCProtocolDecl *Dcl);
  void RewriteForwardProtocolDecl(DeclGroupRef D);
  void RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG);
  void RewriteMethodDeclaration(ObjCMethodDecl *Method);
  void RewriteProperty(ObjCPropertyDecl *prop);
  void RewriteFunctionDecl(FunctionDecl *FD);
  void RewriteBlockPointerType(std::string& Str, QualType Type);
  void RewriteBlockPointerTypeVariable(std::string& Str, ValueDecl *VD);
  void RewriteBlockLiteralFunctionDecl(FunctionDecl *FD);
  void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl);
  void RewriteTypeOfDecl(VarDecl *VD);
  void RewriteObjCQualifiedInterfaceTypes(Expr *E);

  // Expression Rewriting.
  Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
  Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
  Stmt *RewritePropertyOrImplicitGetter(PseudoObjectExpr *Pseudo);
  Stmt *RewritePropertyOrImplicitSetter(PseudoObjectExpr *Pseudo);
  Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
  Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
  Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
  Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
  void RewriteTryReturnStmts(Stmt *S);
  void RewriteSyncReturnStmts(Stmt *S, std::string buf);
  Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
  Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
  Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
  Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
                                     SourceLocation OrigEnd);
  Stmt *RewriteBreakStmt(BreakStmt *S);
  Stmt *RewriteContinueStmt(ContinueStmt *S);
  void RewriteCastExpr(CStyleCastExpr *CE);

  // Block rewriting.
  void RewriteBlocksInFunctionProtoType(QualType funcType, NamedDecl *D);

  // Block specific rewrite rules.
  void RewriteBlockPointerDecl(NamedDecl *VD);
  void RewriteByRefVar(VarDecl *VD);
  Stmt *RewriteBlockDeclRefExpr(DeclRefExpr *VD);
  Stmt *RewriteLocalVariableExternalStorage(DeclRefExpr *DRE);
  void RewriteBlockPointerFunctionArgs(FunctionDecl *FD);

  void RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl,
                                    std::string &Result);

  void Initialize(ASTContext &context) override = 0;

  // Metadata Rewriting.
  virtual void RewriteMetaDataIntoBuffer(std::string &Result) = 0;
  virtual void RewriteObjCProtocolListMetaData(const ObjCList<ObjCProtocolDecl> &Prots,
                                               StringRef prefix,
                                               StringRef ClassName,
                                               std::string &Result) = 0;
  virtual void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
                                           std::string &Result) = 0;
  virtual void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol,
                                   StringRef prefix,
                                   StringRef ClassName,
                                   std::string &Result) = 0;
  virtual void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
                                        std::string &Result) = 0;

  // Rewriting ivar access
  virtual Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) = 0;
  virtual void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,
                                       std::string &Result) = 0;

  // Misc. AST transformation routines. Sometimes they end up calling
  // rewriting routines on the new ASTs.
  CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
                                         ArrayRef<Expr *> Args,
                                         SourceLocation StartLoc=SourceLocation(),
                                         SourceLocation EndLoc=SourceLocation());
  CallExpr *SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
                                      QualType msgSendType,
                                      QualType returnType,
                                      SmallVectorImpl<QualType> &ArgTypes,
                                      SmallVectorImpl<Expr*> &MsgExprs,
                                      ObjCMethodDecl *Method);
  Stmt *SynthMessageExpr(ObjCMessageExpr *Exp,
                         SourceLocation StartLoc=SourceLocation(),
                         SourceLocation EndLoc=SourceLocation());

  void SynthCountByEnumWithState(std::string &buf);
  void SynthMsgSendFunctionDecl();
  void SynthMsgSendSuperFunctionDecl();
  void SynthMsgSendStretFunctionDecl();
  void SynthMsgSendFpretFunctionDecl();
  void SynthMsgSendSuperStretFunctionDecl();
  void SynthGetClassFunctionDecl();
  void SynthGetMetaClassFunctionDecl();
  void SynthGetSuperClassFunctionDecl();
  void SynthSelGetUidFunctionDecl();
  void SynthSuperConstructorFunctionDecl();

  std::string SynthesizeByrefCopyDestroyHelper(VarDecl *VD, int flag);
  std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
                                    StringRef funcName, std::string Tag);
  std::string SynthesizeBlockFunc(BlockExpr *CE, int i,
                                    StringRef funcName, std::string Tag);
  std::string SynthesizeBlockImpl(BlockExpr *CE,
                                  std::string Tag, std::string Desc);
  std::string SynthesizeBlockDescriptor(std::string DescTag,
                                        std::string ImplTag,
                                        int i, StringRef funcName,
                                        unsigned hasCopy);
  Stmt *SynthesizeBlockCall(CallExpr *Exp, const Expr* BlockExp);
  void SynthesizeBlockLiterals(SourceLocation FunLocStart,
                               StringRef FunName);
  FunctionDecl *SynthBlockInitFunctionDecl(StringRef name);
  Stmt *SynthBlockInitExpr(BlockExpr *Exp,
          const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs);

  // Misc. helper routines.
  QualType getProtocolType();
  void WarnAboutReturnGotoStmts(Stmt *S);
  void HasReturnStmts(Stmt *S, bool &hasReturns);
  void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
  void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);
  void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD);

  bool IsDeclStmtInForeachHeader(DeclStmt *DS);
  void CollectBlockDeclRefInfo(BlockExpr *Exp);
  void GetBlockDeclRefExprs(Stmt *S);
  void GetInnerBlockDeclRefExprs(Stmt *S,
              SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs,
              llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts);

  // We avoid calling Type::isBlockPointerType(), since it operates on the
  // canonical type. We only care if the top-level type is a closure pointer.
  bool isTopLevelBlockPointerType(QualType T) {
    return isa<BlockPointerType>(T);
  }

  /// convertBlockPointerToFunctionPointer - Converts a block-pointer type
  /// to a function pointer type and upon success, returns true; false
  /// otherwise.
  bool convertBlockPointerToFunctionPointer(QualType &T) {
    if (isTopLevelBlockPointerType(T)) {
      const auto *BPT = T->castAs<BlockPointerType>();
      T = Context->getPointerType(BPT->getPointeeType());
      return true;
    }
    return false;
  }

  bool needToScanForQualifiers(QualType T);
  QualType getSuperStructType();
  QualType getConstantStringStructType();
  QualType convertFunctionTypeOfBlocks(const FunctionType *FT);
  bool BufferContainsPPDirectives(const char *startBuf, const char *endBuf);

  void convertToUnqualifiedObjCType(QualType &T) {
    if (T->isObjCQualifiedIdType())
      T = Context->getObjCIdType();
    else if (T->isObjCQualifiedClassType())
      T = Context->getObjCClassType();
    else if (T->isObjCObjectPointerType() &&
             T->getPointeeType()->isObjCQualifiedInterfaceType()) {
      if (const ObjCObjectPointerType * OBJPT =
            T->getAsObjCInterfacePointerType()) {
        const ObjCInterfaceType *IFaceT = OBJPT->getInterfaceType();
        T = QualType(IFaceT, 0);
        T = Context->getPointerType(T);
      }
   }
  }

  // FIXME: This predicate seems like it would be useful to add to ASTContext.
  bool isObjCType(QualType T) {
    if (!LangOpts.ObjC)
      return false;

    QualType OCT = Context->getCanonicalType(T).getUnqualifiedType();

    if (OCT == Context->getCanonicalType(Context->getObjCIdType()) ||
        OCT == Context->getCanonicalType(Context->getObjCClassType()))
      return true;

    if (const PointerType *PT = OCT->getAs<PointerType>()) {
      if (isa<ObjCInterfaceType>(PT->getPointeeType()) ||
          PT->getPointeeType()->isObjCQualifiedIdType())
        return true;
    }
    return false;
  }
  bool PointerTypeTakesAnyBlockArguments(QualType QT);
  bool PointerTypeTakesAnyObjCQualifiedType(QualType QT);
  void GetExtentOfArgList(const char *Name, const char *&LParen,
                          const char *&RParen);

  void QuoteDoublequotes(std::string &From, std::string &To) {
    for (unsigned i = 0; i < From.length(); i++) {
      if (From[i] == '"')
        To += "\\\"";
      else
        To += From[i];
    }
  }

  QualType getSimpleFunctionType(QualType result,
                                 ArrayRef<QualType> args,
                                 bool variadic = false) {
    if (result == Context->getObjCInstanceType())
      result =  Context->getObjCIdType();
    FunctionProtoType::ExtProtoInfo fpi;
    fpi.Variadic = variadic;
    return Context->getFunctionType(result, args, fpi);
  }

  // Helper function: create a CStyleCastExpr with trivial type source info.
  CStyleCastExpr* NoTypeInfoCStyleCastExpr(ASTContext *Ctx, QualType Ty,
                                           CastKind Kind, Expr *E) {
    TypeSourceInfo *TInfo = Ctx->getTrivialTypeSourceInfo(Ty, SourceLocation());
    return CStyleCastExpr::Create(*Ctx, Ty, VK_PRValue, Kind, E, nullptr,
                                  FPOptionsOverride(), TInfo,
                                  SourceLocation(), SourceLocation());
  }

  StringLiteral *getStringLiteral(StringRef Str) {
    QualType StrType = Context->getConstantArrayType(
        Context->CharTy, llvm::APInt(32, Str.size() + 1), nullptr,
        ArrayType::Normal, 0);
    return StringLiteral::Create(*Context, Str, StringLiteral::Ascii,
                                 /*Pascal=*/false, StrType, SourceLocation());
  }
};

class RewriteObjCFragileABI : public RewriteObjC {
public:
  RewriteObjCFragileABI(std::string inFile, std::unique_ptr<raw_ostream> OS,
                        DiagnosticsEngine &D, const LangOptions &LOpts,
                        bool silenceMacroWarn)
      : RewriteObjC(inFile, std::move(OS), D, LOpts, silenceMacroWarn) {}

  ~RewriteObjCFragileABI() override {}
  void Initialize(ASTContext &context) override;

  // Rewriting metadata
  template<typename MethodIterator>
  void RewriteObjCMethodsMetaData(MethodIterator MethodBegin,
                                  MethodIterator MethodEnd,
                                  bool IsInstanceMethod,
                                  StringRef prefix,
                                  StringRef ClassName,
                                  std::string &Result);
  void RewriteObjCProtocolMetaData(ObjCProtocolDecl *Protocol,
                                   StringRef prefix, StringRef ClassName,
                                   std::string &Result) override;
  void RewriteObjCProtocolListMetaData(
        const ObjCList<ObjCProtocolDecl> &Prots,
        StringRef prefix, StringRef ClassName, std::string &Result) override;
  void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
                                std::string &Result) override;
  void RewriteMetaDataIntoBuffer(std::string &Result) override;
  void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
                                   std::string &Result) override;

  // Rewriting ivar
  void RewriteIvarOffsetComputation(ObjCIvarDecl *ivar,
                                    std::string &Result) override;
  Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) override;
};
543} // end anonymous namespace

545void RewriteObjC::RewriteBlocksInFunctionProtoType(QualType funcType,
                                                 NamedDecl *D) {
if (const FunctionProtoType *fproto
    = dyn_cast<FunctionProtoType>(funcType.IgnoreParens())) {
  for (const auto &I : fproto->param_types())
    if (isTopLevelBlockPointerType(I)) {
      // All the args are checked/rewritten. Don't call twice!
      RewriteBlockPointerDecl(D);
      break;
    }
}
556}

558void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
const PointerType *PT = funcType->getAs<PointerType>();
if (PT && PointerTypeTakesAnyBlockArguments(funcType))
  RewriteBlocksInFunctionProtoType(PT->getPointeeType(), ND);
562}

564static bool IsHeaderFile(const std::string &Filename) {
std::string::size_type DotPos = Filename.rfind('.');

if (DotPos == std::string::npos) {
  // no file extension
  return false;
}

std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end());
// C header: .h
// C++ header: .hh or .H;
return Ext == "h" || Ext == "hh" || Ext == "H";
576}

578RewriteObjC::RewriteObjC(std::string inFile, std::unique_ptr<raw_ostream> OS,
                       DiagnosticsEngine &D, const LangOptions &LOpts,
                       bool silenceMacroWarn)
  : Diags(D), LangOpts(LOpts), InFileName(inFile), OutFile(std::move(OS)),
    SilenceRewriteMacroWarning(silenceMacroWarn) {
IsHeader = IsHeaderFile(inFile);
RewriteFailedDiag = Diags.getCustomDiagID(DiagnosticsEngine::Warning,
             "rewriting sub-expression within a macro (may not be correct)");
TryFinallyContainsReturnDiag = Diags.getCustomDiagID(
             DiagnosticsEngine::Warning,
             "rewriter doesn't support user-specified control flow semantics "
             "for @try/@finally (code may not execute properly)");
590}

592std::unique_ptr<ASTConsumer>
593clang::CreateObjCRewriter(const std::string &InFile,
                        std::unique_ptr<raw_ostream> OS,
                        DiagnosticsEngine &Diags, const LangOptions &LOpts,
                        bool SilenceRewriteMacroWarning) {
return std::make_unique<RewriteObjCFragileABI>(
    InFile, std::move(OS), Diags, LOpts, SilenceRewriteMacroWarning);
599}

601void RewriteObjC::InitializeCommon(ASTContext &context) {
Context = &context;
SM = &Context->getSourceManager();
TUDecl = Context->getTranslationUnitDecl();
MsgSendFunctionDecl = nullptr;
MsgSendSuperFunctionDecl = nullptr;
MsgSendStretFunctionDecl = nullptr;
MsgSendSuperStretFunctionDecl = nullptr;
MsgSendFpretFunctionDecl = nullptr;
GetClassFunctionDecl = nullptr;
GetMetaClassFunctionDecl = nullptr;
GetSuperClassFunctionDecl = nullptr;
SelGetUidFunctionDecl = nullptr;
CFStringFunctionDecl = nullptr;
ConstantStringClassReference = nullptr;
NSStringRecord = nullptr;
CurMethodDef = nullptr;
CurFunctionDef = nullptr;
CurFunctionDeclToDeclareForBlock = nullptr;
GlobalVarDecl = nullptr;
SuperStructDecl = nullptr;
ProtocolTypeDecl = nullptr;
ConstantStringDecl = nullptr;
BcLabelCount = 0;
SuperConstructorFunctionDecl = nullptr;
NumObjCStringLiterals = 0;
PropParentMap = nullptr;
CurrentBody = nullptr;
DisableReplaceStmt = false;
objc_impl_method = false;

// Get the ID and start/end of the main file.
MainFileID = SM->getMainFileID();
llvm::MemoryBufferRef MainBuf = SM->getBufferOrFake(MainFileID);
MainFileStart = MainBuf.getBufferStart();
MainFileEnd = MainBuf.getBufferEnd();

Rewrite.setSourceMgr(Context->getSourceManager(), Context->getLangOpts());
639}

641//===----------------------------------------------------------------------===//
642// Top Level Driver Code
643//===----------------------------------------------------------------------===//

645void RewriteObjC::HandleTopLevelSingleDecl(Decl *D) {
if (Diags.hasErrorOccurred())
  return;

// Two cases: either the decl could be in the main file, or it could be in a
// #included file.  If the former, rewrite it now.  If the later, check to see
// if we rewrote the #include/#import.
SourceLocation Loc = D->getLocation();
Loc = SM->getExpansionLoc(Loc);

// If this is for a builtin, ignore it.
if (Loc.isInvalid()) return;

// Look for built-in declarations that we need to refer during the rewrite.
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
  RewriteFunctionDecl(FD);
} else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) {
  // declared in <Foundation/NSString.h>
  if (FVD->getName() == "_NSConstantStringClassReference") {
    ConstantStringClassReference = FVD;
    return;
  }
} else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
  if (ID->isThisDeclarationADefinition())
    RewriteInterfaceDecl(ID);
} else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
  RewriteCategoryDecl(CD);
} else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
  if (PD->isThisDeclarationADefinition())
    RewriteProtocolDecl(PD);
} else if (LinkageSpecDecl *LSD = dyn_cast<LinkageSpecDecl>(D)) {
  // Recurse into linkage specifications
  for (DeclContext::decl_iterator DI = LSD->decls_begin(),
                               DIEnd = LSD->decls_end();
       DI != DIEnd; ) {
    if (ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>((*DI))) {
      if (!IFace->isThisDeclarationADefinition()) {
        SmallVector<Decl *, 8> DG;
        SourceLocation StartLoc = IFace->getBeginLoc();
        do {
          if (isa<ObjCInterfaceDecl>(*DI) &&
              !cast<ObjCInterfaceDecl>(*DI)->isThisDeclarationADefinition() &&
              StartLoc == (*DI)->getBeginLoc())
            DG.push_back(*DI);
          else
            break;

          ++DI;
        } while (DI != DIEnd);
        RewriteForwardClassDecl(DG);
        continue;
      }
    }

    if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>((*DI))) {
      if (!Proto->isThisDeclarationADefinition()) {
        SmallVector<Decl *, 8> DG;
        SourceLocation StartLoc = Proto->getBeginLoc();
        do {
          if (isa<ObjCProtocolDecl>(*DI) &&
              !cast<ObjCProtocolDecl>(*DI)->isThisDeclarationADefinition() &&
              StartLoc == (*DI)->getBeginLoc())
            DG.push_back(*DI);
          else
            break;

          ++DI;
        } while (DI != DIEnd);
        RewriteForwardProtocolDecl(DG);
        continue;
      }
    }

    HandleTopLevelSingleDecl(*DI);
    ++DI;
  }
}
// If we have a decl in the main file, see if we should rewrite it.
if (SM->isWrittenInMainFile(Loc))
  return HandleDeclInMainFile(D);
725}

727//===----------------------------------------------------------------------===//
728// Syntactic (non-AST) Rewriting Code
729//===----------------------------------------------------------------------===//

731void RewriteObjC::RewriteInclude() {
SourceLocation LocStart = SM->getLocForStartOfFile(MainFileID);
StringRef MainBuf = SM->getBufferData(MainFileID);
const char *MainBufStart = MainBuf.begin();
const char *MainBufEnd = MainBuf.end();
size_t ImportLen = strlen("import");

// Loop over the whole file, looking for includes.
for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr) {
  if (*BufPtr == '#') {
    if (++BufPtr == MainBufEnd)
      return;
    while (*BufPtr == ' ' || *BufPtr == '\t')
      if (++BufPtr == MainBufEnd)
        return;
    if (!strncmp(BufPtr, "import", ImportLen)) {
      // replace import with include
      SourceLocation ImportLoc =
        LocStart.getLocWithOffset(BufPtr-MainBufStart);
      ReplaceText(ImportLoc, ImportLen, "include");
      BufPtr += ImportLen;
    }
  }
}
755}

757static std::string getIvarAccessString(ObjCIvarDecl *OID) {
const ObjCInterfaceDecl *ClassDecl = OID->getContainingInterface();
std::string S;
S = "((struct ";
S += ClassDecl->getIdentifier()->getName();
S += "_IMPL *)self)->";
S += OID->getName();
return S;
765}

767void RewriteObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
                                        ObjCImplementationDecl *IMD,
                                        ObjCCategoryImplDecl *CID) {
static bool objcGetPropertyDefined = false;
static bool objcSetPropertyDefined = false;
SourceLocation startLoc = PID->getBeginLoc();
InsertText(startLoc, "// ");
const char *startBuf = SM->getCharacterData(startLoc);
assert((*startBuf == '@') && "bogus @synthesize location")(static_cast<void> (0));
const char *semiBuf = strchr(startBuf, ';');
assert((*semiBuf == ';') && "@synthesize: can't find ';'")(static_cast<void> (0));
SourceLocation onePastSemiLoc =
  startLoc.getLocWithOffset(semiBuf-startBuf+1);

if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
  return; // FIXME: is this correct?

// Generate the 'getter' function.
ObjCPropertyDecl *PD = PID->getPropertyDecl();
ObjCIvarDecl *OID = PID->getPropertyIvarDecl();

if (!OID)
  return;

unsigned Attributes = PD->getPropertyAttributes();
if (PID->getGetterMethodDecl() && !PID->getGetterMethodDecl()->isDefined()) {
  bool GenGetProperty =
      !(Attributes & ObjCPropertyAttribute::kind_nonatomic) &&
      (Attributes & (ObjCPropertyAttribute::kind_retain |
                     ObjCPropertyAttribute::kind_copy));
  std::string Getr;
  if (GenGetProperty && !objcGetPropertyDefined) {
    objcGetPropertyDefined = true;
    // FIXME. Is this attribute correct in all cases?
    Getr = "\nextern \"C\" __declspec(dllimport) "
          "id objc_getProperty(id, SEL, long, bool);\n";
  }
  RewriteObjCMethodDecl(OID->getContainingInterface(),
                        PID->getGetterMethodDecl(), Getr);
  Getr += "{ ";
  // Synthesize an explicit cast to gain access to the ivar.
  // See objc-act.c:objc_synthesize_new_getter() for details.
  if (GenGetProperty) {
    // return objc_getProperty(self, _cmd, offsetof(ClassDecl, OID), 1)
    Getr += "typedef ";
    const FunctionType *FPRetType = nullptr;
    RewriteTypeIntoString(PID->getGetterMethodDecl()->getReturnType(), Getr,
                          FPRetType);
    Getr += " _TYPE";
    if (FPRetType) {
      Getr += ")"; // close the precedence "scope" for "*".

      // Now, emit the argument types (if any).
      if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)){
        Getr += "(";
        for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
          if (i) Getr += ", ";
          std::string ParamStr =
              FT->getParamType(i).getAsString(Context->getPrintingPolicy());
          Getr += ParamStr;
        }
        if (FT->isVariadic()) {
          if (FT->getNumParams())
            Getr += ", ";
          Getr += "...";
        }
        Getr += ")";
      } else
        Getr += "()";
    }
    Getr += ";\n";
    Getr += "return (_TYPE)";
    Getr += "objc_getProperty(self, _cmd, ";
    RewriteIvarOffsetComputation(OID, Getr);
    Getr += ", 1)";
  }
  else
    Getr += "return " + getIvarAccessString(OID);
  Getr += "; }";
  InsertText(onePastSemiLoc, Getr);
}

if (PD->isReadOnly() || !PID->getSetterMethodDecl() ||
    PID->getSetterMethodDecl()->isDefined())
  return;

// Generate the 'setter' function.
std::string Setr;
bool GenSetProperty = Attributes & (ObjCPropertyAttribute::kind_retain |
                                    ObjCPropertyAttribute::kind_copy);
if (GenSetProperty && !objcSetPropertyDefined) {
  objcSetPropertyDefined = true;
  // FIXME. Is this attribute correct in all cases?
  Setr = "\nextern \"C\" __declspec(dllimport) "
  "void objc_setProperty (id, SEL, long, id, bool, bool);\n";
}

RewriteObjCMethodDecl(OID->getContainingInterface(),
                      PID->getSetterMethodDecl(), Setr);
Setr += "{ ";
// Synthesize an explicit cast to initialize the ivar.
// See objc-act.c:objc_synthesize_new_setter() for details.
if (GenSetProperty) {
  Setr += "objc_setProperty (self, _cmd, ";
  RewriteIvarOffsetComputation(OID, Setr);
  Setr += ", (id)";
  Setr += PD->getName();
  Setr += ", ";
  if (Attributes & ObjCPropertyAttribute::kind_nonatomic)
    Setr += "0, ";
  else
    Setr += "1, ";
  if (Attributes & ObjCPropertyAttribute::kind_copy)
    Setr += "1)";
  else
    Setr += "0)";
}
else {
  Setr += getIvarAccessString(OID) + " = ";
  Setr += PD->getName();
}
Setr += "; }";
InsertText(onePastSemiLoc, Setr);
890}

892static void RewriteOneForwardClassDecl(ObjCInterfaceDecl *ForwardDecl,
                                     std::string &typedefString) {
typedefString += "#ifndef _REWRITER_typedef_";
typedefString += ForwardDecl->getNameAsString();
typedefString += "\n";
typedefString += "#define _REWRITER_typedef_";
typedefString += ForwardDecl->getNameAsString();
typedefString += "\n";
typedefString += "typedef struct objc_object ";
typedefString += ForwardDecl->getNameAsString();
typedefString += ";\n#endif\n";
903}

905void RewriteObjC::RewriteForwardClassEpilogue(ObjCInterfaceDecl *ClassDecl,
                                            const std::string &typedefString) {
SourceLocation startLoc = ClassDecl->getBeginLoc();
const char *startBuf = SM->getCharacterData(startLoc);
const char *semiPtr = strchr(startBuf, ';');
// Replace the @class with typedefs corresponding to the classes.
ReplaceText(startLoc, semiPtr - startBuf + 1, typedefString);
912}

914void RewriteObjC::RewriteForwardClassDecl(DeclGroupRef D) {
std::string typedefString;
for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I) {
  ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(*I);
  if (I == D.begin()) {
    // Translate to typedef's that forward reference structs with the same name
    // as the class. As a convenience, we include the original declaration
    // as a comment.
    typedefString += "// @class ";
    typedefString += ForwardDecl->getNameAsString();
    typedefString += ";\n";
  }
  RewriteOneForwardClassDecl(ForwardDecl, typedefString);
}
DeclGroupRef::iterator I = D.begin();
RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(*I), typedefString);
930}

932void RewriteObjC::RewriteForwardClassDecl(const SmallVectorImpl<Decl *> &D) {
std::string typedefString;
for (unsigned i = 0; i < D.size(); i++) {
  ObjCInterfaceDecl *ForwardDecl = cast<ObjCInterfaceDecl>(D[i]);
  if (i == 0) {
    typedefString += "// @class ";
    typedefString += ForwardDecl->getNameAsString();
    typedefString += ";\n";
  }
  RewriteOneForwardClassDecl(ForwardDecl, typedefString);
}
RewriteForwardClassEpilogue(cast<ObjCInterfaceDecl>(D[0]), typedefString);
944}

946void RewriteObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) {
// When method is a synthesized one, such as a getter/setter there is
// nothing to rewrite.
if (Method->isImplicit())
  return;
SourceLocation LocStart = Method->getBeginLoc();
SourceLocation LocEnd = Method->getEndLoc();

if (SM->getExpansionLineNumber(LocEnd) >
    SM->getExpansionLineNumber(LocStart)) {
  InsertText(LocStart, "#if 0\n");
  ReplaceText(LocEnd, 1, ";\n#endif\n");
} else {
  InsertText(LocStart, "// ");
}
961}

963void RewriteObjC::RewriteProperty(ObjCPropertyDecl *prop) {
SourceLocation Loc = prop->getAtLoc();

ReplaceText(Loc, 0, "// ");
// FIXME: handle properties that are declared across multiple lines.
968}

970void RewriteObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) {
SourceLocation LocStart = CatDecl->getBeginLoc();

// FIXME: handle category headers that are declared across multiple lines.
ReplaceText(LocStart, 0, "// ");

for (auto *I : CatDecl->instance_properties())
  RewriteProperty(I);
for (auto *I : CatDecl->instance_methods())
  RewriteMethodDeclaration(I);
for (auto *I : CatDecl->class_methods())
  RewriteMethodDeclaration(I);

// Lastly, comment out the @end.
ReplaceText(CatDecl->getAtEndRange().getBegin(),
            strlen("@end"), "/* @end */");
986}

988void RewriteObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) {
SourceLocation LocStart = PDecl->getBeginLoc();
assert(PDecl->isThisDeclarationADefinition())(static_cast<void> (0));

// FIXME: handle protocol headers that are declared across multiple lines.
ReplaceText(LocStart, 0, "// ");

for (auto *I : PDecl->instance_methods())
  RewriteMethodDeclaration(I);
for (auto *I : PDecl->class_methods())
  RewriteMethodDeclaration(I);
for (auto *I : PDecl->instance_properties())
  RewriteProperty(I);

// Lastly, comment out the @end.
SourceLocation LocEnd = PDecl->getAtEndRange().getBegin();
ReplaceText(LocEnd, strlen("@end"), "/* @end */");

// Must comment out @optional/@required
const char *startBuf = SM->getCharacterData(LocStart);
const char *endBuf = SM->getCharacterData(LocEnd);
for (const char *p = startBuf; p < endBuf; p++) {
  if (*p == '@' && !strncmp(p+1, "optional", strlen("optional"))) {
    SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf);
    ReplaceText(OptionalLoc, strlen("@optional"), "/* @optional */");

  }
  else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))) {
    SourceLocation OptionalLoc = LocStart.getLocWithOffset(p-startBuf);
    ReplaceText(OptionalLoc, strlen("@required"), "/* @required */");

  }
}
1021}

1023void RewriteObjC::RewriteForwardProtocolDecl(DeclGroupRef D) {
SourceLocation LocStart = (*D.begin())->getBeginLoc();
if (LocStart.isInvalid())
  llvm_unreachable("Invalid SourceLocation")__builtin_unreachable();
// FIXME: handle forward protocol that are declared across multiple lines.
ReplaceText(LocStart, 0, "// ");
1029}

1031void
1032RewriteObjC::RewriteForwardProtocolDecl(const SmallVectorImpl<Decl *> &DG) {
SourceLocation LocStart = DG[0]->getBeginLoc();
if (LocStart.isInvalid())
  llvm_unreachable("Invalid SourceLocation")__builtin_unreachable();
// FIXME: handle forward protocol that are declared across multiple lines.
ReplaceText(LocStart, 0, "// ");
1038}

1040void RewriteObjC::RewriteTypeIntoString(QualType T, std::string &ResultStr,
                                      const FunctionType *&FPRetType) {
if (T->isObjCQualifiedIdType())
  ResultStr += "id";
else if (T->isFunctionPointerType() ||
         T->isBlockPointerType()) {
  // needs special handling, since pointer-to-functions have special
  // syntax (where a decaration models use).
  QualType retType = T;
  QualType PointeeTy;
  if (const PointerType* PT = retType->getAs<PointerType>())
    PointeeTy = PT->getPointeeType();
  else if (const BlockPointerType *BPT = retType->getAs<BlockPointerType>())
    PointeeTy = BPT->getPointeeType();
  if ((FPRetType = PointeeTy->getAs<FunctionType>())) {
    ResultStr +=
        FPRetType->getReturnType().getAsString(Context->getPrintingPolicy());
    ResultStr += "(*";
  }
} else
  ResultStr += T.getAsString(Context->getPrintingPolicy());
1061}

1063void RewriteObjC::RewriteObjCMethodDecl(const ObjCInterfaceDecl *IDecl,
                                      ObjCMethodDecl *OMD,
                                      std::string &ResultStr) {
//fprintf(stderr,"In RewriteObjCMethodDecl\n");
const FunctionType *FPRetType = nullptr;
ResultStr += "\nstatic ";
RewriteTypeIntoString(OMD->getReturnType(), ResultStr, FPRetType);
ResultStr += " ";

// Unique method name
std::string NameStr;

if (OMD->isInstanceMethod())
  NameStr += "_I_";
else
  NameStr += "_C_";

NameStr += IDecl->getNameAsString();
NameStr += "_";

if (ObjCCategoryImplDecl *CID =
    dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext())) {
  NameStr += CID->getNameAsString();
  NameStr += "_";
}
// Append selector names, replacing ':' with '_'
{
  std::string selString = OMD->getSelector().getAsString();
  int len = selString.size();
  for (int i = 0; i < len; i++)
    if (selString[i] == ':')
      selString[i] = '_';
  NameStr += selString;
}
// Remember this name for metadata emission
MethodInternalNames[OMD] = NameStr;
ResultStr += NameStr;

// Rewrite arguments
ResultStr += "(";

// invisible arguments
if (OMD->isInstanceMethod()) {
  QualType selfTy = Context->getObjCInterfaceType(IDecl);
  selfTy = Context->getPointerType(selfTy);
  if (!LangOpts.MicrosoftExt) {
    if (ObjCSynthesizedStructs.count(const_cast<ObjCInterfaceDecl*>(IDecl)))
      ResultStr += "struct ";
  }
  // When rewriting for Microsoft, explicitly omit the structure name.
  ResultStr += IDecl->getNameAsString();
  ResultStr += " *";
}
else
  ResultStr += Context->getObjCClassType().getAsString(
    Context->getPrintingPolicy());

ResultStr += " self, ";
ResultStr += Context->getObjCSelType().getAsString(Context->getPrintingPolicy());
ResultStr += " _cmd";

// Method arguments.
for (const auto *PDecl : OMD->parameters()) {
  ResultStr += ", ";
  if (PDecl->getType()->isObjCQualifiedIdType()) {
    ResultStr += "id ";
    ResultStr += PDecl->getNameAsString();
  } else {
    std::string Name = PDecl->getNameAsString();
    QualType QT = PDecl->getType();
    // Make sure we convert "t (^)(...)" to "t (*)(...)".
    (void)convertBlockPointerToFunctionPointer(QT);
    QT.getAsStringInternal(Name, Context->getPrintingPolicy());
    ResultStr += Name;
  }
}
if (OMD->isVariadic())
  ResultStr += ", ...";
ResultStr += ") ";

if (FPRetType) {
  ResultStr += ")"; // close the precedence "scope" for "*".

  // Now, emit the argument types (if any).
  if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(FPRetType)) {
    ResultStr += "(";
    for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
      if (i) ResultStr += ", ";
      std::string ParamStr =
          FT->getParamType(i).getAsString(Context->getPrintingPolicy());
      ResultStr += ParamStr;
    }
    if (FT->isVariadic()) {
      if (FT->getNumParams())
        ResultStr += ", ";
      ResultStr += "...";
    }
    ResultStr += ")";
  } else {
    ResultStr += "()";
  }
}
1165}

1167void RewriteObjC::RewriteImplementationDecl(Decl *OID) {
ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID);
ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID);
assert((IMD || CID) && "Unknown ImplementationDecl")(static_cast<void> (0));

InsertText(IMD ? IMD->getBeginLoc() : CID->getBeginLoc(), "// ");

for (auto *OMD : IMD ? IMD->instance_methods() : CID->instance_methods()) {
  if (!OMD->getBody())
    continue;
  std::string ResultStr;
  RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr);
  SourceLocation LocStart = OMD->getBeginLoc();
  SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc();

  const char *startBuf = SM->getCharacterData(LocStart);
  const char *endBuf = SM->getCharacterData(LocEnd);
  ReplaceText(LocStart, endBuf-startBuf, ResultStr);
}

for (auto *OMD : IMD ? IMD->class_methods() : CID->class_methods()) {
  if (!OMD->getBody())
    continue;
  std::string ResultStr;
  RewriteObjCMethodDecl(OMD->getClassInterface(), OMD, ResultStr);
  SourceLocation LocStart = OMD->getBeginLoc();
  SourceLocation LocEnd = OMD->getCompoundBody()->getBeginLoc();

  const char *startBuf = SM->getCharacterData(LocStart);
  const char *endBuf = SM->getCharacterData(LocEnd);
  ReplaceText(LocStart, endBuf-startBuf, ResultStr);
}
for (auto *I : IMD ? IMD->property_impls() : CID->property_impls())
  RewritePropertyImplDecl(I, IMD, CID);

InsertText(IMD ? IMD->getEndLoc() : CID->getEndLoc(), "// ");
1203}

1205void RewriteObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) {
std::string ResultStr;
if (!ObjCForwardDecls.count(ClassDecl->getCanonicalDecl())) {
  // we haven't seen a forward decl - generate a typedef.
  ResultStr = "#ifndef _REWRITER_typedef_";
  ResultStr += ClassDecl->getNameAsString();
  ResultStr += "\n";
  ResultStr += "#define _REWRITER_typedef_";
  ResultStr += ClassDecl->getNameAsString();
  ResultStr += "\n";
  ResultStr += "typedef struct objc_object ";
  ResultStr += ClassDecl->getNameAsString();
  ResultStr += ";\n#endif\n";
  // Mark this typedef as having been generated.
  ObjCForwardDecls.insert(ClassDecl->getCanonicalDecl());
}
RewriteObjCInternalStruct(ClassDecl, ResultStr);

for (auto *I : ClassDecl->instance_properties())
  RewriteProperty(I);
for (auto *I : ClassDecl->instance_methods())
  RewriteMethodDeclaration(I);
for (auto *I : ClassDecl->class_methods())
  RewriteMethodDeclaration(I);

// Lastly, comment out the @end.
ReplaceText(ClassDecl->getAtEndRange().getBegin(), strlen("@end"),
            "/* @end */");
1233}

1235Stmt *RewriteObjC::RewritePropertyOrImplicitSetter(PseudoObjectExpr *PseudoOp) {
SourceRange OldRange = PseudoOp->getSourceRange();

// We just magically know some things about the structure of this
// expression.
ObjCMessageExpr *OldMsg =
  cast<ObjCMessageExpr>(PseudoOp->getSemanticExpr(
                          PseudoOp->getNumSemanticExprs() - 1));

// Because the rewriter doesn't allow us to rewrite rewritten code,
// we need to suppress rewriting the sub-statements.
Expr *Base, *RHS;
{
  DisableReplaceStmtScope S(*this);

  // Rebuild the base expression if we have one.
  Base = nullptr;
  if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) {
    Base = OldMsg->getInstanceReceiver();
    Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
    Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
  }

  // Rebuild the RHS.
  RHS = cast<BinaryOperator>(PseudoOp->getSyntacticForm())->getRHS();
  RHS = cast<OpaqueValueExpr>(RHS)->getSourceExpr();
  RHS = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(RHS));
}

// TODO: avoid this copy.
SmallVector<SourceLocation, 1> SelLocs;
OldMsg->getSelectorLocs(SelLocs);

ObjCMessageExpr *NewMsg = nullptr;
switch (OldMsg->getReceiverKind()) {
case ObjCMessageExpr::Class:
  NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
                                   OldMsg->getValueKind(),
                                   OldMsg->getLeftLoc(),
                                   OldMsg->getClassReceiverTypeInfo(),
                                   OldMsg->getSelector(),
                                   SelLocs,
                                   OldMsg->getMethodDecl(),
                                   RHS,
                                   OldMsg->getRightLoc(),
                                   OldMsg->isImplicit());
  break;

case ObjCMessageExpr::Instance:
  NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
                                   OldMsg->getValueKind(),
                                   OldMsg->getLeftLoc(),
                                   Base,
                                   OldMsg->getSelector(),
                                   SelLocs,
                                   OldMsg->getMethodDecl(),
                                   RHS,
                                   OldMsg->getRightLoc(),
                                   OldMsg->isImplicit());
  break;

case ObjCMessageExpr::SuperClass:
case ObjCMessageExpr::SuperInstance:
  NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
                                   OldMsg->getValueKind(),
                                   OldMsg->getLeftLoc(),
                                   OldMsg->getSuperLoc(),
               OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance,
                                   OldMsg->getSuperType(),
                                   OldMsg->getSelector(),
                                   SelLocs,
                                   OldMsg->getMethodDecl(),
                                   RHS,
                                   OldMsg->getRightLoc(),
                                   OldMsg->isImplicit());
  break;
}

Stmt *Replacement = SynthMessageExpr(NewMsg);
ReplaceStmtWithRange(PseudoOp, Replacement, OldRange);
return Replacement;
1316}

1318Stmt *RewriteObjC::RewritePropertyOrImplicitGetter(PseudoObjectExpr *PseudoOp) {
SourceRange OldRange = PseudoOp->getSourceRange();

// We just magically know some things about the structure of this
// expression.
ObjCMessageExpr *OldMsg =
  cast<ObjCMessageExpr>(PseudoOp->getResultExpr()->IgnoreImplicit());

// Because the rewriter doesn't allow us to rewrite rewritten code,
// we need to suppress rewriting the sub-statements.
Expr *Base = nullptr;
{
  DisableReplaceStmtScope S(*this);

  // Rebuild the base expression if we have one.
  if (OldMsg->getReceiverKind() == ObjCMessageExpr::Instance) {
    Base = OldMsg->getInstanceReceiver();
    Base = cast<OpaqueValueExpr>(Base)->getSourceExpr();
    Base = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(Base));
  }
}

// Intentionally empty.
SmallVector<SourceLocation, 1> SelLocs;
SmallVector<Expr*, 1> Args;

ObjCMessageExpr *NewMsg = nullptr;
switch (OldMsg->getReceiverKind()) {
case ObjCMessageExpr::Class:
  NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
                                   OldMsg->getValueKind(),
                                   OldMsg->getLeftLoc(),
                                   OldMsg->getClassReceiverTypeInfo(),
                                   OldMsg->getSelector(),
                                   SelLocs,
                                   OldMsg->getMethodDecl(),
                                   Args,
                                   OldMsg->getRightLoc(),
                                   OldMsg->isImplicit());
  break;

case ObjCMessageExpr::Instance:
  NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
                                   OldMsg->getValueKind(),
                                   OldMsg->getLeftLoc(),
                                   Base,
                                   OldMsg->getSelector(),
                                   SelLocs,
                                   OldMsg->getMethodDecl(),
                                   Args,
                                   OldMsg->getRightLoc(),
                                   OldMsg->isImplicit());
  break;

case ObjCMessageExpr::SuperClass:
case ObjCMessageExpr::SuperInstance:
  NewMsg = ObjCMessageExpr::Create(*Context, OldMsg->getType(),
                                   OldMsg->getValueKind(),
                                   OldMsg->getLeftLoc(),
                                   OldMsg->getSuperLoc(),
               OldMsg->getReceiverKind() == ObjCMessageExpr::SuperInstance,
                                   OldMsg->getSuperType(),
                                   OldMsg->getSelector(),
                                   SelLocs,
                                   OldMsg->getMethodDecl(),
                                   Args,
                                   OldMsg->getRightLoc(),
                                   OldMsg->isImplicit());
  break;
}

Stmt *Replacement = SynthMessageExpr(NewMsg);
ReplaceStmtWithRange(PseudoOp, Replacement, OldRange);
return Replacement;
1392}

1394/// SynthCountByEnumWithState - To print:
1395/// ((unsigned int (*)
1396///  (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
1397///  (void *)objc_msgSend)((id)l_collection,
1398///                        sel_registerName(
1399///                          "countByEnumeratingWithState:objects:count:"),
1400///                        &enumState,
1401///                        (id *)__rw_items, (unsigned int)16)
1402///
1403void RewriteObjC::SynthCountByEnumWithState(std::string &buf) {
buf += "((unsigned int (*) (id, SEL, struct __objcFastEnumerationState *, "
"id *, unsigned int))(void *)objc_msgSend)";
buf += "\n\t\t";
buf += "((id)l_collection,\n\t\t";
buf += "sel_registerName(\"countByEnumeratingWithState:objects:count:\"),";
buf += "\n\t\t";
buf += "&enumState, "
       "(id *)__rw_items, (unsigned int)16)";
1412}

1414/// RewriteBreakStmt - Rewrite for a break-stmt inside an ObjC2's foreach
1415/// statement to exit to its outer synthesized loop.
1416///
1417Stmt *RewriteObjC::RewriteBreakStmt(BreakStmt *S) {
if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
  return S;
// replace break with goto __break_label
std::string buf;

SourceLocation startLoc = S->getBeginLoc();
buf = "goto __break_label_";
buf += utostr(ObjCBcLabelNo.back());
ReplaceText(startLoc, strlen("break"), buf);

return nullptr;
1429}

1431/// RewriteContinueStmt - Rewrite for a continue-stmt inside an ObjC2's foreach
1432/// statement to continue with its inner synthesized loop.
1433///
1434Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) {
if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
  return S;
// replace continue with goto __continue_label
std::string buf;

SourceLocation startLoc = S->getBeginLoc();
buf = "goto __continue_label_";
buf += utostr(ObjCBcLabelNo.back());
ReplaceText(startLoc, strlen("continue"), buf);

return nullptr;
1446}

1448/// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement.
1449///  It rewrites:
1450/// for ( type elem in collection) { stmts; }

1452/// Into:
1453/// {
1454///   type elem;
1455///   struct __objcFastEnumerationState enumState = { 0 };
1456///   id __rw_items[16];
1457///   id l_collection = (id)collection;
1458///   unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1459///                                       objects:__rw_items count:16];
1460/// if (limit) {
1461///   unsigned long startMutations = *enumState.mutationsPtr;
1462///   do {
1463///        unsigned long counter = 0;
1464///        do {
1465///             if (startMutations != *enumState.mutationsPtr)
1466///               objc_enumerationMutation(l_collection);
1467///             elem = (type)enumState.itemsPtr[counter++];
1468///             stmts;
1469///             __continue_label: ;
1470///        } while (counter < limit);
1471///   } while (limit = [l_collection countByEnumeratingWithState:&enumState
1472///                                  objects:__rw_items count:16]);
1473///   elem = nil;
1474///   __break_label: ;
1475///  }
1476///  else
1477///       elem = nil;
1478///  }
1479///
1480Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
                                              SourceLocation OrigEnd) {
assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty")(static_cast<void> (0));
assert(isa<ObjCForCollectionStmt>(Stmts.back()) &&(static_cast<void> (0))
       "ObjCForCollectionStmt Statement stack mismatch")(static_cast<void> (0));
assert(!ObjCBcLabelNo.empty() &&(static_cast<void> (0))
       "ObjCForCollectionStmt - Label No stack empty")(static_cast<void> (0));

SourceLocation startLoc = S->getBeginLoc();
const char *startBuf = SM->getCharacterData(startLoc);
StringRef elementName;
std::string elementTypeAsString;
std::string buf;
buf = "\n{\n\t";
if (DeclStmt *DS = dyn_cast<DeclStmt>(S->getElement())) {
  // type elem;
  NamedDecl* D = cast<NamedDecl>(DS->getSingleDecl());
  QualType ElementType = cast<ValueDecl>(D)->getType();
  if (ElementType->isObjCQualifiedIdType() ||
      ElementType->isObjCQualifiedInterfaceType())
    // Simply use 'id' for all qualified types.
    elementTypeAsString = "id";
  else
    elementTypeAsString = ElementType.getAsString(Context->getPrintingPolicy());
  buf += elementTypeAsString;
  buf += " ";
  elementName = D->getName();
  buf += elementName;
  buf += ";\n\t";
}
else {
  DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
  elementName = DR->getDecl()->getName();
  ValueDecl *VD = DR->getDecl();
  if (VD->getType()->isObjCQualifiedIdType() ||
      VD->getType()->isObjCQualifiedInterfaceType())
    // Simply use 'id' for all qualified types.
    elementTypeAsString = "id";
  else
    elementTypeAsString = VD->getType().getAsString(Context->getPrintingPolicy());
}

// struct __objcFastEnumerationState enumState = { 0 };
buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t";
// id __rw_items[16];
buf += "id __rw_items[16];\n\t";
// id l_collection = (id)
buf += "id l_collection = (id)";
// Find start location of 'collection' the hard way!
const char *startCollectionBuf = startBuf;
startCollectionBuf += 3;  // skip 'for'
startCollectionBuf = strchr(startCollectionBuf, '(');
startCollectionBuf++; // skip '('
// find 'in' and skip it.
while (*startCollectionBuf != ' ' ||
       *(startCollectionBuf+1) != 'i' || *(startCollectionBuf+2) != 'n' ||
       (*(startCollectionBuf+3) != ' ' &&
        *(startCollectionBuf+3) != '[' && *(startCollectionBuf+3) != '('))
  startCollectionBuf++;
startCollectionBuf += 3;

// Replace: "for (type element in" with string constructed thus far.
ReplaceText(startLoc, startCollectionBuf - startBuf, buf);
// Replace ')' in for '(' type elem in collection ')' with ';'
SourceLocation rightParenLoc = S->getRParenLoc();
const char *rparenBuf = SM->getCharacterData(rightParenLoc);
SourceLocation lparenLoc = startLoc.getLocWithOffset(rparenBuf-startBuf);
buf = ";\n\t";

// unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
//                                   objects:__rw_items count:16];
// which is synthesized into:
// unsigned int limit =
// ((unsigned int (*)
//  (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
//  (void *)objc_msgSend)((id)l_collection,
//                        sel_registerName(
//                          "countByEnumeratingWithState:objects:count:"),
//                        (struct __objcFastEnumerationState *)&state,
//                        (id *)__rw_items, (unsigned int)16);
buf += "unsigned long limit =\n\t\t";
SynthCountByEnumWithState(buf);
buf += ";\n\t";
/// if (limit) {
///   unsigned long startMutations = *enumState.mutationsPtr;
///   do {
///        unsigned long counter = 0;
///        do {
///             if (startMutations != *enumState.mutationsPtr)
///               objc_enumerationMutation(l_collection);
///             elem = (type)enumState.itemsPtr[counter++];
buf += "if (limit) {\n\t";
buf += "unsigned long startMutations = *enumState.mutationsPtr;\n\t";
buf += "do {\n\t\t";
buf += "unsigned long counter = 0;\n\t\t";
buf += "do {\n\t\t\t";
buf += "if (startMutations != *enumState.mutationsPtr)\n\t\t\t\t";
buf += "objc_enumerationMutation(l_collection);\n\t\t\t";
buf += elementName;
buf += " = (";
buf += elementTypeAsString;
buf += ")enumState.itemsPtr[counter++];";
// Replace ')' in for '(' type elem in collection ')' with all of these.
ReplaceText(lparenLoc, 1, buf);

///            __continue_label: ;
///        } while (counter < limit);
///   } while (limit = [l_collection countByEnumeratingWithState:&enumState
///                                  objects:__rw_items count:16]);
///   elem = nil;
///   __break_label: ;
///  }
///  else
///       elem = nil;
///  }
///
buf = ";\n\t";
buf += "__continue_label_";
buf += utostr(ObjCBcLabelNo.back());
buf += ": ;";
buf += "\n\t\t";
buf += "} while (counter < limit);\n\t";
buf += "} while (limit = ";
SynthCountByEnumWithState(buf);
buf += ");\n\t";
buf += elementName;
buf += " = ((";
buf += elementTypeAsString;
buf += ")0);\n\t";
buf += "__break_label_";
buf += utostr(ObjCBcLabelNo.back());
buf += ": ;\n\t";
buf += "}\n\t";
buf += "else\n\t\t";
buf += elementName;
buf += " = ((";
buf += elementTypeAsString;
buf += ")0);\n\t";
buf += "}\n";

// Insert all these *after* the statement body.
// FIXME: If this should support Obj-C++, support CXXTryStmt
if (isa<CompoundStmt>(S->getBody())) {
  SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(1);
  InsertText(endBodyLoc, buf);
} else {
  /* Need to treat single statements specially. For example:
   *
   *     for (A *a in b) if (stuff()) break;
   *     for (A *a in b) xxxyy;
   *
   * The following code simply scans ahead to the semi to find the actual end.
   */
  const char *stmtBuf = SM->getCharacterData(OrigEnd);
  const char *semiBuf = strchr(stmtBuf, ';');
  assert(semiBuf && "Can't find ';'")(static_cast<void> (0));
  SourceLocation endBodyLoc = OrigEnd.getLocWithOffset(semiBuf-stmtBuf+1);
  InsertText(endBodyLoc, buf);
}
Stmts.pop_back();
ObjCBcLabelNo.pop_back();
return nullptr;
1642}

1644/// RewriteObjCSynchronizedStmt -
1645/// This routine rewrites @synchronized(expr) stmt;
1646/// into:
1647/// objc_sync_enter(expr);
1648/// @try stmt @finally { objc_sync_exit(expr); }
1649///
1650Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
// Get the start location and compute the semi location.
SourceLocation startLoc = S->getBeginLoc();
const char *startBuf = SM->getCharacterData(startLoc);

assert((*startBuf == '@') && "bogus @synchronized location")(static_cast<void> (0));

std::string buf;
buf = "objc_sync_enter((id)";
const char *lparenBuf = startBuf;
while (*lparenBuf != '(') lparenBuf++;
ReplaceText(startLoc, lparenBuf-startBuf+1, buf);
// We can't use S->getSynchExpr()->getEndLoc() to find the end location, since
// the sync expression is typically a message expression that's already
// been rewritten! (which implies the SourceLocation's are invalid).
SourceLocation endLoc = S->getSynchBody()->getBeginLoc();
const char *endBuf = SM->getCharacterData(endLoc);
while (*endBuf != ')') endBuf--;
SourceLocation rparenLoc = startLoc.getLocWithOffset(endBuf-startBuf);
buf = ");\n";
// declare a new scope with two variables, _stack and _rethrow.
buf += "/* @try scope begin */ \n{ struct _objc_exception_data {\n";
buf += "int buf[18/*32-bit i386*/];\n";
buf += "char *pointers[4];} _stack;\n";
buf += "id volatile _rethrow = 0;\n";
buf += "objc_exception_try_enter(&_stack);\n";
buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
ReplaceText(rparenLoc, 1, buf);
startLoc = S->getSynchBody()->getEndLoc();
startBuf = SM->getCharacterData(startLoc);

assert((*startBuf == '}') && "bogus @synchronized block")(static_cast<void> (0));
SourceLocation lastCurlyLoc = startLoc;
buf = "}\nelse {\n";
buf += "  _rethrow = objc_exception_extract(&_stack);\n";
buf += "}\n";
buf += "{ /* implicit finally clause */\n";
buf += "  if (!_rethrow) objc_exception_try_exit(&_stack);\n";

std::string syncBuf;
syncBuf += " objc_sync_exit(";

Expr *syncExpr = S->getSynchExpr();
CastKind CK = syncExpr->getType()->isObjCObjectPointerType()
                ? CK_BitCast :
              syncExpr->getType()->isBlockPointerType()
                ? CK_BlockPointerToObjCPointerCast
                : CK_CPointerToObjCPointerCast;
syncExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
                                    CK, syncExpr);
std::string syncExprBufS;
llvm::raw_string_ostream syncExprBuf(syncExprBufS);
assert(syncExpr != nullptr && "Expected non-null Expr")(static_cast<void> (0));
syncExpr->printPretty(syncExprBuf, nullptr, PrintingPolicy(LangOpts));
syncBuf += syncExprBuf.str();
syncBuf += ");";

buf += syncBuf;
buf += "\n  if (_rethrow) objc_exception_throw(_rethrow);\n";
buf += "}\n";
buf += "}";

ReplaceText(lastCurlyLoc, 1, buf);

bool hasReturns = false;
HasReturnStmts(S->getSynchBody(), hasReturns);
if (hasReturns)
  RewriteSyncReturnStmts(S->getSynchBody(), syncBuf);

return nullptr;
1720}

1722void RewriteObjC::WarnAboutReturnGotoStmts(Stmt *S)
1723{
// Perform a bottom up traversal of all children.
for (Stmt *SubStmt : S->children())
  if (SubStmt)
    WarnAboutReturnGotoStmts(SubStmt);

if (isa<ReturnStmt>(S) || isa<GotoStmt>(S)) {
  Diags.Report(Context->getFullLoc(S->getBeginLoc()),
               TryFinallyContainsReturnDiag);
}
1733}

1735void RewriteObjC::HasReturnStmts(Stmt *S, bool &hasReturns)
1736{
// Perform a bottom up traversal of all children.
for (Stmt *SubStmt : S->children())
  if (SubStmt)
    HasReturnStmts(SubStmt, hasReturns);

if (isa<ReturnStmt>(S))
  hasReturns = true;
1744}

1746void RewriteObjC::RewriteTryReturnStmts(Stmt *S) {
// Perform a bottom up traversal of all children.
for (Stmt *SubStmt : S->children())
  if (SubStmt) {
    RewriteTryReturnStmts(SubStmt);
  }
if (isa<ReturnStmt>(S)) {
  SourceLocation startLoc = S->getBeginLoc();
  const char *startBuf = SM->getCharacterData(startLoc);
  const char *semiBuf = strchr(startBuf, ';');
  assert((*semiBuf == ';') && "RewriteTryReturnStmts: can't find ';'")(static_cast<void> (0));
  SourceLocation onePastSemiLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1);

  std::string buf;
  buf = "{ objc_exception_try_exit(&_stack); return";

  ReplaceText(startLoc, 6, buf);
  InsertText(onePastSemiLoc, "}");
}
1765}

1767void RewriteObjC::RewriteSyncReturnStmts(Stmt *S, std::string syncExitBuf) {
// Perform a bottom up traversal of all children.
for (Stmt *SubStmt : S->children())
  if (SubStmt) {
    RewriteSyncReturnStmts(SubStmt, syncExitBuf);
  }
if (isa<ReturnStmt>(S)) {
  SourceLocation startLoc = S->getBeginLoc();
  const char *startBuf = SM->getCharacterData(startLoc);

  const char *semiBuf = strchr(startBuf, ';');
  assert((*semiBuf == ';') && "RewriteSyncReturnStmts: can't find ';'")(static_cast<void> (0));
  SourceLocation onePastSemiLoc = startLoc.getLocWithOffset(semiBuf-startBuf+1);

  std::string buf;
  buf = "{ objc_exception_try_exit(&_stack);";
  buf += syncExitBuf;
  buf += " return";

  ReplaceText(startLoc, 6, buf);
  InsertText(onePastSemiLoc, "}");
}
1789}

1791Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
// Get the start location and compute the semi location.
SourceLocation startLoc = S->getBeginLoc();
const char *startBuf = SM->getCharacterData(startLoc);

assert((*startBuf == '@') && "bogus @try location")(static_cast<void> (0));

std::string buf;
// declare a new scope with two variables, _stack and _rethrow.
buf = "/* @try scope begin */ { struct _objc_exception_data {\n";
buf += "int buf[18/*32-bit i386*/];\n";
buf += "char *pointers[4];} _stack;\n";
buf += "id volatile _rethrow = 0;\n";
buf += "objc_exception_try_enter(&_stack);\n";
buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";

ReplaceText(startLoc, 4, buf);

startLoc = S->getTryBody()->getEndLoc();
startBuf = SM->getCharacterData(startLoc);

assert((*startBuf == '}') && "bogus @try block")(static_cast<void> (0));

SourceLocation lastCurlyLoc = startLoc;
if (S->getNumCatchStmts()) {
  startLoc = startLoc.getLocWithOffset(1);
  buf = " /* @catch begin */ else {\n";
  buf += " id _caught = objc_exception_extract(&_stack);\n";
  buf += " objc_exception_try_enter (&_stack);\n";
  buf += " if (_setjmp(_stack.buf))\n";
  buf += "   _rethrow = objc_exception_extract(&_stack);\n";
  buf += " else { /* @catch continue */";

  InsertText(startLoc, buf);
} else { /* no catch list */
  buf = "}\nelse {\n";
  buf += "  _rethrow = objc_exception_extract(&_stack);\n";
  buf += "}";
  ReplaceText(lastCurlyLoc, 1, buf);
}
Stmt *lastCatchBody = nullptr;
for (unsigned I = 0, N = S->getNumCatchStmts(); I != N; ++I) {
  ObjCAtCatchStmt *Catch = S->getCatchStmt(I);
  VarDecl *catchDecl = Catch->getCatchParamDecl();

  if (I == 0)
    buf = "if ("; // we are generating code for the first catch clause
  else
    buf = "else if (";
  startLoc = Catch->getBeginLoc();
  startBuf = SM->getCharacterData(startLoc);

  assert((*startBuf == '@') && "bogus @catch location")(static_cast<void> (0));

  const char *lParenLoc = strchr(startBuf, '(');

  if (Catch->hasEllipsis()) {
    // Now rewrite the body...
    lastCatchBody = Catch->getCatchBody();
    SourceLocation bodyLoc = lastCatchBody->getBeginLoc();
    const char *bodyBuf = SM->getCharacterData(bodyLoc);
    assert(*SM->getCharacterData(Catch->getRParenLoc()) == ')' &&(static_cast<void> (0))
           "bogus @catch paren location")(static_cast<void> (0));
    assert((*bodyBuf == '{') && "bogus @catch body location")(static_cast<void> (0));

    buf += "1) { id _tmp = _caught;";
    Rewrite.ReplaceText(startLoc, bodyBuf-startBuf+1, buf);
  } else if (catchDecl) {
    QualType t = catchDecl->getType();
    if (t == Context->getObjCIdType()) {
      buf += "1) { ";
      ReplaceText(startLoc, lParenLoc-startBuf+1, buf);
    } else if (const ObjCObjectPointerType *Ptr =
                 t->getAs<ObjCObjectPointerType>()) {
      // Should be a pointer to a class.
      ObjCInterfaceDecl *IDecl = Ptr->getObjectType()->getInterface();
      if (IDecl) {
        buf += "objc_exception_match((struct objc_class *)objc_getClass(\"";
        buf += IDecl->getNameAsString();
        buf += "\"), (struct objc_object *)_caught)) { ";
        ReplaceText(startLoc, lParenLoc-startBuf+1, buf);
      }
    }
    // Now rewrite the body...
    lastCatchBody = Catch->getCatchBody();
    SourceLocation rParenLoc = Catch->getRParenLoc();
    SourceLocation bodyLoc = lastCatchBody->getBeginLoc();
    const char *bodyBuf = SM->getCharacterData(bodyLoc);
    const char *rParenBuf = SM->getCharacterData(rParenLoc);
    assert((*rParenBuf == ')') && "bogus @catch paren location")(static_cast<void> (0));
    assert((*bodyBuf == '{') && "bogus @catch body location")(static_cast<void> (0));

    // Here we replace ") {" with "= _caught;" (which initializes and
    // declares the @catch parameter).
    ReplaceText(rParenLoc, bodyBuf-rParenBuf+1, " = _caught;");
  } else {
    llvm_unreachable("@catch rewrite bug")__builtin_unreachable();
  }
}
// Complete the catch list...
if (lastCatchBody) {
  SourceLocation bodyLoc = lastCatchBody->getEndLoc();
  assert(*SM->getCharacterData(bodyLoc) == '}' &&(static_cast<void> (0))
         "bogus @catch body location")(static_cast<void> (0));

  // Insert the last (implicit) else clause *before* the right curly brace.
  bodyLoc = bodyLoc.getLocWithOffset(-1);
  buf = "} /* last catch end */\n";
  buf += "else {\n";
  buf += " _rethrow = _caught;\n";
  buf += " objc_exception_try_exit(&_stack);\n";
  buf += "} } /* @catch end */\n";
  if (!S->getFinallyStmt())
    buf += "}\n";
  InsertText(bodyLoc, buf);

  // Set lastCurlyLoc
  lastCurlyLoc = lastCatchBody->getEndLoc();
}
if (ObjCAtFinallyStmt *finalStmt = S->getFinallyStmt()) {
  startLoc = finalStmt->getBeginLoc();
  startBuf = SM->getCharacterData(startLoc);
  assert((*startBuf == '@') && "bogus @finally start")(static_cast<void> (0));

  ReplaceText(startLoc, 8, "/* @finally */");

  Stmt *body = finalStmt->getFinallyBody();
  SourceLocation startLoc = body->getBeginLoc();
  SourceLocation endLoc = body->getEndLoc();
  assert(*SM->getCharacterData(startLoc) == '{' &&(static_cast<void> (0))
         "bogus @finally body location")(static_cast<void> (0));
  assert(*SM->getCharacterData(endLoc) == '}' &&(static_cast<void> (0))
         "bogus @finally body location")(static_cast<void> (0));

  startLoc = startLoc.getLocWithOffset(1);
  InsertText(startLoc, " if (!_rethrow) objc_exception_try_exit(&_stack);\n");
  endLoc = endLoc.getLocWithOffset(-1);
  InsertText(endLoc, " if (_rethrow) objc_exception_throw(_rethrow);\n");

  // Set lastCurlyLoc
  lastCurlyLoc = body->getEndLoc();

  // Now check for any return/continue/go statements within the @try.
  WarnAboutReturnGotoStmts(S->getTryBody());
} else { /* no finally clause - make sure we synthesize an implicit one */
  buf = "{ /* implicit finally clause */\n";
  buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
  buf += " if (_rethrow) objc_exception_throw(_rethrow);\n";
  buf += "}";
  ReplaceText(lastCurlyLoc, 1, buf);

  // Now check for any return/continue/go statements within the @try.
  // The implicit finally clause won't called if the @try contains any
  // jump statements.
  bool hasReturns = false;
  HasReturnStmts(S->getTryBody(), hasReturns);
  if (hasReturns)
    RewriteTryReturnStmts(S->getTryBody());
}
// Now emit the final closing curly brace...
lastCurlyLoc = lastCurlyLoc.getLocWithOffset(1);
InsertText(lastCurlyLoc, " } /* @try scope end */\n");
return nullptr;
1954}

1956// This can't be done with ReplaceStmt(S, ThrowExpr), since
1957// the throw expression is typically a message expression that's already
1958// been rewritten! (which implies the SourceLocation's are invalid).
1959Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
// Get the start location and compute the semi location.
SourceLocation startLoc = S->getBeginLoc();
const char *startBuf = SM->getCharacterData(startLoc);

assert((*startBuf == '@') && "bogus @throw location")(static_cast<void> (0));

std::string buf;
/* void objc_exception_throw(id) __attribute__((noreturn)); */
if (S->getThrowExpr())
  buf = "objc_exception_throw(";
else // add an implicit argument
  buf = "objc_exception_throw(_caught";

// handle "@  throw" correctly.
const char *wBuf = strchr(startBuf, 'w');
assert((*wBuf == 'w') && "@throw: can't find 'w'")(static_cast<void> (0));
ReplaceText(startLoc, wBuf-startBuf+1, buf);

const char *semiBuf = strchr(startBuf, ';');
assert((*semiBuf == ';') && "@throw: can't find ';'")(static_cast<void> (0));
SourceLocation semiLoc = startLoc.getLocWithOffset(semiBuf-startBuf);
ReplaceText(semiLoc, 1, ");");
return nullptr;
1983}

1985Stmt *RewriteObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
// Create a new string expression.
std::string StrEncoding;
Context->getObjCEncodingForType(Exp->getEncodedType(), StrEncoding);
Expr *Replacement = getStringLiteral(StrEncoding);
ReplaceStmt(Exp, Replacement);

// Replace this subexpr in the parent.
// delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
return Replacement;
1995}

1997Stmt *RewriteObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
if (!SelGetUidFunctionDecl)
  SynthSelGetUidFunctionDecl();
assert(SelGetUidFunctionDecl && "Can't find sel_registerName() decl")(static_cast<void> (0));
// Create a call to sel_registerName("selName").
SmallVector<Expr*, 8> SelExprs;
SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString()));
CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
                                                SelExprs);
ReplaceStmt(Exp, SelExp);
// delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
return SelExp;
2009}

2011CallExpr *
2012RewriteObjC::SynthesizeCallToFunctionDecl(FunctionDecl *FD,
                                        ArrayRef<Expr *> Args,
                                        SourceLocation StartLoc,
                                        SourceLocation EndLoc) {
// Get the type, we will need to reference it in a couple spots.
QualType msgSendType = FD->getType();

// Create a reference to the objc_msgSend() declaration.
DeclRefExpr *DRE = new (Context) DeclRefExpr(*Context, FD, false, msgSendType,
                                             VK_LValue, SourceLocation());

// Now, we cast the reference to a pointer to the objc_msgSend type.
QualType pToFunc = Context->getPointerType(msgSendType);
ImplicitCastExpr *ICE =
    ImplicitCastExpr::Create(*Context, pToFunc, CK_FunctionToPointerDecay,
                             DRE, nullptr, VK_PRValue, FPOptionsOverride());

const auto *FT = msgSendType->castAs<FunctionType>();

CallExpr *Exp =
    CallExpr::Create(*Context, ICE, Args, FT->getCallResultType(*Context),
                     VK_PRValue, EndLoc, FPOptionsOverride());
return Exp;
2035}

2037static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
                              const char *&startRef, const char *&endRef) {
while (startBuf < endBuf) {
  if (*startBuf == '<')
    startRef = startBuf; // mark the start.
  if (*startBuf == '>') {
    if (startRef && *startRef == '<') {
      endRef = startBuf; // mark the end.
      return true;
    }
    return false;
  }
  startBuf++;
}
return false;
2052}

2054static void scanToNextArgument(const char *&argRef) {
int angle = 0;
while (*argRef != ')' && (*argRef != ',' || angle > 0)) {
  if (*argRef == '<')
    angle++;
  else if (*argRef == '>')
    angle--;
  argRef++;
}
assert(angle == 0 && "scanToNextArgument - bad protocol type syntax")(static_cast<void> (0));
2064}

2066bool RewriteObjC::needToScanForQualifiers(QualType T) {
if (T->isObjCQualifiedIdType())
  return true;
if (const PointerType *PT = T->getAs<PointerType>()) {
  if (PT->getPointeeType()->isObjCQualifiedIdType())
    return true;
}
if (T->isObjCObjectPointerType()) {
  T = T->getPointeeType();
  return T->isObjCQualifiedInterfaceType();
}
if (T->isArrayType()) {
  QualType ElemTy = Context->getBaseElementType(T);
  return needToScanForQualifiers(ElemTy);
}
return false;
2082}

2084void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
QualType Type = E->getType();
if (needToScanForQualifiers(Type)) {
  SourceLocation Loc, EndLoc;

  if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) {
    Loc = ECE->getLParenLoc();
    EndLoc = ECE->getRParenLoc();
  } else {
    Loc = E->getBeginLoc();
    EndLoc = E->getEndLoc();
  }
  // This will defend against trying to rewrite synthesized expressions.
  if (Loc.isInvalid() || EndLoc.isInvalid())
    return;

  const char *startBuf = SM->getCharacterData(Loc);
  const char *endBuf = SM->getCharacterData(EndLoc);
  const char *startRef = nullptr, *endRef = nullptr;
  if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
    // Get the locations of the startRef, endRef.
    SourceLocation LessLoc = Loc.getLocWithOffset(startRef-startBuf);
    SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-startBuf+1);
    // Comment out the protocol references.
    InsertText(LessLoc, "/*");
    InsertText(GreaterLoc, "*/");
  }
}
2112}

2114void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) {
SourceLocation Loc;
QualType Type;
const FunctionProtoType *proto = nullptr;
if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) {
  Loc = VD->getLocation();
  Type = VD->getType();
}
else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Dcl)) {
  Loc = FD->getLocation();
  // Check for ObjC 'id' and class types that have been adorned with protocol
  // information (id<p>, C<p>*). The protocol references need to be rewritten!
  const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
  assert(funcType && "missing function type")(static_cast<void> (0));
  proto = dyn_cast<FunctionProtoType>(funcType);
  if (!proto)
    return;
  Type = proto->getReturnType();
}
else if (FieldDecl *FD = dyn_cast<FieldDecl>(Dcl)) {
  Loc = FD->getLocation();
  Type = FD->getType();
}
else
  return;

if (needToScanForQualifiers(Type)) {
  // Since types are unique, we need to scan the buffer.

  const char *endBuf = SM->getCharacterData(Loc);
  const char *startBuf = endBuf;
  while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart)
    startBuf--; // scan backward (from the decl location) for return type.
  const char *startRef = nullptr, *endRef = nullptr;
  if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
    // Get the locations of the startRef, endRef.
    SourceLocation LessLoc = Loc.getLocWithOffset(startRef-endBuf);
    SourceLocation GreaterLoc = Loc.getLocWithOffset(endRef-endBuf+1);
    // Comment out the protocol references.
    InsertText(LessLoc, "/*");
    InsertText(GreaterLoc, "*/");
  }
}
if (!proto)
    return; // most likely, was a variable
// Now check arguments.
const char *startBuf = SM->getCharacterData(Loc);
const char *startFuncBuf = startBuf;
for (unsigned i = 0; i < proto->getNumParams(); i++) {
  if (needToScanForQualifiers(proto->getParamType(i))) {
    // Since types are unique, we need to scan the buffer.

    const char *endBuf = startBuf;
    // scan forward (from the decl location) for argument types.
    scanToNextArgument(endBuf);
    const char *startRef = nullptr, *endRef = nullptr;
    if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
      // Get the locations of the startRef, endRef.
      SourceLocation LessLoc =
        Loc.getLocWithOffset(startRef-startFuncBuf);
      SourceLocation GreaterLoc =
        Loc.getLocWithOffset(endRef-startFuncBuf+1);
      // Comment out the protocol references.
      InsertText(LessLoc, "/*");
      InsertText(GreaterLoc, "*/");
    }
    startBuf = ++endBuf;
  }
  else {
    // If the function name is derived from a macro expansion, then the
    // argument buffer will not follow the name. Need to speak with Chris.
    while (*startBuf && *startBuf != ')' && *startBuf != ',')
      startBuf++; // scan forward (from the decl location) for argument types.
    startBuf++;
  }
}
2190}

2192void RewriteObjC::RewriteTypeOfDecl(VarDecl *ND) {
QualType QT = ND->getType();
const Type* TypePtr = QT->getAs<Type>();
if (!isa<TypeOfExprType>(TypePtr))
  return;
while (isa<TypeOfExprType>(TypePtr)) {
  const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr);
  QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType();
  TypePtr = QT->getAs<Type>();
}
// FIXME. This will not work for multiple declarators; as in:
// __typeof__(a) b,c,d;
std::string TypeAsString(QT.getAsString(Context->getPrintingPolicy()));
SourceLocation DeclLoc = ND->getTypeSpecStartLoc();
const char *startBuf = SM->getCharacterData(DeclLoc);
if (ND->getInit()) {
  std::string Name(ND->getNameAsString());
  TypeAsString += " " + Name + " = ";
  Expr *E = ND->getInit();
  SourceLocation startLoc;
  if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E))
    startLoc = ECE->getLParenLoc();
  else
    startLoc = E->getBeginLoc();
  startLoc = SM->getExpansionLoc(startLoc);
  const char *endBuf = SM->getCharacterData(startLoc);
  ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString);
}
else {
  SourceLocation X = ND->getEndLoc();
  X = SM->getExpansionLoc(X);
  const char *endBuf = SM->getCharacterData(X);
  ReplaceText(DeclLoc, endBuf-startBuf-1, TypeAsString);
}
2226}

2228// SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
2229void RewriteObjC::SynthSelGetUidFunctionDecl() {
IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
SmallVector<QualType, 16> ArgTys;
ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
QualType getFuncType =
  getSimpleFunctionType(Context->getObjCSelType(), ArgTys);
SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                             SourceLocation(),
                                             SourceLocation(),
                                             SelGetUidIdent, getFuncType,
                                             nullptr, SC_Extern);
2240}

2242void RewriteObjC::RewriteFunctionDecl(FunctionDecl *FD) {
// declared in <objc/objc.h>
if (FD->getIdentifier() &&
    FD->getName() == "sel_registerName") {
  SelGetUidFunctionDecl = FD;
  return;
}
RewriteObjCQualifiedInterfaceTypes(FD);
2250}

2252void RewriteObjC::RewriteBlockPointerType(std::string& Str, QualType Type) {
std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
const char *argPtr = TypeString.c_str();
if (!strchr(argPtr, '^')) {
  Str += TypeString;
  return;
}
while (*argPtr) {
  Str += (*argPtr == '^' ? '*' : *argPtr);
  argPtr++;
}
2263}

2265// FIXME. Consolidate this routine with RewriteBlockPointerType.
2266void RewriteObjC::RewriteBlockPointerTypeVariable(std::string& Str,
                                                ValueDecl *VD) {
QualType Type = VD->getType();
std::string TypeString(Type.getAsString(Context->getPrintingPolicy()));
const char *argPtr = TypeString.c_str();
int paren = 0;
while (*argPtr) {
  switch (*argPtr) {
    case '(':
      Str += *argPtr;
      paren++;
      break;
    case ')':
      Str += *argPtr;
      paren--;
      break;
    case '^':
      Str += '*';
      if (paren == 1)
        Str += VD->getNameAsString();
      break;
    default:
      Str += *argPtr;
      break;
  }
  argPtr++;
}
2293}

2295void RewriteObjC::RewriteBlockLiteralFunctionDecl(FunctionDecl *FD) {
SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
const FunctionType *funcType = FD->getType()->getAs<FunctionType>();
const FunctionProtoType *proto = dyn_cast_or_null<FunctionProtoType>(funcType);
if (!proto)
  return;
QualType Type = proto->getReturnType();
std::string FdStr = Type.getAsString(Context->getPrintingPolicy());
FdStr += " ";
FdStr += FD->getName();
FdStr +=  "(";
unsigned numArgs = proto->getNumParams();
for (unsigned i = 0; i < numArgs; i++) {
  QualType ArgType = proto->getParamType(i);
  RewriteBlockPointerType(FdStr, ArgType);
  if (i+1 < numArgs)
    FdStr += ", ";
}
FdStr +=  ");\n";
InsertText(FunLocStart, FdStr);
CurFunctionDeclToDeclareForBlock = nullptr;
2316}

2318// SynthSuperConstructorFunctionDecl - id objc_super(id obj, id super);
2319void RewriteObjC::SynthSuperConstructorFunctionDecl() {
if (SuperConstructorFunctionDecl)
  return;
IdentifierInfo *msgSendIdent = &Context->Idents.get("__rw_objc_super");
SmallVector<QualType, 16> ArgTys;
QualType argT = Context->getObjCIdType();
assert(!argT.isNull() && "Can't find 'id' type")(static_cast<void> (0));
ArgTys.push_back(argT);
ArgTys.push_back(argT);
QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                             ArgTys);
SuperConstructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                   SourceLocation(),
                                                   SourceLocation(),
                                                   msgSendIdent, msgSendType,
                                                   nullptr, SC_Extern);
2335}

2337// SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
2338void RewriteObjC::SynthMsgSendFunctionDecl() {
IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
SmallVector<QualType, 16> ArgTys;
QualType argT = Context->getObjCIdType();
assert(!argT.isNull() && "Can't find 'id' type")(static_cast<void> (0));
ArgTys.push_back(argT);
argT = Context->getObjCSelType();
assert(!argT.isNull() && "Can't find 'SEL' type")(static_cast<void> (0));
ArgTys.push_back(argT);
QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                             ArgTys, /*variadic=*/true);
MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                           SourceLocation(),
                                           SourceLocation(),
                                           msgSendIdent, msgSendType,
                                           nullptr, SC_Extern);
2354}

2356// SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(struct objc_super *, SEL op, ...);
2357void RewriteObjC::SynthMsgSendSuperFunctionDecl() {
IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
SmallVector<QualType, 16> ArgTys;
RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
                                    SourceLocation(), SourceLocation(),
                                    &Context->Idents.get("objc_super"));
QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
assert(!argT.isNull() && "Can't build 'struct objc_super *' type")(static_cast<void> (0));
ArgTys.push_back(argT);
argT = Context->getObjCSelType();
assert(!argT.isNull() && "Can't find 'SEL' type")(static_cast<void> (0));
ArgTys.push_back(argT);
QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                             ArgTys, /*variadic=*/true);
MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                SourceLocation(),
                                                SourceLocation(),
                                                msgSendIdent, msgSendType,
                                                nullptr, SC_Extern);
2376}

2378// SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
2379void RewriteObjC::SynthMsgSendStretFunctionDecl() {
IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
SmallVector<QualType, 16> ArgTys;
QualType argT = Context->getObjCIdType();
assert(!argT.isNull() && "Can't find 'id' type")(static_cast<void> (0));
ArgTys.push_back(argT);
argT = Context->getObjCSelType();
assert(!argT.isNull() && "Can't find 'SEL' type")(static_cast<void> (0));
ArgTys.push_back(argT);
QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                             ArgTys, /*variadic=*/true);
MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                SourceLocation(),
                                                SourceLocation(),
                                                msgSendIdent, msgSendType,
                                                nullptr, SC_Extern);
2395}

2397// SynthMsgSendSuperStretFunctionDecl -
2398// id objc_msgSendSuper_stret(struct objc_super *, SEL op, ...);
2399void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() {
IdentifierInfo *msgSendIdent =
  &Context->Idents.get("objc_msgSendSuper_stret");
SmallVector<QualType, 16> ArgTys;
RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
                                    SourceLocation(), SourceLocation(),
                                    &Context->Idents.get("objc_super"));
QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
assert(!argT.isNull() && "Can't build 'struct objc_super *' type")(static_cast<void> (0));
ArgTys.push_back(argT);
argT = Context->getObjCSelType();
assert(!argT.isNull() && "Can't find 'SEL' type")(static_cast<void> (0));
ArgTys.push_back(argT);
QualType msgSendType = getSimpleFunctionType(Context->getObjCIdType(),
                                             ArgTys, /*variadic=*/true);
MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                     SourceLocation(),
                                                     SourceLocation(),
                                                     msgSendIdent,
                                                     msgSendType, nullptr,
                                                     SC_Extern);
2420}

2422// SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
2423void RewriteObjC::SynthMsgSendFpretFunctionDecl() {
IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
SmallVector<QualType, 16> ArgTys;
QualType argT = Context->getObjCIdType();
assert(!argT.isNull() && "Can't find 'id' type")(static_cast<void> (0));
ArgTys.push_back(argT);
argT = Context->getObjCSelType();
assert(!argT.isNull() && "Can't find 'SEL' type")(static_cast<void> (0));
ArgTys.push_back(argT);
QualType msgSendType = getSimpleFunctionType(Context->DoubleTy,
                                             ArgTys, /*variadic=*/true);
MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                SourceLocation(),
                                                SourceLocation(),
                                                msgSendIdent, msgSendType,
                                                nullptr, SC_Extern);
2439}

2441// SynthGetClassFunctionDecl - id objc_getClass(const char *name);
2442void RewriteObjC::SynthGetClassFunctionDecl() {
IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
SmallVector<QualType, 16> ArgTys;
ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
QualType getClassType = getSimpleFunctionType(Context->getObjCIdType(),
                                              ArgTys);
GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                            SourceLocation(),
                                            SourceLocation(),
                                            getClassIdent, getClassType,
                                            nullptr, SC_Extern);
2453}

2455// SynthGetSuperClassFunctionDecl - Class class_getSuperclass(Class cls);
2456void RewriteObjC::SynthGetSuperClassFunctionDecl() {
IdentifierInfo *getSuperClassIdent =
  &Context->Idents.get("class_getSuperclass");
SmallVector<QualType, 16> ArgTys;
ArgTys.push_back(Context->getObjCClassType());
QualType getClassType = getSimpleFunctionType(Context->getObjCClassType(),
                                              ArgTys);
GetSuperClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                 SourceLocation(),
                                                 SourceLocation(),
                                                 getSuperClassIdent,
                                                 getClassType, nullptr,
                                                 SC_Extern);
2469}

2471// SynthGetMetaClassFunctionDecl - id objc_getMetaClass(const char *name);
2472void RewriteObjC::SynthGetMetaClassFunctionDecl() {
IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
SmallVector<QualType, 16> ArgTys;
ArgTys.push_back(Context->getPointerType(Context->CharTy.withConst()));
QualType getClassType = getSimpleFunctionType(Context->getObjCIdType(),
                                              ArgTys);
GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
                                                SourceLocation(),
                                                SourceLocation(),
                                                getClassIdent, getClassType,
                                                nullptr, SC_Extern);
2483}

2485Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
assert(Exp != nullptr && "Expected non-null ObjCStringLiteral")(static_cast<void> (0));
QualType strType = getConstantStringStructType();

std::string S = "__NSConstantStringImpl_";

std::string tmpName = InFileName;
unsigned i;
for (i=0; i < tmpName.length(); i++) {
  char c = tmpName.at(i);
  // replace any non-alphanumeric characters with '_'.
  if (!isAlphanumeric(c))
    tmpName[i] = '_';
}
S += tmpName;
S += "_";
S += utostr(NumObjCStringLiterals++);

Preamble += "static __NSConstantStringImpl " + S;
Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
Preamble += "0x000007c8,"; // utf8_str
// The pretty printer for StringLiteral handles escape characters properly.
std::string prettyBufS;
llvm::raw_string_ostream prettyBuf(prettyBufS);
Exp->getString()->printPretty(prettyBuf, nullptr, PrintingPolicy(LangOpts));
Preamble += prettyBuf.str();
Preamble += ",";
Preamble += utostr(Exp->getString()->getByteLength()) + "};\n";

VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                                 SourceLocation(), &Context->Idents.get(S),
                                 strType, nullptr, SC_Static);
DeclRefExpr *DRE = new (Context)
    DeclRefExpr(*Context, NewVD, false, strType, VK_LValue, SourceLocation());
Expr *Unop = UnaryOperator::Create(
    const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
    Context->getPointerType(DRE->getType()), VK_PRValue, OK_Ordinary,
    SourceLocation(), false, FPOptionsOverride());
// cast to NSConstantString *
CastExpr *cast = NoTypeInfoCStyleCastExpr(Context, Exp->getType(),
                                          CK_CPointerToObjCPointerCast, Unop);
ReplaceStmt(Exp, cast);
// delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
return cast;
2529}

2531// struct objc_super { struct objc_object *receiver; struct objc_class *super; };
2532QualType RewriteObjC::getSuperStructType() {
if (!SuperStructDecl) {
  SuperStructDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
                                       SourceLocation(), SourceLocation(),
                                       &Context->Idents.get("objc_super"));
  QualType FieldTypes[2];

  // struct objc_object *receiver;
  FieldTypes[0] = Context->getObjCIdType();
  // struct objc_class *super;
  FieldTypes[1] = Context->getObjCClassType();

  // Create fields
  for (unsigned i = 0; i < 2; ++i) {
    SuperStructDecl->addDecl(FieldDecl::Create(*Context, SuperStructDecl,
                                               SourceLocation(),
                                               SourceLocation(), nullptr,
                                               FieldTypes[i], nullptr,
                                               /*BitWidth=*/nullptr,
                                               /*Mutable=*/false,
                                               ICIS_NoInit));
  }

  SuperStructDecl->completeDefinition();
}
return Context->getTagDeclType(SuperStructDecl);
2558}

2560QualType RewriteObjC::getConstantStringStructType() {
if (!ConstantStringDecl) {
  ConstantStringDecl = RecordDecl::Create(*Context, TTK_Struct, TUDecl,
                                          SourceLocation(), SourceLocation(),
                       &Context->Idents.get("__NSConstantStringImpl"));
  QualType FieldTypes[4];

  // struct objc_object *receiver;
  FieldTypes[0] = Context->getObjCIdType();
  // int flags;
  FieldTypes[1] = Context->IntTy;
  // char *str;
  FieldTypes[2] = Context->getPointerType(Context->CharTy);
  // long length;
  FieldTypes[3] = Context->LongTy;

  // Create fields
  for (unsigned i = 0; i < 4; ++i) {
    ConstantStringDecl->addDecl(FieldDecl::Create(*Context,
                                                  ConstantStringDecl,
                                                  SourceLocation(),
                                                  SourceLocation(), nullptr,
                                                  FieldTypes[i], nullptr,
                                                  /*BitWidth=*/nullptr,
                                                  /*Mutable=*/true,
                                                  ICIS_NoInit));
  }

  ConstantStringDecl->completeDefinition();
}
return Context->getTagDeclType(ConstantStringDecl);
2591}

2593CallExpr *RewriteObjC::SynthMsgSendStretCallExpr(FunctionDecl *MsgSendStretFlavor,
                                              QualType msgSendType,
                                              QualType returnType,
                                              SmallVectorImpl<QualType> &ArgTypes,
                                              SmallVectorImpl<Expr*> &MsgExprs,
                                              ObjCMethodDecl *Method) {
// Create a reference to the objc_msgSend_stret() declaration.
DeclRefExpr *STDRE =
    new (Context) DeclRefExpr(*Context, MsgSendStretFlavor, false,
                              msgSendType, VK_LValue, SourceLocation());
// Need to cast objc_msgSend_stret to "void *" (see above comment).
CastExpr *cast = NoTypeInfoCStyleCastExpr(Context,
                                Context->getPointerType(Context->VoidTy),
                                CK_BitCast, STDRE);
// Now do the "normal" pointer to function cast.
QualType castType = getSimpleFunctionType(returnType, ArgTypes,
                                          Method ? Method->isVariadic()
                                                 : false);
castType = Context->getPointerType(castType);
cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                          cast);

// Don't forget the parens to enforce the proper binding.
ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), cast);

const auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *STCE =
    CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(), VK_PRValue,
                     SourceLocation(), FPOptionsOverride());
return STCE;
2623}

2625Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp,
                                  SourceLocation StartLoc,
                                  SourceLocation EndLoc) {
if (!SelGetUidFunctionDecl)
  SynthSelGetUidFunctionDecl();
if (!MsgSendFunctionDecl)
  SynthMsgSendFunctionDecl();
if (!MsgSendSuperFunctionDecl)
  SynthMsgSendSuperFunctionDecl();
if (!MsgSendStretFunctionDecl)
  SynthMsgSendStretFunctionDecl();
if (!MsgSendSuperStretFunctionDecl)
  SynthMsgSendSuperStretFunctionDecl();
if (!MsgSendFpretFunctionDecl)
  SynthMsgSendFpretFunctionDecl();
if (!GetClassFunctionDecl)
  SynthGetClassFunctionDecl();
if (!GetSuperClassFunctionDecl)
  SynthGetSuperClassFunctionDecl();
if (!GetMetaClassFunctionDecl)
  SynthGetMetaClassFunctionDecl();

// default to objc_msgSend().
FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
// May need to use objc_msgSend_stret() as well.
FunctionDecl *MsgSendStretFlavor = nullptr;
if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
  QualType resultType = mDecl->getReturnType();
  if (resultType->isRecordType())
    MsgSendStretFlavor = MsgSendStretFunctionDecl;
  else if (resultType->isRealFloatingType())
    MsgSendFlavor = MsgSendFpretFunctionDecl;
}

// Synthesize a call to objc_msgSend().
SmallVector<Expr*, 8> MsgExprs;
switch (Exp->getReceiverKind()) {
case ObjCMessageExpr::SuperClass: {
  MsgSendFlavor = MsgSendSuperFunctionDecl;
  if (MsgSendStretFlavor)
    MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
  assert(MsgSendFlavor && "MsgSendFlavor is NULL!")(static_cast<void> (0));

  ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();

  SmallVector<Expr*, 4> InitExprs;

  // set the receiver to self, the first argument to all methods.
  InitExprs.push_back(NoTypeInfoCStyleCastExpr(
      Context, Context->getObjCIdType(), CK_BitCast,
      new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false,
                                Context->getObjCIdType(), VK_PRValue,
                                SourceLocation()))); // set the 'receiver'.

  // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
  SmallVector<Expr*, 8> ClsExprs;
  ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
  CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
                                               ClsExprs, StartLoc, EndLoc);
  // (Class)objc_getClass("CurrentClass")
  CastExpr *ArgExpr = NoTypeInfoCStyleCastExpr(Context,
                                           Context->getObjCClassType(),
                                           CK_BitCast, Cls);
  ClsExprs.clear();
  ClsExprs.push_back(ArgExpr);
  Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
                                     StartLoc, EndLoc);
  // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
  // To turn off a warning, type-cast to 'id'
  InitExprs.push_back( // set 'super class', using class_getSuperclass().
                      NoTypeInfoCStyleCastExpr(Context,
                                               Context->getObjCIdType(),
                                               CK_BitCast, Cls));
  // struct objc_super
  QualType superType = getSuperStructType();
  Expr *SuperRep;

  if (LangOpts.MicrosoftExt) {
    SynthSuperConstructorFunctionDecl();
    // Simulate a constructor call...
    DeclRefExpr *DRE = new (Context)
        DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
                    VK_LValue, SourceLocation());
    SuperRep =
        CallExpr::Create(*Context, DRE, InitExprs, superType, VK_LValue,
                         SourceLocation(), FPOptionsOverride());
    // The code for super is a little tricky to prevent collision with
    // the structure definition in the header. The rewriter has it's own
    // internal definition (__rw_objc_super) that is uses. This is why
    // we need the cast below. For example:
    // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
    //
    SuperRep = UnaryOperator::Create(
        const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
        Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
        SourceLocation(), false, FPOptionsOverride());
    SuperRep = NoTypeInfoCStyleCastExpr(Context,
                                        Context->getPointerType(superType),
                                        CK_BitCast, SuperRep);
  } else {
    // (struct objc_super) { <exprs from above> }
    InitListExpr *ILE =
      new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
                                 SourceLocation());
    TypeSourceInfo *superTInfo
      = Context->getTrivialTypeSourceInfo(superType);
    SuperRep = new (Context) CompoundLiteralExpr(SourceLocation(), superTInfo,
                                                 superType, VK_LValue,
                                                 ILE, false);
    // struct objc_super *
    SuperRep = UnaryOperator::Create(
        const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
        Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
        SourceLocation(), false, FPOptionsOverride());
  }
  MsgExprs.push_back(SuperRep);
  break;
}

case ObjCMessageExpr::Class: {
  SmallVector<Expr*, 8> ClsExprs;
  auto *Class =
      Exp->getClassReceiver()->castAs<ObjCObjectType>()->getInterface();
  IdentifierInfo *clsName = Class->getIdentifier();
  ClsExprs.push_back(getStringLiteral(clsName->getName()));
  CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
                                               StartLoc, EndLoc);
  MsgExprs.push_back(Cls);
  break;
}

case ObjCMessageExpr::SuperInstance:{
  MsgSendFlavor = MsgSendSuperFunctionDecl;
  if (MsgSendStretFlavor)
    MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
  assert(MsgSendFlavor && "MsgSendFlavor is NULL!")(static_cast<void> (0));
  ObjCInterfaceDecl *ClassDecl = CurMethodDef->getClassInterface();
  SmallVector<Expr*, 4> InitExprs;

  InitExprs.push_back(NoTypeInfoCStyleCastExpr(
      Context, Context->getObjCIdType(), CK_BitCast,
      new (Context) DeclRefExpr(*Context, CurMethodDef->getSelfDecl(), false,
                                Context->getObjCIdType(), VK_PRValue,
                                SourceLocation()))); // set the 'receiver'.

  // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
  SmallVector<Expr*, 8> ClsExprs;
  ClsExprs.push_back(getStringLiteral(ClassDecl->getIdentifier()->getName()));
  CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl, ClsExprs,
                                               StartLoc, EndLoc);
  // (Class)objc_getClass("CurrentClass")
  CastExpr *ArgExpr = NoTypeInfoCStyleCastExpr(Context,
                                               Context->getObjCClassType(),
                                               CK_BitCast, Cls);
  ClsExprs.clear();
  ClsExprs.push_back(ArgExpr);
  Cls = SynthesizeCallToFunctionDecl(GetSuperClassFunctionDecl, ClsExprs,
                                     StartLoc, EndLoc);

  // (id)class_getSuperclass((Class)objc_getClass("CurrentClass"))
  // To turn off a warning, type-cast to 'id'
  InitExprs.push_back(
    // set 'super class', using class_getSuperclass().
    NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
                             CK_BitCast, Cls));
  // struct objc_super
  QualType superType = getSuperStructType();
  Expr *SuperRep;

  if (LangOpts.MicrosoftExt) {
    SynthSuperConstructorFunctionDecl();
    // Simulate a constructor call...
    DeclRefExpr *DRE = new (Context)
        DeclRefExpr(*Context, SuperConstructorFunctionDecl, false, superType,
                    VK_LValue, SourceLocation());
    SuperRep =
        CallExpr::Create(*Context, DRE, InitExprs, superType, VK_LValue,
                         SourceLocation(), FPOptionsOverride());
    // The code for super is a little tricky to prevent collision with
    // the structure definition in the header. The rewriter has it's own
    // internal definition (__rw_objc_super) that is uses. This is why
    // we need the cast below. For example:
    // (struct objc_super *)&__rw_objc_super((id)self, (id)objc_getClass("SUPER"))
    //
    SuperRep = UnaryOperator::Create(
        const_cast<ASTContext &>(*Context), SuperRep, UO_AddrOf,
        Context->getPointerType(SuperRep->getType()), VK_PRValue, OK_Ordinary,
        SourceLocation(), false, FPOptionsOverride());
    SuperRep = NoTypeInfoCStyleCastExpr(Context,
                             Context->getPointerType(superType),
                             CK_BitCast, SuperRep);
  } else {
    // (struct objc_super) { <exprs from above> }
    InitListExpr *ILE =
      new (Context) InitListExpr(*Context, SourceLocation(), InitExprs,
                                 SourceLocation());
    TypeSourceInfo *superTInfo
      = Context->getTrivialTypeSourceInfo(superType);
    SuperRep = new (Context) CompoundLiteralExpr(
        SourceLocation(), superTInfo, superType, VK_PRValue, ILE, false);
  }
  MsgExprs.push_back(SuperRep);
  break;
}

case ObjCMessageExpr::Instance: {
  // Remove all type-casts because it may contain objc-style types; e.g.
  // Foo<Proto> *.
  Expr *recExpr = Exp->getInstanceReceiver();
  while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr))
    recExpr = CE->getSubExpr();
  CastKind CK = recExpr->getType()->isObjCObjectPointerType()
                  ? CK_BitCast : recExpr->getType()->isBlockPointerType()
                                   ? CK_BlockPointerToObjCPointerCast
                                   : CK_CPointerToObjCPointerCast;

  recExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
                                     CK, recExpr);
  MsgExprs.push_back(recExpr);
  break;
}
}

// Create a call to sel_registerName("selName"), it will be the 2nd argument.
SmallVector<Expr*, 8> SelExprs;
SelExprs.push_back(getStringLiteral(Exp->getSelector().getAsString()));
CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
                                                SelExprs, StartLoc, EndLoc);
MsgExprs.push_back(SelExp);

// Now push any user supplied arguments.
for (unsigned i = 0; i < Exp->getNumArgs(); i++) {
  Expr *userExpr = Exp->getArg(i);
  // Make all implicit casts explicit...ICE comes in handy:-)
  if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) {
    // Reuse the ICE type, it is exactly what the doctor ordered.
    QualType type = ICE->getType();
    if (needToScanForQualifiers(type))
      type = Context->getObjCIdType();
    // Make sure we convert "type (^)(...)" to "type (*)(...)".
    (void)convertBlockPointerToFunctionPointer(type);
    const Expr *SubExpr = ICE->IgnoreParenImpCasts();
    CastKind CK;
    if (SubExpr->getType()->isIntegralType(*Context) &&
        type->isBooleanType()) {
      CK = CK_IntegralToBoolean;
    } else if (type->isObjCObjectPointerType()) {
      if (SubExpr->getType()->isBlockPointerType()) {
        CK = CK_BlockPointerToObjCPointerCast;
      } else if (SubExpr->getType()->isPointerType()) {
        CK = CK_CPointerToObjCPointerCast;
      } else {
        CK = CK_BitCast;
      }
    } else {
      CK = CK_BitCast;
    }

    userExpr = NoTypeInfoCStyleCastExpr(Context, type, CK, userExpr);
  }
  // Make id<P...> cast into an 'id' cast.
  else if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(userExpr)) {
    if (CE->getType()->isObjCQualifiedIdType()) {
      while ((CE = dyn_cast<CStyleCastExpr>(userExpr)))
        userExpr = CE->getSubExpr();
      CastKind CK;
      if (userExpr->getType()->isIntegralType(*Context)) {
        CK = CK_IntegralToPointer;
      } else if (userExpr->getType()->isBlockPointerType()) {
        CK = CK_BlockPointerToObjCPointerCast;
      } else if (userExpr->getType()->isPointerType()) {
        CK = CK_CPointerToObjCPointerCast;
      } else {
        CK = CK_BitCast;
      }
      userExpr = NoTypeInfoCStyleCastExpr(Context, Context->getObjCIdType(),
                                          CK, userExpr);
    }
  }
  MsgExprs.push_back(userExpr);
  // We've transferred the ownership to MsgExprs. For now, we *don't* null
  // out the argument in the original expression (since we aren't deleting
  // the ObjCMessageExpr). See RewritePropertyOrImplicitSetter() usage for more info.
  //Exp->setArg(i, 0);
}
// Generate the funky cast.
CastExpr *cast;
SmallVector<QualType, 8> ArgTypes;
QualType returnType;

// Push 'id' and 'SEL', the 2 implicit arguments.
if (MsgSendFlavor == MsgSendSuperFunctionDecl)
  ArgTypes.push_back(Context->getPointerType(getSuperStructType()));
else
  ArgTypes.push_back(Context->getObjCIdType());
ArgTypes.push_back(Context->getObjCSelType());
if (ObjCMethodDecl *OMD = Exp->getMethodDecl()) {
  // Push any user argument types.
  for (const auto *PI : OMD->parameters()) {
    QualType t = PI->getType()->isObjCQualifiedIdType()
                   ? Context->getObjCIdType()
                   : PI->getType();
    // Make sure we convert "t (^)(...)" to "t (*)(...)".
    (void)convertBlockPointerToFunctionPointer(t);
    ArgTypes.push_back(t);
  }
  returnType = Exp->getType();
  convertToUnqualifiedObjCType(returnType);
  (void)convertBlockPointerToFunctionPointer(returnType);
} else {
  returnType = Context->getObjCIdType();
}
// Get the type, we will need to reference it in a couple spots.
QualType msgSendType = MsgSendFlavor->getType();

// Create a reference to the objc_msgSend() declaration.
DeclRefExpr *DRE = new (Context) DeclRefExpr(
    *Context, MsgSendFlavor, false, msgSendType, VK_LValue, SourceLocation());

// Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
// If we don't do this cast, we get the following bizarre warning/note:
// xx.m:13: warning: function called through a non-compatible type
// xx.m:13: note: if this code is reached, the program will abort
cast = NoTypeInfoCStyleCastExpr(Context,
                                Context->getPointerType(Context->VoidTy),
                                CK_BitCast, DRE);

// Now do the "normal" pointer to function cast.
// If we don't have a method decl, force a variadic cast.
const ObjCMethodDecl *MD = Exp->getMethodDecl();
QualType castType =
  getSimpleFunctionType(returnType, ArgTypes, MD ? MD->isVariadic() : true);
castType = Context->getPointerType(castType);
cast = NoTypeInfoCStyleCastExpr(Context, castType, CK_BitCast,
                                cast);

// Don't forget the parens to enforce the proper binding.
ParenExpr *PE = new (Context) ParenExpr(StartLoc, EndLoc, cast);

const auto *FT = msgSendType->castAs<FunctionType>();
CallExpr *CE = CallExpr::Create(*Context, PE, MsgExprs, FT->getReturnType(),
                                VK_PRValue, EndLoc, FPOptionsOverride());
Stmt *ReplacingStmt = CE;
if (MsgSendStretFlavor) {
  // We have the method which returns a struct/union. Must also generate
  // call to objc_msgSend_stret and hang both varieties on a conditional
  // expression which dictate which one to envoke depending on size of
  // method's return type.

  CallExpr *STCE = SynthMsgSendStretCallExpr(MsgSendStretFlavor,
                                             msgSendType, returnType,
                                             ArgTypes, MsgExprs,
                                             Exp->getMethodDecl());

  // Build sizeof(returnType)
  UnaryExprOrTypeTraitExpr *sizeofExpr =
     new (Context) UnaryExprOrTypeTraitExpr(UETT_SizeOf,
                               Context->getTrivialTypeSourceInfo(returnType),
                               Context->getSizeType(), SourceLocation(),
                               SourceLocation());
  // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
  // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases.
  // For X86 it is more complicated and some kind of target specific routine
  // is needed to decide what to do.
  unsigned IntSize =
    static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
  IntegerLiteral *limit = IntegerLiteral::Create(*Context,
                                                 llvm::APInt(IntSize, 8),
                                                 Context->IntTy,
                                                 SourceLocation());
  BinaryOperator *lessThanExpr = BinaryOperator::Create(
      *Context, sizeofExpr, limit, BO_LE, Context->IntTy, VK_PRValue,
      OK_Ordinary, SourceLocation(), FPOptionsOverride());
  // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
  ConditionalOperator *CondExpr = new (Context) ConditionalOperator(
      lessThanExpr, SourceLocation(), CE, SourceLocation(), STCE, returnType,
      VK_PRValue, OK_Ordinary);
  ReplacingStmt = new (Context) ParenExpr(SourceLocation(), SourceLocation(),
                                          CondExpr);
}
// delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
return ReplacingStmt;
3007}

3009Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
Stmt *ReplacingStmt =
    SynthMessageExpr(Exp, Exp->getBeginLoc(), Exp->getEndLoc());

// Now do the actual rewrite.
ReplaceStmt(Exp, ReplacingStmt);

// delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
return ReplacingStmt;
3018}

3020// typedef struct objc_object Protocol;
3021QualType RewriteObjC::getProtocolType() {
if (!ProtocolTypeDecl) {
  TypeSourceInfo *TInfo
    = Context->getTrivialTypeSourceInfo(Context->getObjCIdType());
  ProtocolTypeDecl = TypedefDecl::Create(*Context, TUDecl,
                                         SourceLocation(), SourceLocation(),
                                         &Context->Idents.get("Protocol"),
                                         TInfo);
}
return Context->getTypeDeclType(ProtocolTypeDecl);
3031}

3033/// RewriteObjCProtocolExpr - Rewrite a protocol expression into
3034/// a synthesized/forward data reference (to the protocol's metadata).
3035/// The forward references (and metadata) are generated in
3036/// RewriteObjC::HandleTranslationUnit().
3037Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
std::string Name = "_OBJC_PROTOCOL_" + Exp->getProtocol()->getNameAsString();
IdentifierInfo *ID = &Context->Idents.get(Name);
VarDecl *VD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
                              SourceLocation(), ID, getProtocolType(),
                              nullptr, SC_Extern);
DeclRefExpr *DRE = new (Context) DeclRefExpr(
    *Context, VD, false, getProtocolType(), VK_LValue, SourceLocation());
Expr *DerefExpr = UnaryOperator::Create(
    const_cast<ASTContext &>(*Context), DRE, UO_AddrOf,
    Context->getPointerType(DRE->getType()), VK_PRValue, OK_Ordinary,
    SourceLocation(), false, FPOptionsOverride());
CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, DerefExpr->getType(),
                                              CK_BitCast,
                                              DerefExpr);
ReplaceStmt(Exp, castExpr);
ProtocolExprDecls.insert(Exp->getProtocol()->getCanonicalDecl());
// delete Exp; leak for now, see RewritePropertyOrImplicitSetter() usage for more info.
return castExpr;
3056}

3058bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf,
                                           const char *endBuf) {
while (startBuf < endBuf) {
  if (*startBuf == '#') {
    // Skip whitespace.
    for (++startBuf; startBuf[0] == ' ' || startBuf[0] == '\t'; ++startBuf)
      ;
    if (!strncmp(startBuf, "if", strlen("if")) ||
        !strncmp(startBuf, "ifdef", strlen("ifdef")) ||
        !strncmp(startBuf, "ifndef", strlen("ifndef")) ||
        !strncmp(startBuf, "define", strlen("define")) ||
        !strncmp(startBuf, "undef", strlen("undef")) ||
        !strncmp(startBuf, "else", strlen("else")) ||
        !strncmp(startBuf, "elif", strlen("elif")) ||
        !strncmp(startBuf, "endif", strlen("endif")) ||
        !strncmp(startBuf, "pragma", strlen("pragma")) ||
        !strncmp(startBuf, "include", strlen("include")) ||
        !strncmp(startBuf, "import", strlen("import")) ||
        !strncmp(startBuf, "include_next", strlen("include_next")))
      return true;
  }
  startBuf++;
}
return false;
3082}

3084/// RewriteObjCInternalStruct - Rewrite one internal struct corresponding to
3085/// an objective-c class with ivars.
3086void RewriteObjC::RewriteObjCInternalStruct(ObjCInterfaceDecl *CDecl,
                                             std::string &Result) {
assert(CDecl && "Class missing in SynthesizeObjCInternalStruct")(static_cast<void> (0));
assert(CDecl->getName() != "" &&(static_cast<void> (0))
       "Name missing in SynthesizeObjCInternalStruct")(static_cast<void> (0));
// Do not synthesize more than once.
if (ObjCSynthesizedStructs.count(CDecl))
  return;
ObjCInterfaceDecl *RCDecl = CDecl->getSuperClass();
int NumIvars = CDecl->ivar_size();
SourceLocation LocStart = CDecl->getBeginLoc();
SourceLocation LocEnd = CDecl->getEndOfDefinitionLoc();

const char *startBuf = SM->getCharacterData(LocStart);
const char *endBuf = SM->getCharacterData(LocEnd);

// If no ivars and no root or if its root, directly or indirectly,
// have no ivars (thus not synthesized) then no need to synthesize this class.
if ((!CDecl->isThisDeclarationADefinition() || NumIvars == 0) &&
    (!RCDecl || !ObjCSynthesizedStructs.count(RCDecl))) {
  endBuf += Lexer::MeasureTokenLength(LocEnd, *SM, LangOpts);
  ReplaceText(LocStart, endBuf-startBuf, Result);
  return;
}

// FIXME: This has potential of causing problem. If
// SynthesizeObjCInternalStruct is ever called recursively.
Result += "\nstruct ";
Result += CDecl->getNameAsString();
if (LangOpts.MicrosoftExt)
  Result += "_IMPL";

if (NumIvars > 0) {
  const char *cursor = strchr(startBuf, '{');
  assert((cursor && endBuf)(static_cast<void> (0))
         && "SynthesizeObjCInternalStruct - malformed @interface")(static_cast<void> (0));
  // If the buffer contains preprocessor directives, we do more fine-grained
  // rewrites. This is intended to fix code that looks like (which occurs in
  // NSURL.h, for example):
  //
  // #ifdef XYZ
  // @interface Foo : NSObject
  // #else
  // @interface FooBar : NSObject
  // #endif
  // {
  //    int i;
  // }
  // @end
  //
  // This clause is segregated to avoid breaking the common case.
  if (BufferContainsPPDirectives(startBuf, cursor)) {
    SourceLocation L = RCDecl ? CDecl->getSuperClassLoc() :
                                CDecl->getAtStartLoc();
    const char *endHeader = SM->getCharacterData(L);
    endHeader += Lexer::MeasureTokenLength(L, *SM, LangOpts);

    if (CDecl->protocol_begin() != CDecl->protocol_end()) {
      // advance to the end of the referenced protocols.
      while (endHeader < cursor && *endHeader != '>') endHeader++;
      endHeader++;
    }
    // rewrite the original header
    ReplaceText(LocStart, endHeader-startBuf, Result);
  } else {
    // rewrite the original header *without* disturbing the '{'
    ReplaceText(LocStart, cursor-startBuf, Result);
  }
  if (RCDecl && ObjCSynthesizedStructs.count(RCDecl)) {
    Result = "\n    struct ";
    Result += RCDecl->getNameAsString();
    Result += "_IMPL ";
    Result += RCDecl->getNameAsString();
    Result += "_IVARS;\n";

    // insert the super class structure definition.
    SourceLocation OnePastCurly =
      LocStart.getLocWithOffset(cursor-startBuf+1);
    InsertText(OnePastCurly, Result);
  }
  cursor++; // past '{'

  // Now comment out any visibility specifiers.
  while (cursor < endBuf) {
    if (*cursor == '@') {
      SourceLocation atLoc = LocStart.getLocWithOffset(cursor-startBuf);
      // Skip whitespace.
      for (++cursor; cursor[0] == ' ' || cursor[0] == '\t'; ++cursor)
        /*scan*/;

      // FIXME: presence of @public, etc. inside comment results in
      // this transformation as well, which is still correct c-code.
      if (!strncmp(cursor, "public", strlen("public")) ||
          !strncmp(cursor, "private", strlen("private")) ||
          !strncmp(cursor, "package", strlen("package")) ||
          !strncmp(cursor, "protected", strlen("protected")))
        InsertText(atLoc, "// ");
    }
    // FIXME: If there are cases where '<' is used in ivar declaration part
    // of user code, then scan the ivar list and use needToScanForQualifiers
    // for type checking.
    else if (*cursor == '<') {
      SourceLocation atLoc = LocStart.getLocWithOffset(cursor-startBuf);
      InsertText(atLoc, "/* ");
      cursor = strchr(cursor, '>');
      cursor++;
      atLoc = LocStart.getLocWithOffset(cursor-startBuf);
      InsertText(atLoc, " */");
    } else if (*cursor == '^') { // rewrite block specifier.
      SourceLocation caretLoc = LocStart.getLocWithOffset(cursor-startBuf);
      ReplaceText(caretLoc, 1, "*");
    }
    cursor++;
  }
  // Don't forget to add a ';'!!
  InsertText(LocEnd.getLocWithOffset(1), ";");
} else { // we don't have any instance variables - insert super struct.
  endBuf += Lexer::MeasureTokenLength(LocEnd, *SM, LangOpts);
  Result += " {\n    struct ";
  Result += RCDecl->getNameAsString();
  Result += "_IMPL ";
  Result += RCDecl->getNameAsString();
  Result += "_IVARS;\n};\n";
  ReplaceText(LocStart, endBuf-startBuf, Result);
}
// Mark this struct as having been generated.
if (!ObjCSynthesizedStructs.insert(CDecl).second)
  llvm_unreachable("struct already synthesize- SynthesizeObjCInternalStruct")__builtin_unreachable();
3214}

3216//===----------------------------------------------------------------------===//
3217// Meta Data Emission
3218//===----------------------------------------------------------------------===//

3220/// RewriteImplementations - This routine rewrites all method implementations
3221/// and emits meta-data.

3223void RewriteObjC::RewriteImplementations() {
int ClsDefCount = ClassImplementation.size();
int CatDefCount = CategoryImplementation.size();

// Rewrite implemented methods
for (int i = 0; i < ClsDefCount; i++)
  RewriteImplementationDecl(ClassImplementation[i]);

for (int i = 0; i < CatDefCount; i++)
  RewriteImplementationDecl(CategoryImplementation[i]);
3233}

3235void RewriteObjC::RewriteByRefString(std::string &ResultStr,
                                   const std::string &Name,
                                   ValueDecl *VD, bool def) {
assert(BlockByRefDeclNo.count(VD) &&(static_cast<void> (0))
       "RewriteByRefString: ByRef decl missing")(static_cast<void> (0));
if (def)
  ResultStr += "struct ";
ResultStr += "__Block_byref_" + Name +
  "_" + utostr(BlockByRefDeclNo[VD]) ;
3244}

3246static bool HasLocalVariableExternalStorage(ValueDecl *VD) {
if (VarDecl *Var = dyn_cast<VarDecl>(VD))
  return (Var->isFunctionOrMethodVarDecl() && !Var->hasLocalStorage());
return false;
3250}

3252std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i,
                                                 StringRef funcName,
                                                 std::string Tag) {
const FunctionType *AFT = CE->getFunctionType();
QualType RT = AFT->getReturnType();
std::string StructRef = "struct " + Tag;
std::string S = "static " + RT.getAsString(Context->getPrintingPolicy()) + " __" +
                funcName.str() + "_" + "block_func_" + utostr(i);

BlockDecl *BD = CE->getBlockDecl();

if (isa<FunctionNoProtoType>(AFT)) {
  // No user-supplied arguments. Still need to pass in a pointer to the
  // block (to reference imported block decl refs).
  S += "(" + StructRef + " *__cself)";
} else if (BD->param_empty()) {
  S += "(" + StructRef + " *__cself)";
} else {
  const FunctionProtoType *FT = cast<FunctionProtoType>(AFT);
  assert(FT && "SynthesizeBlockFunc: No function proto")(static_cast<void> (0));
  S += '(';
  // first add the implicit argument.
  S += StructRef + " *__cself, ";
  std::string ParamStr;
  for (BlockDecl::param_iterator AI = BD->param_begin(),
       E = BD->param_end(); AI != E; ++AI) {
    if (AI != BD->param_begin()) S += ", ";
    ParamStr = (*AI)->getNameAsString();
    QualType QT = (*AI)->getType();
    (void)convertBlockPointerToFunctionPointer(QT);
    QT.getAsStringInternal(ParamStr, Context->getPrintingPolicy());
    S += ParamStr;
  }
  if (FT->isVariadic()) {
    if (!BD->param_empty()) S += ", ";
    S += "...";
  }
  S += ')';
}
S += " {\n";

// Create local declarations to avoid rewriting all closure decl ref exprs.
// First, emit a declaration for all "by ref" decls.
for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
     E = BlockByRefDecls.end(); I != E; ++I) {
  S += "  ";
  std::string Name = (*I)->getNameAsString();
  std::string TypeString;
  RewriteByRefString(TypeString, Name, (*I));
  TypeString += " *";
  Name = TypeString + Name;
  S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n";
}
// Next, emit a declaration for all "by copy" declarations.
for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
     E = BlockByCopyDecls.end(); I != E; ++I) {
  S += "  ";
  // Handle nested closure invocation. For example:
  //
  //   void (^myImportedClosure)(void);
  //   myImportedClosure  = ^(void) { setGlobalInt(x + y); };
  //
  //   void (^anotherClosure)(void);
  //   anotherClosure = ^(void) {
  //     myImportedClosure(); // import and invoke the closure
  //   };
  //
  if (isTopLevelBlockPointerType((*I)->getType())) {
    RewriteBlockPointerTypeVariable(S, (*I));
    S += " = (";
    RewriteBlockPointerType(S, (*I)->getType());
    S += ")";
    S += "__cself->" + (*I)->getNameAsString() + "; // bound by copy\n";
  }
  else {
    std::string Name = (*I)->getNameAsString();
    QualType QT = (*I)->getType();
    if (HasLocalVariableExternalStorage(*I))
      QT = Context->getPointerType(QT);
    QT.getAsStringInternal(Name, Context->getPrintingPolicy());
    S += Name + " = __cself->" +
                            (*I)->getNameAsString() + "; // bound by copy\n";
  }
}
std::string RewrittenStr = RewrittenBlockExprs[CE];
const char *cstr = RewrittenStr.c_str();
while (*cstr++ != '{') ;
S += cstr;
S += "\n";
return S;
3342}

3344std::string RewriteObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
                                                 StringRef funcName,
                                                 std::string Tag) {
std::string StructRef = "struct " + Tag;
std::string S = "static void __";

S += funcName;
S += "_block_copy_" + utostr(i);
S += "(" + StructRef;
S += "*dst, " + StructRef;
S += "*src) {";
for (ValueDecl *VD : ImportedBlockDecls) {
  S += "_Block_object_assign((void*)&dst->";
  S += VD->getNameAsString();
  S += ", (void*)src->";
  S += VD->getNameAsString();
  if (BlockByRefDeclsPtrSet.count(VD))
    S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
  else if (VD->getType()->isBlockPointerType())
    S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
  else
    S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
}
S += "}\n";

S += "\nstatic void __";
S += funcName;
S += "_block_dispose_" + utostr(i);
S += "(" + StructRef;
S += "*src) {";
for (ValueDecl *VD : ImportedBlockDecls) {
  S += "_Block_object_dispose((void*)src->";
  S += VD->getNameAsString();
  if (BlockByRefDeclsPtrSet.count(VD))
    S += ", " + utostr(BLOCK_FIELD_IS_BYREF) + "/*BLOCK_FIELD_IS_BYREF*/);";
  else if (VD->getType()->isBlockPointerType())
    S += ", " + utostr(BLOCK_FIELD_IS_BLOCK) + "/*BLOCK_FIELD_IS_BLOCK*/);";
  else
    S += ", " + utostr(BLOCK_FIELD_IS_OBJECT) + "/*BLOCK_FIELD_IS_OBJECT*/);";
}
S += "}\n";
return S;
3386}

3388std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag,
                                           std::string Desc) {
std::string S = "\nstruct " + Tag;
std::string Constructor = "  " + Tag;

S += " {\n  struct __block_impl impl;\n";
S += "  struct " + Desc;
S += "* Desc;\n";

Constructor += "(void *fp, "; // Invoke function pointer.
Constructor += "struct " + Desc; // Descriptor pointer.
Constructor += " *desc";

if (BlockDeclRefs.size()) {
  // Output all "by copy" declarations.
  for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
       E = BlockByCopyDecls.end(); I != E; ++I) {
    S += "  ";
    std::string FieldName = (*I)->getNameAsString();
    std::string ArgName = "_" + FieldName;
    // Handle nested closure invocation. For example:
    //
    //   void (^myImportedBlock)(void);
    //   myImportedBlock  = ^(void) { setGlobalInt(x + y); };
    //
    //   void (^anotherBlock)(void);
    //   anotherBlock = ^(void) {
    //     myImportedBlock(); // import and invoke the closure
    //   };
    //
    if (isTopLevelBlockPointerType((*I)->getType())) {
      S += "struct __block_impl *";
      Constructor += ", void *" + ArgName;
    } else {
      QualType QT = (*I)->getType();
      if (HasLocalVariableExternalStorage(*I))
        QT = Context->getPointerType(QT);
      QT.getAsStringInternal(FieldName, Context->getPrintingPolicy());
      QT.getAsStringInternal(ArgName, Context->getPrintingPolicy());
      Constructor += ", " + ArgName;
    }
    S += FieldName + ";\n";
  }
  // Output all "by ref" declarations.
  for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
       E = BlockByRefDecls.end(); I != E; ++I) {
    S += "  ";
    std::string FieldName = (*I)->getNameAsString();
    std::string ArgName = "_" + FieldName;
    {
      std::string TypeString;
      RewriteByRefString(TypeString, FieldName, (*I));
      TypeString += " *";
      FieldName = TypeString + FieldName;
      ArgName = TypeString + ArgName;
      Constructor += ", " + ArgName;
    }
    S += FieldName + "; // by ref\n";
  }
  // Finish writing the constructor.
  Constructor += ", int flags=0)";
  // Initialize all "by copy" arguments.
  bool firsTime = true;
  for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(),
       E = BlockByCopyDecls.end(); I != E; ++I) {
    std::string Name = (*I)->getNameAsString();
      if (firsTime) {
        Constructor += " : ";
        firsTime = false;
      }
      else
        Constructor += ", ";
      if (isTopLevelBlockPointerType((*I)->getType()))
        Constructor += Name + "((struct __block_impl *)_" + Name + ")";
      else
        Constructor += Name + "(_" + Name + ")";
  }
  // Initialize all "by ref" arguments.
  for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(),
       E = BlockByRefDecls.end(); I != E; ++I) {
    std::string Name = (*I)->getNameAsString();
    if (firsTime) {
      Constructor += " : ";
      firsTime = false;
    }
    else
      Constructor += ", ";
    Constructor += Name + "(_" + Name + "->__forwarding)";
  }

  Constructor += " {\n";
  if (GlobalVarDecl)
    Constructor += "    impl.isa = &_NSConcreteGlobalBlock;\n";
  else
    Constructor += "    impl.isa = &_NSConcreteStackBlock;\n";
  Constructor += "    impl.Flags = flags;\n    impl.FuncPtr = fp;\n";

  Constructor += "    Desc = desc;\n";
} else {
  // Finish writing the constructor.
  Constructor += ", int flags=0) {\n";
  if (GlobalVarDecl)
    Constructor += "    impl.isa = &_NSConcreteGlobalBlock;\n";
  else
    Constructor += "    impl.isa = &_NSConcreteStackBlock;\n";
  Constructor += "    impl.Flags = flags;\n    impl.FuncPtr = fp;\n";
  Constructor += "    Desc = desc;\n";
}
Constructor += "  ";
Constructor += "}\n";
S += Constructor;
S += "};\n";
return S;
3501}

3503std::string RewriteObjC::SynthesizeBlockDescriptor(std::string DescTag,
                                                 std::string ImplTag, int i,
                                                 StringRef FunName,
                                                 unsigned hasCopy) {
std::string S = "\nstatic struct " + DescTag;

S += " {\n  unsigned long reserved;\n";
S += "  unsigned long Block_size;\n";
if (hasCopy) {
  S += "  void (*copy)(struct ";
  S += ImplTag; S += "*, struct ";
  S += ImplTag; S += "*);\n";

  S += "  void (*dispose)(struct ";
  S += ImplTag; S += "*);\n";
}
S += "} ";

S += DescTag + "_DATA = { 0, sizeof(struct ";
S += ImplTag + ")";
if (hasCopy) {
  S += ", __" + FunName.str() + "_block_copy_" + utostr(i);
  S += ", __" + FunName.str() + "_block_dispose_" + utostr(i);
}
S += "};\n";
return S;
3529}

3531void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart,
                                        StringRef FunName) {
// Insert declaration for the function in which block literal is used.
if (CurFunctionDeclToDeclareForBlock && !Blocks.empty())
  RewriteBlockLiteralFunctionDecl(CurFunctionDeclToDeclareForBlock);
bool RewriteSC = (GlobalVarDecl &&
                  !Blocks.empty() &&
                  GlobalVarDecl->getStorageClass() == SC_Static &&
                  GlobalVarDecl->getType().getCVRQualifiers());
if (RewriteSC) {
  std::string SC(" void __");
  SC += GlobalVarDecl->getNameAsString();
  SC += "() {}";
  InsertText(FunLocStart, SC);
}

// Insert closures that were part of the function.
for (unsigned i = 0, count=0; i < Blocks.size(); i++) {
  CollectBlockDeclRefInfo(Blocks[i]);
  // Need to copy-in the inner copied-in variables not actually used in this
  // block.
  for (int j = 0; j < InnerDeclRefsCount[i]; j++) {
    DeclRefExpr *Exp = InnerDeclRefs[count++];
    ValueDecl *VD = Exp->getDecl();
    BlockDeclRefs.push_back(Exp);
    if (!VD->hasAttr<BlocksAttr>() && !BlockByCopyDeclsPtrSet.count(VD)) {
      BlockByCopyDeclsPtrSet.insert(VD);
      BlockByCopyDecls.push_back(VD);
    }
    if (VD->hasAttr<BlocksAttr>() && !BlockByRefDeclsPtrSet.count(VD)) {
      BlockByRefDeclsPtrSet.insert(VD);
      BlockByRefDecls.push_back(VD);
    }
    // imported objects in the inner blocks not used in the outer
    // blocks must be copied/disposed in the outer block as well.
    if (VD->hasAttr<BlocksAttr>() ||
        VD->getType()->isObjCObjectPointerType() ||
        VD->getType()->isBlockPointerType())
      ImportedBlockDecls.insert(VD);
  }

  std::string ImplTag = "__" + FunName.str() + "_block_impl_" + utostr(i);
  std::string DescTag = "__" + FunName.str() + "_block_desc_" + utostr(i);

  std::string CI = SynthesizeBlockImpl(Blocks[i], ImplTag, DescTag);

  InsertText(FunLocStart, CI);

  std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, ImplTag);

  InsertText(FunLocStart, CF);

  if (ImportedBlockDecls.size()) {
    std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, ImplTag);
    InsertText(FunLocStart, HF);
  }
  std::string BD = SynthesizeBlockDescriptor(DescTag, ImplTag, i, FunName,
                                             ImportedBlockDecls.size() > 0);
  InsertText(FunLocStart, BD);

  BlockDeclRefs.clear();
  BlockByRefDecls.clear();
  BlockByRefDeclsPtrSet.clear();
  BlockByCopyDecls.clear();
  BlockByCopyDeclsPtrSet.clear();
  ImportedBlockDecls.clear();
}
if (RewriteSC) {
  // Must insert any 'const/volatile/static here. Since it has been
  // removed as result of rewriting of block literals.
  std::string SC;
  if (GlobalVarDecl->getStorageClass() == SC_Static)
    SC = "static ";
  if (GlobalVarDecl->getType().isConstQualified())
    SC += "const ";
  if (GlobalVarDecl->getType().isVolatileQualified())
    SC += "volatile ";
  if (GlobalVarDecl->getType().isRestrictQualified())
    SC += "restrict ";
  InsertText(FunLocStart, SC);
}

Blocks.clear();
InnerDeclRefsCount.clear();
InnerDeclRefs.clear();
RewrittenBlockExprs.clear();
3617}

3619void RewriteObjC::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) {
SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
StringRef FuncName = FD->getName();

SynthesizeBlockLiterals(FunLocStart, FuncName);
3624}

3626static void BuildUniqueMethodName(std::string &Name,
                                ObjCMethodDecl *MD) {
ObjCInterfaceDecl *IFace = MD->getClassInterface();
Name = std::string(IFace->getName());
Name += "__" + MD->getSelector().getAsString();
// Convert colons to underscores.
std::string::size_type loc = 0;
while ((loc = Name.find(':', loc)) != std::string::npos)
  Name.replace(loc, 1, "_");
3635}

3637void RewriteObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) {
// fprintf(stderr,"In InsertBlockLiteralsWitinMethod\n");
// SourceLocation FunLocStart = MD->getBeginLoc();
SourceLocation FunLocStart = MD->getBeginLoc();
std::string FuncName;
BuildUniqueMethodName(FuncName, MD);
SynthesizeBlockLiterals(FunLocStart, FuncName);
3644}

3646void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) {
for (Stmt *SubStmt : S->children())
  if (SubStmt) {
    if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt))
      GetBlockDeclRefExprs(CBE->getBody());
    else
      GetBlockDeclRefExprs(SubStmt);
  }
// Handle specific things.
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S))
  if (DRE->refersToEnclosingVariableOrCapture() ||
      HasLocalVariableExternalStorage(DRE->getDecl()))
    // FIXME: Handle enums.
    BlockDeclRefs.push_back(DRE);
3660}

3662void RewriteObjC::GetInnerBlockDeclRefExprs(Stmt *S,
              SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs,
              llvm::SmallPtrSetImpl<const DeclContext *> &InnerContexts) {
for (Stmt *SubStmt : S->children())
  if (SubStmt) {
    if (BlockExpr *CBE = dyn_cast<BlockExpr>(SubStmt)) {
      InnerContexts.insert(cast<DeclContext>(CBE->getBlockDecl()));
      GetInnerBlockDeclRefExprs(CBE->getBody(),
                                InnerBlockDeclRefs,
                                InnerContexts);
    }
    else
      GetInnerBlockDeclRefExprs(SubStmt, InnerBlockDeclRefs, InnerContexts);
  }
// Handle specific things.
if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(S)) {
  if (DRE->refersToEnclosingVariableOrCapture() ||
      HasLocalVariableExternalStorage(DRE->getDecl())) {
    if (!InnerContexts.count(DRE->getDecl()->getDeclContext()))
      InnerBlockDeclRefs.push_back(DRE);
    if (VarDecl *Var = cast<VarDecl>(DRE->getDecl()))
      if (Var->isFunctionOrMethodVarDecl())
        ImportedLocalExternalDecls.insert(Var);
  }
}
3687}

3689/// convertFunctionTypeOfBlocks - This routine converts a function type
3690/// whose result type may be a block pointer or whose argument type(s)
3691/// might be block pointers to an equivalent function type replacing
3692/// all block pointers to function pointers.
3693QualType RewriteObjC::convertFunctionTypeOfBlocks(const FunctionType *FT) {
const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT);
// FTP will be null for closures that don't take arguments.
// Generate a funky cast.
SmallVector<QualType, 8> ArgTypes;
QualType Res = FT->getReturnType();
bool HasBlockType = convertBlockPointerToFunctionPointer(Res);

if (FTP) {
  for (auto &I : FTP->param_types()) {
    QualType t = I;
    // Make sure we convert "t (^)(...)" to "t (*)(...)".
    if (convertBlockPointerToFunctionPointer(t))
      HasBlockType = true;
    ArgTypes.push_back(t);
  }
}
QualType FuncType;
// FIXME. Does this work if block takes no argument but has a return type
// which is of block type?
if (HasBlockType)
  FuncType = getSimpleFunctionType(Res, ArgTypes);
else FuncType = QualType(FT, 0);
return FuncType;
3717}

3719Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp, const Expr *BlockExp) {
// Navigate to relevant type information.
const BlockPointerType *CPT = nullptr;
53
←
'CPT' initialized to a null pointer value→

if (const DeclRefExpr *DRE54.1
'DRE' is null
 = dyn_cast<DeclRefExpr>(BlockExp)) {
54
←
Assuming 'BlockExp' is not a 'DeclRefExpr'→
55
←
Taking false branch→
  CPT = DRE->getType()->getAs<BlockPointerType>();
} else if (const MemberExpr *MExpr56.1
'MExpr' is null
 = dyn_cast<MemberExpr>(BlockExp)) {
56
←
Assuming 'BlockExp' is not a 'MemberExpr'→
57
←
Taking false branch→
  CPT = MExpr->getType()->getAs<BlockPointerType>();
}
else if (const ParenExpr *PRE58.1
'PRE' is null
 = dyn_cast<ParenExpr>(BlockExp)) {
58
←
Assuming 'BlockExp' is not a 'ParenExpr'→
59
←
Taking false branch→
  return SynthesizeBlockCall(Exp, PRE->getSubExpr());
}
else if (const ImplicitCastExpr *IEXPR60.1
'IEXPR' is null
 = dyn_cast<ImplicitCastExpr>(BlockExp))
60
←
Assuming 'BlockExp' is not a 'ImplicitCastExpr'→
61
←
Taking false branch→
  CPT = IEXPR->getType()->getAs<BlockPointerType>();
else if (const ConditionalOperator *CEXPR62.1
'CEXPR' is null
 =
63
←
Taking false branch→
          dyn_cast<ConditionalOperator>(BlockExp)) {
62
←
Assuming 'BlockExp' is not a 'ConditionalOperator'→
  Expr *LHSExp = CEXPR->getLHS();
  Stmt *LHSStmt = SynthesizeBlockCall(Exp, LHSExp);
  Expr *RHSExp = CEXPR->getRHS();
  Stmt *RHSStmt = SynthesizeBlockCall(Exp, RHSExp);
  Expr *CONDExp = CEXPR->getCond();
  ConditionalOperator *CondExpr = new (Context) ConditionalOperator(
      CONDExp, SourceLocation(), cast<Expr>(LHSStmt), SourceLocation(),
      cast<Expr>(RHSStmt), Exp->getType(), VK_PRValue, OK_Ordinary);
  return CondExpr;
} else if (const ObjCIvarRefExpr *IRE64.1
'IRE' is null
 = dyn_cast<ObjCIvarRefExpr>(BlockExp)) {
64
←
Assuming 'BlockExp' is not a 'ObjCIvarRefExpr'→
65
←
Taking false branch→
  CPT = IRE->getType()->getAs<BlockPointerType>();
} else if (const PseudoObjectExpr *POE

66.1	'POE' is null

←

Taking false branch

→

3747 = dyn_cast<PseudoObjectExpr>(BlockExp)) {

←

Assuming 'BlockExp' is not a 'PseudoObjectExpr'

→

3748 CPT = POE->getType()->castAs<BlockPointerType>(); 3749 } else { 3750 assert(false && "RewriteBlockClass: Bad type")(static_cast<void> (0)); 3751 } 3752 assert(CPT && "RewriteBlockClass: Bad type")(static_cast<void> (0)); 3753 const FunctionType *FT = CPT->getPointeeType()->getAs<FunctionType>();

←

Called C++ object pointer is null

3754 assert(FT && "RewriteBlockClass: Bad type")(static_cast<void> (0)); 3755 const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(FT); 3756 // FTP will be null for closures that don't take arguments. 3757 3758 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl, 3759 SourceLocation(), SourceLocation(), 3760 &Context->Idents.get("__block_impl")); 3761 QualType PtrBlock = Context->getPointerType(Context->getTagDeclType(RD)); 3762 3763 // Generate a funky cast. 3764 SmallVector<QualType, 8> ArgTypes; 3765 3766 // Push the block argument type. 3767 ArgTypes.push_back(PtrBlock); 3768 if (FTP) { 3769 for (auto &I : FTP->param_types()) { 3770 QualType t = I; 3771 // Make sure we convert "t (^)(...)" to "t (*)(...)". 3772 if (!convertBlockPointerToFunctionPointer(t)) 3773 convertToUnqualifiedObjCType(t); 3774 ArgTypes.push_back(t); 3775 } 3776 } 3777 // Now do the pointer to function cast. 3778 QualType PtrToFuncCastType = getSimpleFunctionType(Exp->getType(), ArgTypes); 3779 3780 PtrToFuncCastType = Context->getPointerType(PtrToFuncCastType); 3781 3782 CastExpr *BlkCast = NoTypeInfoCStyleCastExpr(Context, PtrBlock, 3783 CK_BitCast, 3784 const_cast<Expr*>(BlockExp)); 3785 // Don't forget the parens to enforce the proper binding. 3786 ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), 3787 BlkCast); 3788 //PE->dump(); 3789 3790 FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), 3791 SourceLocation(), 3792 &Context->Idents.get("FuncPtr"), 3793 Context->VoidPtrTy, nullptr, 3794 /*BitWidth=*/nullptr, /*Mutable=*/true, 3795 ICIS_NoInit); 3796 MemberExpr *ME = MemberExpr::CreateImplicit( 3797 *Context, PE, true, FD, FD->getType(), VK_LValue, OK_Ordinary); 3798 3799 CastExpr *FunkCast = NoTypeInfoCStyleCastExpr(Context, PtrToFuncCastType, 3800 CK_BitCast, ME); 3801 PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), FunkCast); 3802 3803 SmallVector<Expr*, 8> BlkExprs; 3804 // Add the implicit argument. 3805 BlkExprs.push_back(BlkCast); 3806 // Add the user arguments. 3807 for (CallExpr::arg_iterator I = Exp->arg_begin(), 3808 E = Exp->arg_end(); I != E; ++I) { 3809 BlkExprs.push_back(*I); 3810 } 3811 CallExpr *CE = 3812 CallExpr::Create(*Context, PE, BlkExprs, Exp->getType(), VK_PRValue, 3813 SourceLocation(), FPOptionsOverride()); 3814 return CE; 3815} 3816 3817// We need to return the rewritten expression to handle cases where the 3818// BlockDeclRefExpr is embedded in another expression being rewritten. 3819// For example: 3820// 3821// int main() { 3822// __block Foo *f; 3823// __block int i; 3824// 3825// void (^myblock)() = ^() { 3826// [f test]; // f is a BlockDeclRefExpr embedded in a message (which is being rewritten). 3827// i = 77; 3828// }; 3829//} 3830Stmt *RewriteObjC::RewriteBlockDeclRefExpr(DeclRefExpr *DeclRefExp) { 3831 // Rewrite the byref variable into BYREFVAR->__forwarding->BYREFVAR 3832 // for each DeclRefExp where BYREFVAR is name of the variable. 3833 ValueDecl *VD = DeclRefExp->getDecl(); 3834 bool isArrow = DeclRefExp->refersToEnclosingVariableOrCapture() || 3835 HasLocalVariableExternalStorage(DeclRefExp->getDecl()); 3836 3837 FieldDecl *FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), 3838 SourceLocation(), 3839 &Context->Idents.get("__forwarding"), 3840 Context->VoidPtrTy, nullptr, 3841 /*BitWidth=*/nullptr, /*Mutable=*/true, 3842 ICIS_NoInit); 3843 MemberExpr *ME = 3844 MemberExpr::CreateImplicit(*Context, DeclRefExp, isArrow, FD, 3845 FD->getType(), VK_LValue, OK_Ordinary); 3846 3847 StringRef Name = VD->getName(); 3848 FD = FieldDecl::Create(*Context, nullptr, SourceLocation(), SourceLocation(), 3849 &Context->Idents.get(Name), 3850 Context->VoidPtrTy, nullptr, 3851 /*BitWidth=*/nullptr, /*Mutable=*/true, 3852 ICIS_NoInit); 3853 ME = MemberExpr::CreateImplicit(*Context, ME, true, FD, DeclRefExp->getType(), 3854 VK_LValue, OK_Ordinary); 3855 3856 // Need parens to enforce precedence. 3857 ParenExpr *PE = new (Context) ParenExpr(DeclRefExp->getExprLoc(), 3858 DeclRefExp->getExprLoc(), 3859 ME); 3860 ReplaceStmt(DeclRefExp, PE); 3861 return PE; 3862} 3863 3864// Rewrites the imported local variable V with external storage 3865// (static, extern, etc.) as *V 3866// 3867Stmt *RewriteObjC::RewriteLocalVariableExternalStorage(DeclRefExpr *DRE) { 3868 ValueDecl *VD = DRE->getDecl(); 3869 if (VarDecl *Var = dyn_cast<VarDecl>(VD)) 3870 if (!ImportedLocalExternalDecls.count(Var)) 3871 return DRE; 3872 Expr *Exp = UnaryOperator::Create( 3873 const_cast<ASTContext &>(*Context), DRE, UO_Deref, DRE->getType(), 3874 VK_LValue, OK_Ordinary, DRE->getLocation(), false, FPOptionsOverride()); 3875 // Need parens to enforce precedence. 3876 ParenExpr *PE = new (Context) ParenExpr(SourceLocation(), SourceLocation(), 3877 Exp); 3878 ReplaceStmt(DRE, PE); 3879 return PE; 3880} 3881 3882void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) { 3883 SourceLocation LocStart = CE->getLParenLoc(); 3884 SourceLocation LocEnd = CE->getRParenLoc(); 3885 3886 // Need to avoid trying to rewrite synthesized casts. 3887 if (LocStart.isInvalid()) 3888 return; 3889 // Need to avoid trying to rewrite casts contained in macros. 3890 if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd)) 3891 return; 3892 3893 const char *startBuf = SM->getCharacterData(LocStart); 3894 const char *endBuf = SM->getCharacterData(LocEnd); 3895 QualType QT = CE->getType(); 3896 const Type* TypePtr = QT->getAs<Type>(); 3897 if (isa<TypeOfExprType>(TypePtr)) { 3898 const TypeOfExprType *TypeOfExprTypePtr = cast<TypeOfExprType>(TypePtr); 3899 QT = TypeOfExprTypePtr->getUnderlyingExpr()->getType(); 3900 std::string TypeAsString = "("; 3901 RewriteBlockPointerType(TypeAsString, QT); 3902 TypeAsString += ")"; 3903 ReplaceText(LocStart, endBuf-startBuf+1, TypeAsString); 3904 return; 3905 } 3906 // advance the location to startArgList. 3907 const char *argPtr = startBuf; 3908 3909 while (*argPtr++ && (argPtr < endBuf)) { 3910 switch (*argPtr) { 3911 case '^': 3912 // Replace the '^' with '*'. 3913 LocStart = LocStart.getLocWithOffset(argPtr-startBuf); 3914 ReplaceText(LocStart, 1, "*"); 3915 break; 3916 } 3917 } 3918} 3919 3920void RewriteObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) { 3921 SourceLocation DeclLoc = FD->getLocation(); 3922 unsigned parenCount = 0; 3923 3924 // We have 1 or more arguments that have closure pointers. 3925 const char *startBuf = SM->getCharacterData(DeclLoc); 3926 const char *startArgList = strchr(startBuf, '('); 3927 3928 assert((*startArgList == '(') && "Rewriter fuzzy parser confused")(static_cast<void> (0)); 3929 3930 parenCount++; 3931 // advance the location to startArgList. 3932 DeclLoc = DeclLoc.getLocWithOffset(startArgList-startBuf); 3933 assert((DeclLoc.isValid()) && "Invalid DeclLoc")(static_cast<void> (0)); 3934 3935 const char *argPtr = startArgList; 3936 3937 while (*argPtr++ && parenCount) { 3938 switch (*argPtr) { 3939 case '^': 3940 // Replace the '^' with '*'. 3941 DeclLoc = DeclLoc.getLocWithOffset(argPtr-startArgList); 3942 ReplaceText(DeclLoc, 1, "*"); 3943 break; 3944 case '(': 3945 parenCount++; 3946 break; 3947 case ')': 3948 parenCount--; 3949 break; 3950 } 3951 } 3952} 3953 3954bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) { 3955 const FunctionProtoType *FTP; 3956 const PointerType *PT = QT->getAs<PointerType>(); 3957 if (PT) { 3958 FTP = PT->getPointeeType()->getAs<FunctionProtoType>(); 3959 } else { 3960 const BlockPointerType *BPT = QT->getAs<BlockPointerType>(); 3961 assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type")(static_cast<void> (0)); 3962 FTP = BPT->getPointeeType()->getAs<FunctionProtoType>(); 3963 } 3964 if (FTP) { 3965 for (const auto &I : FTP->param_types()) 3966 if (isTopLevelBlockPointerType(I)) 3967 return true; 3968 } 3969 return false; 3970} 3971 3972bool RewriteObjC::PointerTypeTakesAnyObjCQualifiedType(QualType QT) { 3973 const FunctionProtoType *FTP; 3974 const PointerType *PT = QT->getAs<PointerType>(); 3975 if (PT) { 3976 FTP = PT->getPointeeType()->getAs<FunctionProtoType>(); 3977 } else { 3978 const BlockPointerType *BPT = QT->getAs<BlockPointerType>(); 3979 assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type")(static_cast<void> (0)); 3980 FTP = BPT->getPointeeType()->getAs<FunctionProtoType>(); 3981 } 3982 if (FTP) { 3983 for (const auto &I : FTP->param_types()) { 3984 if (I->isObjCQualifiedIdType()) 3985 return true; 3986 if (I->isObjCObjectPointerType() && 3987 I->getPointeeType()->isObjCQualifiedInterfaceType()) 3988 return true; 3989 } 3990 3991 } 3992 return false; 3993} 3994 3995void RewriteObjC::GetExtentOfArgList(const char *Name, const char *&LParen, 3996 const char *&RParen) { 3997 const char *argPtr = strchr(Name, '('); 3998 assert((*argPtr == '(') && "Rewriter fuzzy parser confused")(static_cast<void> (0)); 3999 4000 LParen = argPtr; // output the start. 4001 argPtr++; // skip past the left paren. 4002 unsigned parenCount = 1; 4003 4004 while (*argPtr && parenCount) { 4005 switch (*argPtr) { 4006 case '(': parenCount++; break; 4007 case ')': parenCount--; break; 4008 default: break; 4009 } 4010 if (parenCount) argPtr++; 4011 } 4012 assert((*argPtr == ')') && "Rewriter fuzzy parser confused")(static_cast<void> (0)); 4013 RParen = argPtr; // output the end 4014} 4015 4016void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) { 4017 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 4018 RewriteBlockPointerFunctionArgs(FD); 4019 return; 4020 } 4021 // Handle Variables and Typedefs. 4022 SourceLocation DeclLoc = ND->getLocation(); 4023 QualType DeclT; 4024 if (VarDecl *VD = dyn_cast<VarDecl>(ND)) 4025 DeclT = VD->getType(); 4026 else if (TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(ND)) 4027 DeclT = TDD->getUnderlyingType(); 4028 else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND)) 4029 DeclT = FD->getType(); 4030 else 4031 llvm_unreachable("RewriteBlockPointerDecl(): Decl type not yet handled")__builtin_unreachable(); 4032 4033 const char *startBuf = SM->getCharacterData(DeclLoc); 4034 const char *endBuf = startBuf; 4035 // scan backward (from the decl location) for the end of the previous decl. 4036 while (*startBuf != '^' && *startBuf != ';' && startBuf != MainFileStart) 4037 startBuf--; 4038 SourceLocation Start = DeclLoc.getLocWithOffset(startBuf-endBuf); 4039 std::string buf; 4040 unsigned OrigLength=0; 4041 // *startBuf != '^' if we are dealing with a pointer to function that 4042 // may take block argument types (which will be handled below). 4043 if (*startBuf == '^') { 4044 // Replace the '^' with '*', computing a negative offset. 4045 buf = '*'; 4046 startBuf++; 4047 OrigLength++; 4048 } 4049 while (*startBuf != ')') { 4050 buf += *startBuf; 4051 startBuf++; 4052 OrigLength++; 4053 } 4054 buf += ')'; 4055 OrigLength++; 4056 4057 if (PointerTypeTakesAnyBlockArguments(DeclT) || 4058 PointerTypeTakesAnyObjCQualifiedType(DeclT)) { 4059 // Replace the '^' with '*' for arguments. 4060 // Replace id<P> with id/*<>*/ 4061 DeclLoc = ND->getLocation(); 4062 startBuf = SM->getCharacterData(DeclLoc); 4063 const char *argListBegin, *argListEnd; 4064 GetExtentOfArgList(startBuf, argListBegin, argListEnd); 4065 while (argListBegin < argListEnd) { 4066 if (*argListBegin == '^') 4067 buf += '*'; 4068 else if (*argListBegin == '<') { 4069 buf += "/*"; 4070 buf += *argListBegin++; 4071 OrigLength++; 4072 while (*argListBegin != '>') { 4073 buf += *argListBegin++; 4074 OrigLength++; 4075 } 4076 buf += *argListBegin; 4077 buf += "*/"; 4078 } 4079 else 4080 buf += *argListBegin; 4081 argListBegin++; 4082 OrigLength++; 4083 } 4084 buf += ')'; 4085 OrigLength++; 4086 } 4087 ReplaceText(Start, OrigLength, buf); 4088} 4089 4090/// SynthesizeByrefCopyDestroyHelper - This routine synthesizes: 4091/// void __Block_byref_id_object_copy(struct Block_byref_id_object *dst, 4092/// struct Block_byref_id_object *src) { 4093/// _Block_object_assign (&_dest->object, _src->object, 4094/// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT 4095/// [|BLOCK_FIELD_IS_WEAK]) // object 4096/// _Block_object_assign(&_dest->object, _src->object, 4097/// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK 4098/// [|BLOCK_FIELD_IS_WEAK]) // block 4099/// } 4100/// And: 4101/// void __Block_byref_id_object_dispose(struct Block_byref_id_object *_src) { 4102/// _Block_object_dispose(_src->object, 4103/// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_OBJECT 4104/// [|BLOCK_FIELD_IS_WEAK]) // object 4105/// _Block_object_dispose(_src->object, 4106/// BLOCK_BYREF_CALLER | BLOCK_FIELD_IS_BLOCK 4107/// [|BLOCK_FIELD_IS_WEAK]) // block 4108/// } 4109 4110std::string RewriteObjC::SynthesizeByrefCopyDestroyHelper(VarDecl *VD, 4111 int flag) { 4112 std::string S; 4113 if (CopyDestroyCache.count(flag)) 4114 return S; 4115 CopyDestroyCache.insert(flag); 4116 S = "static void __Block_byref_id_object_copy_"; 4117 S += utostr(flag); 4118 S += "(void *dst, void *src) {\n"; 4119 4120 // offset into the object pointer is computed as: 4121 // void * + void* + int + int + void* + void * 4122 unsigned IntSize = 4123 static_cast<unsigned>(Context->getTypeSize(Context->IntTy)); 4124 unsigned VoidPtrSize = 4125 static_cast<unsigned>(Context->getTypeSize(Context->VoidPtrTy)); 4126 4127 unsigned offset = (VoidPtrSize*4 + IntSize + IntSize)/Context->getCharWidth(); 4128 S += " _Block_object_assign((char*)dst + "; 4129 S += utostr(offset); 4130 S += ", *(void * *) ((char*)src + "; 4131 S += utostr(offset); 4132 S += "), "; 4133 S += utostr(flag); 4134 S += ");\n}\n"; 4135 4136 S += "static void __Block_byref_id_object_dispose_"; 4137 S += utostr(flag); 4138 S += "(void *src) {\n"; 4139 S += " _Block_object_dispose(*(void * *) ((char*)src + "; 4140 S += utostr(offset); 4141 S += "), "; 4142 S += utostr(flag); 4143 S += ");\n}\n"; 4144 return S; 4145} 4146 4147/// RewriteByRefVar - For each __block typex ND variable this routine transforms 4148/// the declaration into: 4149/// struct __Block_byref_ND { 4150/// void *__isa; // NULL for everything except __weak pointers 4151/// struct __Block_byref_ND *__forwarding; 4152/// int32_t __flags; 4153/// int32_t __size; 4154/// void *__Block_byref_id_object_copy; // If variable is __block ObjC object 4155/// void *__Block_byref_id_object_dispose; // If variable is __block ObjC object 4156/// typex ND; 4157/// }; 4158/// 4159/// It then replaces declaration of ND variable with: 4160/// struct __Block_byref_ND ND = {__isa=0B, __forwarding=&ND, __flags=some_flag, 4161/// __size=sizeof(struct __Block_byref_ND), 4162/// ND=initializer-if-any}; 4163/// 4164/// 4165void RewriteObjC::RewriteByRefVar(VarDecl *ND) { 4166 // Insert declaration for the function in which block literal is 4167 // used. 4168 if (CurFunctionDeclToDeclareForBlock) 4169 RewriteBlockLiteralFunctionDecl(CurFunctionDeclToDeclareForBlock); 4170 int flag = 0; 4171 int isa = 0; 4172 SourceLocation DeclLoc = ND->getTypeSpecStartLoc(); 4173 if (DeclLoc.isInvalid()) 4174 // If type location is missing, it is because of missing type (a warning). 4175 // Use variable's location which is good for this case. 4176 DeclLoc = ND->getLocation(); 4177 const char *startBuf = SM->getCharacterData(DeclLoc); 4178 SourceLocation X = ND->getEndLoc(); 4179 X = SM->getExpansionLoc(X); 4180 const char *endBuf = SM->getCharacterData(X); 4181 std::string Name(ND->getNameAsString()); 4182 std::string ByrefType; 4183 RewriteByRefString(ByrefType, Name, ND, true); 4184 ByrefType += " {\n"; 4185 ByrefType += " void *__isa;\n"; 4186 RewriteByRefString(ByrefType, Name, ND); 4187 ByrefType += " *__forwarding;\n"; 4188 ByrefType += " int __flags;\n"; 4189 ByrefType += " int __size;\n"; 4190 // Add void *__Block_byref_id_object_copy; 4191 // void *__Block_byref_id_object_dispose; if needed. 4192 QualType Ty = ND->getType(); 4193 bool HasCopyAndDispose = Context->BlockRequiresCopying(Ty, ND); 4194 if (HasCopyAndDispose) { 4195 ByrefType += " void (*__Block_byref_id_object_copy)(void*, void*);\n"; 4196 ByrefType += " void (*__Block_byref_id_object_dispose)(void*);\n"; 4197 } 4198 4199 QualType T = Ty; 4200 (void)convertBlockPointerToFunctionPointer(T); 4201 T.getAsStringInternal(Name, Context->getPrintingPolicy()); 4202 4203 ByrefType += " " + Name + ";\n"; 4204 ByrefType += "};\n"; 4205 // Insert this type in global scope. It is needed by helper function. 4206 SourceLocation FunLocStart; 4207 if (CurFunctionDef) 4208 FunLocStart = CurFunctionDef->getTypeSpecStartLoc(); 4209 else { 4210 assert(CurMethodDef && "RewriteByRefVar - CurMethodDef is null")(static_cast<void> (0)); 4211 FunLocStart = CurMethodDef->getBeginLoc(); 4212 } 4213 InsertText(FunLocStart, ByrefType); 4214 if (Ty.isObjCGCWeak()) { 4215 flag |= BLOCK_FIELD_IS_WEAK; 4216 isa = 1; 4217 } 4218 4219 if (HasCopyAndDispose) { 4220 flag = BLOCK_BYREF_CALLER; 4221 QualType Ty = ND->getType(); 4222 // FIXME. Handle __weak variable (BLOCK_FIELD_IS_WEAK) as well. 4223 if (Ty->isBlockPointerType()) 4224 flag |= BLOCK_FIELD_IS_BLOCK; 4225 else 4226 flag |= BLOCK_FIELD_IS_OBJECT; 4227 std::string HF = SynthesizeByrefCopyDestroyHelper(ND, flag); 4228 if (!HF.empty()) 4229 InsertText(FunLocStart, HF); 4230 } 4231 4232 // struct __Block_byref_ND ND = 4233 // {0, &ND, some_flag, __size=sizeof(struct __Block_byref_ND), 4234 // initializer-if-any}; 4235 bool hasInit = (ND->getInit() != nullptr); 4236 unsigned flags = 0; 4237 if (HasCopyAndDispose) 4238 flags |= BLOCK_HAS_COPY_DISPOSE; 4239 Name = ND->getNameAsString(); 4240 ByrefType.clear(); 4241 RewriteByRefString(ByrefType, Name, ND); 4242 std::string ForwardingCastType("("); 4243 ForwardingCastType += ByrefType + " *)"; 4244 if (!hasInit) { 4245 ByrefType += " " + Name + " = {(void*)"; 4246 ByrefType += utostr(isa); 4247 ByrefType += "," + ForwardingCastType + "&" + Name + ", "; 4248 ByrefType += utostr(flags); 4249 ByrefType += ", "; 4250 ByrefType += "sizeof("; 4251 RewriteByRefString(ByrefType, Name, ND); 4252 ByrefType += ")"; 4253 if (HasCopyAndDispose) { 4254 ByrefType += ", __Block_byref_id_object_copy_"; 4255 ByrefType += utostr(flag); 4256 ByrefType += ", __Block_byref_id_object_dispose_"; 4257 ByrefType += utostr(flag); 4258 } 4259 ByrefType += "};\n"; 4260 unsigned nameSize = Name.size(); 4261 // for block or function pointer declaration. Name is already 4262 // part of the declaration. 4263 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) 4264 nameSize = 1; 4265 ReplaceText(DeclLoc, endBuf-startBuf+nameSize, ByrefType); 4266 } 4267 else { 4268 SourceLocation startLoc; 4269 Expr *E = ND->getInit(); 4270 if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) 4271 startLoc = ECE->getLParenLoc(); 4272 else 4273 startLoc = E->getBeginLoc(); 4274 startLoc = SM->getExpansionLoc(startLoc); 4275 endBuf = SM->getCharacterData(startLoc); 4276 ByrefType += " " + Name; 4277 ByrefType += " = {(void*)"; 4278 ByrefType += utostr(isa); 4279 ByrefType += "," + ForwardingCastType + "&" + Name + ", "; 4280 ByrefType += utostr(flags); 4281 ByrefType += ", "; 4282 ByrefType += "sizeof("; 4283 RewriteByRefString(ByrefType, Name, ND); 4284 ByrefType += "), "; 4285 if (HasCopyAndDispose) { 4286 ByrefType += "__Block_byref_id_object_copy_"; 4287 ByrefType += utostr(flag); 4288 ByrefType += ", __Block_byref_id_object_dispose_"; 4289 ByrefType += utostr(flag); 4290 ByrefType += ", "; 4291 } 4292 ReplaceText(DeclLoc, endBuf-startBuf, ByrefType); 4293 4294 // Complete the newly synthesized compound expression by inserting a right 4295 // curly brace before the end of the declaration. 4296 // FIXME: This approach avoids rewriting the initializer expression. It 4297 // also assumes there is only one declarator. For example, the following 4298 // isn't currently supported by this routine (in general): 4299 // 4300 // double __block BYREFVAR = 1.34, BYREFVAR2 = 1.37; 4301 // 4302 const char *startInitializerBuf = SM->getCharacterData(startLoc); 4303 const char *semiBuf = strchr(startInitializerBuf, ';'); 4304 assert((*semiBuf == ';') && "RewriteByRefVar: can't find ';'")(static_cast<void> (0)); 4305 SourceLocation semiLoc = 4306 startLoc.getLocWithOffset(semiBuf-startInitializerBuf); 4307 4308 InsertText(semiLoc, "}"); 4309 } 4310} 4311 4312void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) { 4313 // Add initializers for any closure decl refs. 4314 GetBlockDeclRefExprs(Exp->getBody()); 4315 if (BlockDeclRefs.size()) { 4316 // Unique all "by copy" declarations. 4317 for (unsigned i = 0; i < BlockDeclRefs.size(); i++) 4318 if (!BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>()) { 4319 if (!BlockByCopyDeclsPtrSet.count(BlockDeclRefs[i]->getDecl())) { 4320 BlockByCopyDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl()); 4321 BlockByCopyDecls.push_back(BlockDeclRefs[i]->getDecl()); 4322 } 4323 } 4324 // Unique all "by ref" declarations. 4325 for (unsigned i = 0; i < BlockDeclRefs.size(); i++) 4326 if (BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>()) { 4327 if (!BlockByRefDeclsPtrSet.count(BlockDeclRefs[i]->getDecl())) { 4328 BlockByRefDeclsPtrSet.insert(BlockDeclRefs[i]->getDecl()); 4329 BlockByRefDecls.push_back(BlockDeclRefs[i]->getDecl()); 4330 } 4331 } 4332 // Find any imported blocks...they will need special attention. 4333 for (unsigned i = 0; i < BlockDeclRefs.size(); i++) 4334 if (BlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() || 4335 BlockDeclRefs[i]->getType()->isObjCObjectPointerType() || 4336 BlockDeclRefs[i]->getType()->isBlockPointerType()) 4337 ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl()); 4338 } 4339} 4340 4341FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(StringRef name) { 4342 IdentifierInfo *ID = &Context->Idents.get(name); 4343 QualType FType = Context->getFunctionNoProtoType(Context->VoidPtrTy); 4344 return FunctionDecl::Create(*Context, TUDecl, SourceLocation(), 4345 SourceLocation(), ID, FType, nullptr, SC_Extern, 4346 false, false); 4347} 4348 4349Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp, 4350 const SmallVectorImpl<DeclRefExpr *> &InnerBlockDeclRefs) { 4351 const BlockDecl *block = Exp->getBlockDecl(); 4352 Blocks.push_back(Exp); 4353 4354 CollectBlockDeclRefInfo(Exp); 4355 4356 // Add inner imported variables now used in current block. 4357 int countOfInnerDecls = 0; 4358 if (!InnerBlockDeclRefs.empty()) { 4359 for (unsigned i = 0; i < InnerBlockDeclRefs.size(); i++) { 4360 DeclRefExpr *Exp = InnerBlockDeclRefs[i]; 4361 ValueDecl *VD = Exp->getDecl(); 4362 if (!VD->hasAttr<BlocksAttr>() && !BlockByCopyDeclsPtrSet.count(VD)) { 4363 // We need to save the copied-in variables in nested 4364 // blocks because it is needed at the end for some of the API generations. 4365 // See SynthesizeBlockLiterals routine. 4366 InnerDeclRefs.push_back(Exp); countOfInnerDecls++; 4367 BlockDeclRefs.push_back(Exp); 4368 BlockByCopyDeclsPtrSet.insert(VD); 4369 BlockByCopyDecls.push_back(VD); 4370 } 4371 if (VD->hasAttr<BlocksAttr>() && !BlockByRefDeclsPtrSet.count(VD)) { 4372 InnerDeclRefs.push_back(Exp); countOfInnerDecls++; 4373 BlockDeclRefs.push_back(Exp); 4374 BlockByRefDeclsPtrSet.insert(VD); 4375 BlockByRefDecls.push_back(VD); 4376 } 4377 } 4378 // Find any imported blocks...they will need special attention. 4379 for (unsigned i = 0; i < InnerBlockDeclRefs.size(); i++) 4380 if (InnerBlockDeclRefs[i]->getDecl()->hasAttr<BlocksAttr>() || 4381 InnerBlockDeclRefs[i]->getType()->isObjCObjectPointerType() || 4382 InnerBlockDeclRefs[i]->getType()->isBlockPointerType()) 4383 ImportedBlockDecls.insert(InnerBlockDeclRefs[i]->getDecl()); 4384 } 4385 InnerDeclRefsCount.push_back(countOfInnerDecls); 4386 4387 std::string FuncName; 4388 4389 if (CurFunctionDef) 4390 FuncName = CurFunctionDef->getNameAsString(); 4391 else if (CurMethodDef) 4392 BuildUniqueMethodName(FuncName, CurMethodDef); 4393 else if (GlobalVarDecl) 4394 FuncName = std::string(GlobalVarDecl->getNameAsString()); 4395 4396 std::string BlockNumber = utostr(Blocks.size()-1); 4397 4398 std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber; 4399 std::string Func = "__" + FuncName + "_block_func_" + BlockNumber; 4400 4401 // Get a pointer to the function type so we can cast appropriately. 4402 QualType BFT = convertFunctionTypeOfBlocks(Exp->getFunctionType()); 4403 QualType FType = Context->getPointerType(BFT); 4404 4405 FunctionDecl *FD; 4406 Expr *NewRep; 4407 4408 // Simulate a constructor call... 4409 FD = SynthBlockInitFunctionDecl(Tag); 4410 DeclRefExpr *DRE = new (Context) 4411 DeclRefExpr(*Context, FD, false, FType, VK_PRValue, SourceLocation()); 4412 4413 SmallVector<Expr*, 4> InitExprs; 4414 4415 // Initialize the block function. 4416 FD = SynthBlockInitFunctionDecl(Func); 4417 DeclRefExpr *Arg = new (Context) DeclRefExpr( 4418 *Context, FD, false, FD->getType(), VK_LValue, SourceLocation()); 4419 CastExpr *castExpr = 4420 NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, CK_BitCast, Arg); 4421 InitExprs.push_back(castExpr); 4422 4423 // Initialize the block descriptor. 4424 std::string DescData = "__" + FuncName + "_block_desc_" + BlockNumber + "_DATA"; 4425 4426 VarDecl *NewVD = VarDecl::Create( 4427 *Context, TUDecl, SourceLocation(), SourceLocation(), 4428 &Context->Idents.get(DescData), Context->VoidPtrTy, nullptr, SC_Static); 4429 UnaryOperator *DescRefExpr = UnaryOperator::Create( 4430 const_cast<ASTContext &>(*Context), 4431 new (Context) DeclRefExpr(*Context, NewVD, false, Context->VoidPtrTy, 4432 VK_LValue, SourceLocation()), 4433 UO_AddrOf, Context->getPointerType(Context->VoidPtrTy), VK_PRValue, 4434 OK_Ordinary, SourceLocation(), false, FPOptionsOverride()); 4435 InitExprs.push_back(DescRefExpr); 4436 4437 // Add initializers for any closure decl refs. 4438 if (BlockDeclRefs.size()) { 4439 Expr *Exp; 4440 // Output all "by copy" declarations. 4441 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByCopyDecls.begin(), 4442 E = BlockByCopyDecls.end(); I != E; ++I) { 4443 if (isObjCType((*I)->getType())) { 4444 // FIXME: Conform to ABI ([[obj retain] autorelease]). 4445 FD = SynthBlockInitFunctionDecl((*I)->getName()); 4446 Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), 4447 VK_LValue, SourceLocation()); 4448 if (HasLocalVariableExternalStorage(*I)) { 4449 QualType QT = (*I)->getType(); 4450 QT = Context->getPointerType(QT); 4451 Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp, 4452 UO_AddrOf, QT, VK_PRValue, OK_Ordinary, 4453 SourceLocation(), false, 4454 FPOptionsOverride()); 4455 } 4456 } else if (isTopLevelBlockPointerType((*I)->getType())) { 4457 FD = SynthBlockInitFunctionDecl((*I)->getName()); 4458 Arg = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), 4459 VK_LValue, SourceLocation()); 4460 Exp = NoTypeInfoCStyleCastExpr(Context, Context->VoidPtrTy, CK_BitCast, 4461 Arg); 4462 } else { 4463 FD = SynthBlockInitFunctionDecl((*I)->getName()); 4464 Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), 4465 VK_LValue, SourceLocation()); 4466 if (HasLocalVariableExternalStorage(*I)) { 4467 QualType QT = (*I)->getType(); 4468 QT = Context->getPointerType(QT); 4469 Exp = UnaryOperator::Create(const_cast<ASTContext &>(*Context), Exp, 4470 UO_AddrOf, QT, VK_PRValue, OK_Ordinary, 4471 SourceLocation(), false, 4472 FPOptionsOverride()); 4473 } 4474 } 4475 InitExprs.push_back(Exp); 4476 } 4477 // Output all "by ref" declarations. 4478 for (SmallVectorImpl<ValueDecl *>::iterator I = BlockByRefDecls.begin(), 4479 E = BlockByRefDecls.end(); I != E; ++I) { 4480 ValueDecl *ND = (*I); 4481 std::string Name(ND->getNameAsString()); 4482 std::string RecName; 4483 RewriteByRefString(RecName, Name, ND, true); 4484 IdentifierInfo *II = &Context->Idents.get(RecName.c_str() 4485 + sizeof("struct")); 4486 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl, 4487 SourceLocation(), SourceLocation(), 4488 II); 4489 assert(RD && "SynthBlockInitExpr(): Can't find RecordDecl")(static_cast<void> (0)); 4490 QualType castT = Context->getPointerType(Context->getTagDeclType(RD)); 4491 4492 FD = SynthBlockInitFunctionDecl((*I)->getName()); 4493 Exp = new (Context) DeclRefExpr(*Context, FD, false, FD->getType(), 4494 VK_LValue, SourceLocation()); 4495 bool isNestedCapturedVar = false; 4496 if (block) 4497 for (const auto &CI : block->captures()) { 4498 const VarDecl *variable = CI.getVariable(); 4499 if (variable == ND && CI.isNested()) { 4500 assert (CI.isByRef() &&(static_cast<void> (0)) 4501 "SynthBlockInitExpr - captured block variable is not byref")(static_cast<void> (0)); 4502 isNestedCapturedVar = true; 4503 break; 4504 } 4505 } 4506 // captured nested byref variable has its address passed. Do not take 4507 // its address again. 4508 if (!isNestedCapturedVar) 4509 Exp = UnaryOperator::Create( 4510 const_cast<ASTContext &>(*Context), Exp, UO_AddrOf, 4511 Context->getPointerType(Exp->getType()), VK_PRValue, OK_Ordinary, 4512 SourceLocation(), false, FPOptionsOverride()); 4513 Exp = NoTypeInfoCStyleCastExpr(Context, castT, CK_BitCast, Exp); 4514 InitExprs.push_back(Exp); 4515 } 4516 } 4517 if (ImportedBlockDecls.size()) { 4518 // generate BLOCK_HAS_COPY_DISPOSE(have helper funcs) | BLOCK_HAS_DESCRIPTOR 4519 int flag = (BLOCK_HAS_COPY_DISPOSE | BLOCK_HAS_DESCRIPTOR); 4520 unsigned IntSize = 4521 static_cast<unsigned>(Context->getTypeSize(Context->IntTy)); 4522 Expr *FlagExp = IntegerLiteral::Create(*Context, llvm::APInt(IntSize, flag), 4523 Context->IntTy, SourceLocation()); 4524 InitExprs.push_back(FlagExp); 4525 } 4526 NewRep = CallExpr::Create(*Context, DRE, InitExprs, FType, VK_LValue, 4527 SourceLocation(), FPOptionsOverride()); 4528 NewRep = UnaryOperator::Create( 4529 const_cast<ASTContext &>(*Context), NewRep, UO_AddrOf, 4530 Context->getPointerType(NewRep->getType()), VK_PRValue, OK_Ordinary, 4531 SourceLocation(), false, FPOptionsOverride()); 4532 NewRep = NoTypeInfoCStyleCastExpr(Context, FType, CK_BitCast, 4533 NewRep); 4534 BlockDeclRefs.clear(); 4535 BlockByRefDecls.clear(); 4536 BlockByRefDeclsPtrSet.clear(); 4537 BlockByCopyDecls.clear(); 4538 BlockByCopyDeclsPtrSet.clear(); 4539 ImportedBlockDecls.clear(); 4540 return NewRep; 4541} 4542 4543bool RewriteObjC::IsDeclStmtInForeachHeader(DeclStmt *DS) { 4544 if (const ObjCForCollectionStmt * CS = 4545 dyn_cast<ObjCForCollectionStmt>(Stmts.back())) 4546 return CS->getElement() == DS; 4547 return false; 4548} 4549 4550//===----------------------------------------------------------------------===// 4551// Function Body / Expression rewriting 4552//===----------------------------------------------------------------------===// 4553 4554Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) { 4555 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||

←

Assuming 'S' is not a 'SwitchStmt'

→

←

Assuming 'S' is not a 'WhileStmt'

→

←

Taking false branch

→

4556 isa<DoStmt>(S) || isa<ForStmt>(S))

←

Assuming 'S' is not a 'DoStmt'

→

←

Assuming 'S' is not a 'ForStmt'

→

4557 Stmts.push_back(S); 4558 else if (isa<ObjCForCollectionStmt>(S)) {

←

Assuming 'S' is not a 'ObjCForCollectionStmt'

→

←

Taking false branch

→

4559 Stmts.push_back(S); 4560 ObjCBcLabelNo.push_back(++BcLabelCount); 4561 } 4562 4563 // Pseudo-object operations and ivar references need special 4564 // treatment because we're going to recursively rewrite them. 4565 if (PseudoObjectExpr *PseudoOp

9.1	'PseudoOp' is null

= dyn_cast<PseudoObjectExpr>(S)) {

←

Assuming 'S' is not a 'PseudoObjectExpr'

→

←

Taking false branch

→

4566 if (isa<BinaryOperator>(PseudoOp->getSyntacticForm())) { 4567 return RewritePropertyOrImplicitSetter(PseudoOp); 4568 } else { 4569 return RewritePropertyOrImplicitGetter(PseudoOp); 4570 } 4571 } else if (ObjCIvarRefExpr *IvarRefExpr

11.1	'IvarRefExpr' is null

= dyn_cast<ObjCIvarRefExpr>(S)) {

←

Assuming 'S' is not a 'ObjCIvarRefExpr'

→

←

Taking false branch

→

4572 return RewriteObjCIvarRefExpr(IvarRefExpr); 4573 } 4574 4575 SourceRange OrigStmtRange = S->getSourceRange(); 4576 4577 // Perform a bottom up rewrite of all children. 4578 for (Stmt *&childStmt : S->children()) 4579 if (childStmt) {

←

Assuming 'childStmt' is null

→

←

Taking false branch

→

4580 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(childStmt); 4581 if (newStmt) { 4582 childStmt = newStmt; 4583 } 4584 } 4585 4586 if (BlockExpr *BE

15.1	'BE' is null

= dyn_cast<BlockExpr>(S)) {

←

Assuming 'S' is not a 'BlockExpr'

→

←

Taking false branch

→

4587 SmallVector<DeclRefExpr *, 8> InnerBlockDeclRefs; 4588 llvm::SmallPtrSet<const DeclContext *, 8> InnerContexts; 4589 InnerContexts.insert(BE->getBlockDecl()); 4590 ImportedLocalExternalDecls.clear(); 4591 GetInnerBlockDeclRefExprs(BE->getBody(), 4592 InnerBlockDeclRefs, InnerContexts); 4593 // Rewrite the block body in place. 4594 Stmt *SaveCurrentBody = CurrentBody; 4595 CurrentBody = BE->getBody(); 4596 PropParentMap = nullptr; 4597 // block literal on rhs of a property-dot-sytax assignment 4598 // must be replaced by its synthesize ast so getRewrittenText 4599 // works as expected. In this case, what actually ends up on RHS 4600 // is the blockTranscribed which is the helper function for the 4601 // block literal; as in: self.c = ^() {[ace ARR];}; 4602 bool saveDisableReplaceStmt = DisableReplaceStmt; 4603 DisableReplaceStmt = false; 4604 RewriteFunctionBodyOrGlobalInitializer(BE->getBody()); 4605 DisableReplaceStmt = saveDisableReplaceStmt; 4606 CurrentBody = SaveCurrentBody; 4607 PropParentMap = nullptr; 4608 ImportedLocalExternalDecls.clear(); 4609 // Now we snarf the rewritten text and stash it away for later use. 4610 std::string Str = Rewrite.getRewrittenText(BE->getSourceRange()); 4611 RewrittenBlockExprs[BE] = Str; 4612 4613 Stmt *blockTranscribed = SynthBlockInitExpr(BE, InnerBlockDeclRefs); 4614 4615 //blockTranscribed->dump(); 4616 ReplaceStmt(S, blockTranscribed); 4617 return blockTranscribed; 4618 } 4619 // Handle specific things. 4620 if (ObjCEncodeExpr *AtEncode

17.1	'AtEncode' is null

= dyn_cast<ObjCEncodeExpr>(S))

←

Assuming 'S' is not a 'ObjCEncodeExpr'

→

←

Taking false branch

→

4621 return RewriteAtEncode(AtEncode); 4622 4623 if (ObjCSelectorExpr *AtSelector

19.1	'AtSelector' is null

= dyn_cast<ObjCSelectorExpr>(S))

←

Assuming 'S' is not a 'ObjCSelectorExpr'

→

←

Taking false branch

→

4624 return RewriteAtSelector(AtSelector); 4625 4626 if (ObjCStringLiteral *AtString

21.1	'AtString' is null

= dyn_cast<ObjCStringLiteral>(S))

←

Assuming 'S' is not a 'ObjCStringLiteral'

→

←

Taking false branch

→

4627 return RewriteObjCStringLiteral(AtString); 4628 4629 if (ObjCMessageExpr *MessExpr

23.1	'MessExpr' is null

= dyn_cast<ObjCMessageExpr>(S)) {

←

Assuming 'S' is not a 'ObjCMessageExpr'

→

←

Taking false branch

→

4630#if 0 4631 // Before we rewrite it, put the original message expression in a comment. 4632 SourceLocation startLoc = MessExpr->getBeginLoc(); 4633 SourceLocation endLoc = MessExpr->getEndLoc(); 4634 4635 const char *startBuf = SM->getCharacterData(startLoc); 4636 const char *endBuf = SM->getCharacterData(endLoc); 4637 4638 std::string messString; 4639 messString += "// "; 4640 messString.append(startBuf, endBuf-startBuf+1); 4641 messString += "\n"; 4642 4643 // FIXME: Missing definition of 4644 // InsertText(clang::SourceLocation, char const*, unsigned int). 4645 // InsertText(startLoc, messString); 4646 // Tried this, but it didn't work either... 4647 // ReplaceText(startLoc, 0, messString.c_str(), messString.size()); 4648#endif 4649 return RewriteMessageExpr(MessExpr); 4650 } 4651 4652 if (ObjCAtTryStmt *StmtTry

25.1	'StmtTry' is null

= dyn_cast<ObjCAtTryStmt>(S))

←

Assuming 'S' is not a 'ObjCAtTryStmt'

→

←

Taking false branch

→

4653 return RewriteObjCTryStmt(StmtTry); 4654 4655 if (ObjCAtSynchronizedStmt *StmtTry

27.1	'StmtTry' is null

= dyn_cast<ObjCAtSynchronizedStmt>(S))

←

Assuming 'S' is not a 'ObjCAtSynchronizedStmt'

→

←

Taking false branch

→

4656 return RewriteObjCSynchronizedStmt(StmtTry); 4657 4658 if (ObjCAtThrowStmt *StmtThrow

29.1	'StmtThrow' is null

= dyn_cast<ObjCAtThrowStmt>(S))

←

Assuming 'S' is not a 'ObjCAtThrowStmt'

→

←

Taking false branch

→

4659 return RewriteObjCThrowStmt(StmtThrow); 4660 4661 if (ObjCProtocolExpr *ProtocolExp

31.1	'ProtocolExp' is null

= dyn_cast<ObjCProtocolExpr>(S))

←

Assuming 'S' is not a 'ObjCProtocolExpr'

→

←

Taking false branch

→

4662 return RewriteObjCProtocolExpr(ProtocolExp); 4663 4664 if (ObjCForCollectionStmt *StmtForCollection

33.1	'StmtForCollection' is null

←

Taking false branch

→

4665 dyn_cast<ObjCForCollectionStmt>(S))

←

Assuming 'S' is not a 'ObjCForCollectionStmt'

→

4666 return RewriteObjCForCollectionStmt(StmtForCollection, 4667 OrigStmtRange.getEnd()); 4668 if (BreakStmt *StmtBreakStmt

35.1	'StmtBreakStmt' is null

←

Taking false branch

→

4669 dyn_cast<BreakStmt>(S))

←

Assuming 'S' is not a 'BreakStmt'

→

4670 return RewriteBreakStmt(StmtBreakStmt); 4671 if (ContinueStmt *StmtContinueStmt

37.1	'StmtContinueStmt' is null

←

Taking false branch

→

4672 dyn_cast<ContinueStmt>(S))

←

Assuming 'S' is not a 'ContinueStmt'

→

4673 return RewriteContinueStmt(StmtContinueStmt); 4674 4675 // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls 4676 // and cast exprs. 4677 if (DeclStmt *DS

39.1	'DS' is null

= dyn_cast<DeclStmt>(S)) {

←

Assuming 'S' is not a 'DeclStmt'

→

←

Taking false branch

→

4678 // FIXME: What we're doing here is modifying the type-specifier that 4679 // precedes the first Decl. In the future the DeclGroup should have 4680 // a separate type-specifier that we can rewrite. 4681 // NOTE: We need to avoid rewriting the DeclStmt if it is within 4682 // the context of an ObjCForCollectionStmt. For example: 4683 // NSArray *someArray; 4684 // for (id <FooProtocol> index in someArray) ; 4685 // This is because RewriteObjCForCollectionStmt() does textual rewriting 4686 // and it depends on the original text locations/positions. 4687 if (Stmts.empty() || !IsDeclStmtInForeachHeader(DS)) 4688 RewriteObjCQualifiedInterfaceTypes(*DS->decl_begin()); 4689 4690 // Blocks rewrite rules. 4691 for (auto *SD : DS->decls()) { 4692 if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) { 4693 if (isTopLevelBlockPointerType(ND->getType())) 4694 RewriteBlockPointerDecl(ND); 4695 else if (ND->getType()->isFunctionPointerType()) 4696 CheckFunctionPointerDecl(ND->getType(), ND); 4697 if (VarDecl *VD = dyn_cast<VarDecl>(SD)) { 4698 if (VD->hasAttr<BlocksAttr>()) { 4699 static unsigned uniqueByrefDeclCount = 0; 4700 assert(!BlockByRefDeclNo.count(ND) &&(static_cast<void> (0)) 4701 "RewriteFunctionBodyOrGlobalInitializer: Duplicate byref decl")(static_cast<void> (0)); 4702 BlockByRefDeclNo[ND] = uniqueByrefDeclCount++; 4703 RewriteByRefVar(VD); 4704 } 4705 else 4706 RewriteTypeOfDecl(VD); 4707 } 4708 } 4709 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) { 4710 if (isTopLevelBlockPointerType(TD->getUnderlyingType())) 4711 RewriteBlockPointerDecl(TD); 4712 else if (TD->getUnderlyingType()->isFunctionPointerType()) 4713 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); 4714 } 4715 } 4716 } 4717 4718 if (CStyleCastExpr *CE

41.1	'CE' is null

= dyn_cast<CStyleCastExpr>(S))

←

Assuming 'S' is not a 'CStyleCastExpr'

→

4719 RewriteObjCQualifiedInterfaceTypes(CE); 4720 4721 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||

←

Assuming 'S' is not a 'SwitchStmt'

→

←

Assuming 'S' is not a 'WhileStmt'

→

←

Taking false branch

→

4722 isa<DoStmt>(S) || isa<ForStmt>(S)) {

←

Assuming 'S' is not a 'DoStmt'

→

←

Assuming 'S' is not a 'ForStmt'

→

4723 assert(!Stmts.empty() && "Statement stack is empty")(static_cast<void> (0)); 4724 assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) ||(static_cast<void> (0)) 4725 isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back()))(static_cast<void> (0)) 4726 && "Statement stack mismatch")(static_cast<void> (0)); 4727 Stmts.pop_back(); 4728 } 4729 // Handle blocks rewriting. 4730 if (DeclRefExpr *DRE

47.1	'DRE' is null

= dyn_cast<DeclRefExpr>(S)) {

←

Assuming 'S' is not a 'DeclRefExpr'

→

←

Taking false branch

→

4731 ValueDecl *VD = DRE->getDecl(); 4732 if (VD->hasAttr<BlocksAttr>()) 4733 return RewriteBlockDeclRefExpr(DRE); 4734 if (HasLocalVariableExternalStorage(VD)) 4735 return RewriteLocalVariableExternalStorage(DRE); 4736 } 4737 4738 if (CallExpr *CE

49.1	'CE' is non-null

= dyn_cast<CallExpr>(S)) {

←

Assuming 'S' is a 'CallExpr'

→

←

Taking true branch

→

4739 if (CE->getCallee()->getType()->isBlockPointerType()) {

←

Taking true branch

→

4740 Stmt *BlockCall = SynthesizeBlockCall(CE, CE->getCallee());

←

Calling 'RewriteObjC::SynthesizeBlockCall'

→

4741 ReplaceStmt(S, BlockCall); 4742 return BlockCall; 4743 } 4744 } 4745 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) { 4746 RewriteCastExpr(CE); 4747 } 4748#if 0 4749 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) { 4750 CastExpr *Replacement = new (Context) CastExpr(ICE->getType(), 4751 ICE->getSubExpr(), 4752 SourceLocation()); 4753 // Get the new text. 4754 std::string SStr; 4755 llvm::raw_string_ostream Buf(SStr); 4756 Replacement->printPretty(Buf); 4757 const std::string &Str = Buf.str(); 4758 4759 printf("CAST = %s\n", &Str[0]); 4760 InsertText(ICE->getSubExpr()->getBeginLoc(), Str); 4761 delete S; 4762 return Replacement; 4763 } 4764#endif 4765 // Return this stmt unmodified. 4766 return S; 4767} 4768 4769void RewriteObjC::RewriteRecordBody(RecordDecl *RD) { 4770 for (auto *FD : RD->fields()) { 4771 if (isTopLevelBlockPointerType(FD->getType())) 4772 RewriteBlockPointerDecl(FD); 4773 if (FD->getType()->isObjCQualifiedIdType() || 4774 FD->getType()->isObjCQualifiedInterfaceType()) 4775 RewriteObjCQualifiedInterfaceTypes(FD); 4776 } 4777} 4778 4779/// HandleDeclInMainFile - This is called for each top-level decl defined in the 4780/// main file of the input. 4781void RewriteObjC::HandleDeclInMainFile(Decl *D) { 4782 switch (D->getKind()) { 4783 case Decl::Function: { 4784 FunctionDecl *FD = cast<FunctionDecl>(D); 4785 if (FD->isOverloadedOperator()) 4786 return; 4787 4788 // Since function prototypes don't have ParmDecl's, we check the function 4789 // prototype. This enables us to rewrite function declarations and 4790 // definitions using the same code. 4791 RewriteBlocksInFunctionProtoType(FD->getType(), FD); 4792 4793 if (!FD->isThisDeclarationADefinition()) 4794 break; 4795 4796 // FIXME: If this should support Obj-C++, support CXXTryStmt 4797 if (CompoundStmt *Body = dyn_cast_or_null<CompoundStmt>(FD->getBody())) { 4798 CurFunctionDef = FD; 4799 CurFunctionDeclToDeclareForBlock = FD; 4800 CurrentBody = Body; 4801 Body = 4802 cast_or_null<CompoundStmt>(RewriteFunctionBodyOrGlobalInitializer(Body)); 4803 FD->setBody(Body); 4804 CurrentBody = nullptr; 4805 if (PropParentMap) { 4806 delete PropParentMap; 4807 PropParentMap = nullptr; 4808 } 4809 // This synthesizes and inserts the block "impl" struct, invoke function, 4810 // and any copy/dispose helper functions. 4811 InsertBlockLiteralsWithinFunction(FD); 4812 CurFunctionDef = nullptr; 4813 CurFunctionDeclToDeclareForBlock = nullptr; 4814 } 4815 break; 4816 } 4817 case Decl::ObjCMethod: { 4818 ObjCMethodDecl *MD = cast<ObjCMethodDecl>(D); 4819 if (CompoundStmt *Body = MD->getCompoundBody()) { 4820 CurMethodDef = MD; 4821 CurrentBody = Body; 4822 Body = 4823 cast_or_null<CompoundStmt>(RewriteFunctionBodyOrGlobalInitializer(Body)); 4824 MD->setBody(Body); 4825 CurrentBody = nullptr; 4826 if (PropParentMap) { 4827 delete PropParentMap; 4828 PropParentMap = nullptr; 4829 } 4830 InsertBlockLiteralsWithinMethod(MD); 4831 CurMethodDef = nullptr; 4832 } 4833 break; 4834 } 4835 case Decl::ObjCImplementation: { 4836 ObjCImplementationDecl *CI = cast<ObjCImplementationDecl>(D); 4837 ClassImplementation.push_back(CI); 4838 break; 4839 } 4840 case Decl::ObjCCategoryImpl: { 4841 ObjCCategoryImplDecl *CI = cast<ObjCCategoryImplDecl>(D); 4842 CategoryImplementation.push_back(CI); 4843 break; 4844 } 4845 case Decl::Var: { 4846 VarDecl *VD = cast<VarDecl>(D); 4847 RewriteObjCQualifiedInterfaceTypes(VD); 4848 if (isTopLevelBlockPointerType(VD->getType())) 4849 RewriteBlockPointerDecl(VD); 4850 else if (VD->getType()->isFunctionPointerType()) { 4851 CheckFunctionPointerDecl(VD->getType(), VD); 4852 if (VD->getInit()) { 4853 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) { 4854 RewriteCastExpr(CE); 4855 } 4856 } 4857 } else if (VD->getType()->isRecordType()) { 4858 RecordDecl *RD = VD->getType()->castAs<RecordType>()->getDecl(); 4859 if (RD->isCompleteDefinition()) 4860 RewriteRecordBody(RD); 4861 } 4862 if (VD->getInit()) { 4863 GlobalVarDecl = VD; 4864 CurrentBody = VD->getInit(); 4865 RewriteFunctionBodyOrGlobalInitializer(VD->getInit()); 4866 CurrentBody = nullptr; 4867 if (PropParentMap) { 4868 delete PropParentMap; 4869 PropParentMap = nullptr; 4870 } 4871 SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), VD->getName()); 4872 GlobalVarDecl = nullptr; 4873 4874 // This is needed for blocks. 4875 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) { 4876 RewriteCastExpr(CE); 4877 } 4878 } 4879 break; 4880 } 4881 case Decl::TypeAlias: 4882 case Decl::Typedef: { 4883 if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) { 4884 if (isTopLevelBlockPointerType(TD->getUnderlyingType())) 4885 RewriteBlockPointerDecl(TD); 4886 else if (TD->getUnderlyingType()->isFunctionPointerType()) 4887 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD); 4888 } 4889 break; 4890 } 4891 case Decl::CXXRecord: 4892 case Decl::Record: { 4893 RecordDecl *RD = cast<RecordDecl>(D); 4894 if (RD->isCompleteDefinition()) 4895 RewriteRecordBody(RD); 4896 break; 4897 } 4898 default: 4899 break; 4900 } 4901 // Nothing yet. 4902} 4903 4904void RewriteObjC::HandleTranslationUnit(ASTContext &C) { 4905 if (Diags.hasErrorOccurred()) 4906 return; 4907 4908 RewriteInclude(); 4909 4910 // Here's a great place to add any extra declarations that may be needed. 4911 // Write out meta data for each @protocol(<expr>). 4912 for (ObjCProtocolDecl *ProtDecl : ProtocolExprDecls) 4913 RewriteObjCProtocolMetaData(ProtDecl, "", "", Preamble); 4914 4915 InsertText(SM->getLocForStartOfFile(MainFileID), Preamble, false); 4916 if (ClassImplementation.size() || CategoryImplementation.size()) 4917 RewriteImplementations(); 4918 4919 // Get the buffer corresponding to MainFileID. If we haven't changed it, then 4920 // we are done. 4921 if (const RewriteBuffer *RewriteBuf = 4922 Rewrite.getRewriteBufferFor(MainFileID)) { 4923 //printf("Changed:\n"); 4924 *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end()); 4925 } else { 4926 llvm::errs() << "No changes\n"; 4927 } 4928 4929 if (ClassImplementation.size() || CategoryImplementation.size() || 4930 ProtocolExprDecls.size()) { 4931 // Rewrite Objective-c meta data* 4932 std::string ResultStr; 4933 RewriteMetaDataIntoBuffer(ResultStr); 4934 // Emit metadata. 4935 *OutFile << ResultStr; 4936 } 4937 OutFile->flush(); 4938} 4939 4940void RewriteObjCFragileABI::Initialize(ASTContext &context) { 4941 InitializeCommon(context); 4942 4943 // declaring objc_selector outside the parameter list removes a silly 4944 // scope related warning... 4945 if (IsHeader) 4946 Preamble = "#pragma once\n"; 4947 Preamble += "struct objc_selector; struct objc_class;\n"; 4948 Preamble += "struct __rw_objc_super { struct objc_object *object; "; 4949 Preamble += "struct objc_object *superClass; "; 4950 if (LangOpts.MicrosoftExt) { 4951 // Add a constructor for creating temporary objects. 4952 Preamble += "__rw_objc_super(struct objc_object *o, struct objc_object *s) " 4953 ": "; 4954 Preamble += "object(o), superClass(s) {} "; 4955 } 4956 Preamble += "};\n"; 4957 Preamble += "#ifndef _REWRITER_typedef_Protocol\n"; 4958 Preamble += "typedef struct objc_object Protocol;\n"; 4959 Preamble += "#define _REWRITER_typedef_Protocol\n"; 4960 Preamble += "#endif\n"; 4961 if (LangOpts.MicrosoftExt) { 4962 Preamble += "#define __OBJC_RW_DLLIMPORT extern \"C\" __declspec(dllimport)\n"; 4963 Preamble += "#define __OBJC_RW_STATICIMPORT extern \"C\"\n"; 4964 } else 4965 Preamble += "#define __OBJC_RW_DLLIMPORT extern\n"; 4966 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSend"; 4967 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n"; 4968 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSendSuper"; 4969 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n"; 4970 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object* objc_msgSend_stret"; 4971 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n"; 4972 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object* objc_msgSendSuper_stret"; 4973 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n"; 4974 Preamble += "__OBJC_RW_DLLIMPORT double objc_msgSend_fpret"; 4975 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n"; 4976 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_getClass"; 4977 Preamble += "(const char *);\n"; 4978 Preamble += "__OBJC_RW_DLLIMPORT struct objc_class *class_getSuperclass"; 4979 Preamble += "(struct objc_class *);\n"; 4980 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_getMetaClass"; 4981 Preamble += "(const char *);\n"; 4982 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_throw(struct objc_object *);\n"; 4983 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_try_enter(void *);\n"; 4984 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_try_exit(void *);\n"; 4985 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_exception_extract(void *);\n"; 4986 Preamble += "__OBJC_RW_DLLIMPORT int objc_exception_match"; 4987 Preamble += "(struct objc_class *, struct objc_object *);\n"; 4988 // @synchronized hooks. 4989 Preamble += "__OBJC_RW_DLLIMPORT int objc_sync_enter(struct objc_object *);\n"; 4990 Preamble += "__OBJC_RW_DLLIMPORT int objc_sync_exit(struct objc_object *);\n"; 4991 Preamble += "__OBJC_RW_DLLIMPORT Protocol *objc_getProtocol(const char *);\n"; 4992 Preamble += "#ifndef __FASTENUMERATIONSTATE\n"; 4993 Preamble += "struct __objcFastEnumerationState {\n\t"; 4994 Preamble += "unsigned long state;\n\t"; 4995 Preamble += "void **itemsPtr;\n\t"; 4996 Preamble += "unsigned long *mutationsPtr;\n\t"; 4997 Preamble += "unsigned long extra[5];\n};\n"; 4998 Preamble += "__OBJC_RW_DLLIMPORT void objc_enumerationMutation(struct objc_object *);\n"; 4999 Preamble += "#define __FASTENUMERATIONSTATE\n"; 5000 Preamble += "#endif\n"; 5001 Preamble += "#ifndef __NSCONSTANTSTRINGIMPL\n"; 5002 Preamble += "struct __NSConstantStringImpl {\n"; 5003 Preamble += " int *isa;\n"; 5004 Preamble += " int flags;\n"; 5005 Preamble += " char *str;\n"; 5006 Preamble += " long length;\n"; 5007 Preamble += "};\n"; 5008 Preamble += "#ifdef CF_EXPORT_CONSTANT_STRING\n"; 5009 Preamble += "extern \"C\" __declspec(dllexport) int __CFConstantStringClassReference[];\n"; 5010 Preamble += "#else\n"; 5011 Preamble += "__OBJC_RW_DLLIMPORT int __CFConstantStringClassReference[];\n"; 5012 Preamble += "#endif\n"; 5013 Preamble += "#define __NSCONSTANTSTRINGIMPL\n"; 5014 Preamble += "#endif\n"; 5015 // Blocks preamble. 5016 Preamble += "#ifndef BLOCK_IMPL\n"; 5017 Preamble += "#define BLOCK_IMPL\n"; 5018 Preamble += "struct __block_impl {\n"; 5019 Preamble += " void *isa;\n"; 5020 Preamble += " int Flags;\n"; 5021 Preamble += " int Reserved;\n"; 5022 Preamble += " void *FuncPtr;\n"; 5023 Preamble += "};\n"; 5024 Preamble += "// Runtime copy/destroy helper functions (from Block_private.h)\n"; 5025 Preamble += "#ifdef __OBJC_EXPORT_BLOCKS\n"; 5026 Preamble += "extern \"C\" __declspec(dllexport) " 5027 "void _Block_object_assign(void *, const void *, const int);\n"; 5028 Preamble += "extern \"C\" __declspec(dllexport) void _Block_object_dispose(const void *, const int);\n"; 5029 Preamble += "extern \"C\" __declspec(dllexport) void *_NSConcreteGlobalBlock[32];\n"; 5030 Preamble += "extern \"C\" __declspec(dllexport) void *_NSConcreteStackBlock[32];\n"; 5031 Preamble += "#else\n"; 5032 Preamble += "__OBJC_RW_DLLIMPORT void _Block_object_assign(void *, const void *, const int);\n"; 5033 Preamble += "__OBJC_RW_DLLIMPORT void _Block_object_dispose(const void *, const int);\n"; 5034 Preamble += "__OBJC_RW_DLLIMPORT void *_NSConcreteGlobalBlock[32];\n"; 5035 Preamble += "__OBJC_RW_DLLIMPORT void *_NSConcreteStackBlock[32];\n"; 5036 Preamble += "#endif\n"; 5037 Preamble += "#endif\n"; 5038 if (LangOpts.MicrosoftExt) { 5039 Preamble += "#undef __OBJC_RW_DLLIMPORT\n"; 5040 Preamble += "#undef __OBJC_RW_STATICIMPORT\n"; 5041 Preamble += "#ifndef KEEP_ATTRIBUTES\n"; // We use this for clang tests. 5042 Preamble += "#define __attribute__(X)\n"; 5043 Preamble += "#endif\n"; 5044 Preamble += "#define __weak\n"; 5045 } 5046 else { 5047 Preamble += "#define __block\n"; 5048 Preamble += "#define __weak\n"; 5049 } 5050 // NOTE! Windows uses LLP64 for 64bit mode. So, cast pointer to long long 5051 // as this avoids warning in any 64bit/32bit compilation model. 5052 Preamble += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((long long) &((TYPE *)0)->MEMBER)\n"; 5053} 5054 5055/// RewriteIvarOffsetComputation - This routine synthesizes computation of 5056/// ivar offset. 5057void RewriteObjCFragileABI::RewriteIvarOffsetComputation(ObjCIvarDecl *ivar, 5058 std::string &Result) { 5059 if (ivar->isBitField()) { 5060 // FIXME: The hack below doesn't work for bitfields. For now, we simply 5061 // place all bitfields at offset 0. 5062 Result += "0"; 5063 } else { 5064 Result += "__OFFSETOFIVAR__(struct "; 5065 Result += ivar->getContainingInterface()->getNameAsString(); 5066 if (LangOpts.MicrosoftExt) 5067 Result += "_IMPL"; 5068 Result += ", "; 5069 Result += ivar->getNameAsString(); 5070 Result += ")"; 5071 } 5072} 5073 5074/// RewriteObjCProtocolMetaData - Rewrite protocols meta-data. 5075void RewriteObjCFragileABI::RewriteObjCProtocolMetaData( 5076 ObjCProtocolDecl *PDecl, StringRef prefix, 5077 StringRef ClassName, std::string &Result) { 5078 static bool objc_protocol_methods = false; 5079 5080 // Output struct protocol_methods holder of method selector and type. 5081 if (!objc_protocol_methods && PDecl->hasDefinition()) { 5082 /* struct protocol_methods { 5083 SEL _cmd; 5084 char *method_types; 5085 } 5086 */ 5087 Result += "\nstruct _protocol_methods {\n"; 5088 Result += "\tstruct objc_selector *_cmd;\n"; 5089 Result += "\tchar *method_types;\n"; 5090 Result += "};\n"; 5091 5092 objc_protocol_methods = true; 5093 } 5094 // Do not synthesize the protocol more than once. 5095 if (ObjCSynthesizedProtocols.count(PDecl->getCanonicalDecl())) 5096 return; 5097 5098 if (ObjCProtocolDecl *Def = PDecl->getDefinition()) 5099 PDecl = Def; 5100 5101 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) { 5102 unsigned NumMethods = std::distance(PDecl->instmeth_begin(), 5103 PDecl->instmeth_end()); 5104 /* struct _objc_protocol_method_list { 5105 int protocol_method_count; 5106 struct protocol_methods protocols[]; 5107 } 5108 */ 5109 Result += "\nstatic struct {\n"; 5110 Result += "\tint protocol_method_count;\n"; 5111 Result += "\tstruct _protocol_methods protocol_methods["; 5112 Result += utostr(NumMethods); 5113 Result += "];\n} _OBJC_PROTOCOL_INSTANCE_METHODS_"; 5114 Result += PDecl->getNameAsString(); 5115 Result += " __attribute__ ((used, section (\"__OBJC, __cat_inst_meth\")))= " 5116 "{\n\t" + utostr(NumMethods) + "\n"; 5117 5118 // Output instance methods declared in this protocol. 5119 for (ObjCProtocolDecl::instmeth_iterator 5120 I = PDecl->instmeth_begin(), E = PDecl->instmeth_end(); 5121 I != E; ++I) { 5122 if (I == PDecl->instmeth_begin()) 5123 Result += "\t ,{{(struct objc_selector *)\""; 5124 else 5125 Result += "\t ,{(struct objc_selector *)\""; 5126 Result += (*I)->getSelector().getAsString(); 5127 std::string MethodTypeString = Context->getObjCEncodingForMethodDecl(*I); 5128 Result += "\", \""; 5129 Result += MethodTypeString; 5130 Result += "\"}\n"; 5131 } 5132 Result += "\t }\n};\n"; 5133 } 5134 5135 // Output class methods declared in this protocol. 5136 unsigned NumMethods = std::distance(PDecl->classmeth_begin(), 5137 PDecl->classmeth_end()); 5138 if (NumMethods > 0) { 5139 /* struct _objc_protocol_method_list { 5140 int protocol_method_count; 5141 struct protocol_methods protocols[]; 5142 } 5143 */ 5144 Result += "\nstatic struct {\n"; 5145 Result += "\tint protocol_method_count;\n"; 5146 Result += "\tstruct _protocol_methods protocol_methods["; 5147 Result += utostr(NumMethods); 5148 Result += "];\n} _OBJC_PROTOCOL_CLASS_METHODS_"; 5149 Result += PDecl->getNameAsString(); 5150 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= " 5151 "{\n\t"; 5152 Result += utostr(NumMethods); 5153 Result += "\n"; 5154 5155 // Output instance methods declared in this protocol. 5156 for (ObjCProtocolDecl::classmeth_iterator 5157 I = PDecl->classmeth_begin(), E = PDecl->classmeth_end(); 5158 I != E; ++I) { 5159 if (I == PDecl->classmeth_begin()) 5160 Result += "\t ,{{(struct objc_selector *)\""; 5161 else 5162 Result += "\t ,{(struct objc_selector *)\""; 5163 Result += (*I)->getSelector().getAsString(); 5164 std::string MethodTypeString = Context->getObjCEncodingForMethodDecl(*I); 5165 Result += "\", \""; 5166 Result += MethodTypeString; 5167 Result += "\"}\n"; 5168 } 5169 Result += "\t }\n};\n"; 5170 } 5171 5172 // Output: 5173 /* struct _objc_protocol { 5174 // Objective-C 1.0 extensions 5175 struct _objc_protocol_extension *isa; 5176 char *protocol_name; 5177 struct _objc_protocol **protocol_list; 5178 struct _objc_protocol_method_list *instance_methods; 5179 struct _objc_protocol_method_list *class_methods; 5180 }; 5181 */ 5182 static bool objc_protocol = false; 5183 if (!objc_protocol) { 5184 Result += "\nstruct _objc_protocol {\n"; 5185 Result += "\tstruct _objc_protocol_extension *isa;\n"; 5186 Result += "\tchar *protocol_name;\n"; 5187 Result += "\tstruct _objc_protocol **protocol_list;\n"; 5188 Result += "\tstruct _objc_protocol_method_list *instance_methods;\n"; 5189 Result += "\tstruct _objc_protocol_method_list *class_methods;\n"; 5190 Result += "};\n"; 5191 5192 objc_protocol = true; 5193 } 5194 5195 Result += "\nstatic struct _objc_protocol _OBJC_PROTOCOL_"; 5196 Result += PDecl->getNameAsString(); 5197 Result += " __attribute__ ((used, section (\"__OBJC, __protocol\")))= " 5198 "{\n\t0, \""; 5199 Result += PDecl->getNameAsString(); 5200 Result += "\", 0, "; 5201 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) { 5202 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_INSTANCE_METHODS_"; 5203 Result += PDecl->getNameAsString(); 5204 Result += ", "; 5205 } 5206 else 5207 Result += "0, "; 5208 if (PDecl->classmeth_begin() != PDecl->classmeth_end()) { 5209 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_CLASS_METHODS_"; 5210 Result += PDecl->getNameAsString(); 5211 Result += "\n"; 5212 } 5213 else 5214 Result += "0\n"; 5215 Result += "};\n"; 5216 5217 // Mark this protocol as having been generated. 5218 if (!ObjCSynthesizedProtocols.insert(PDecl->getCanonicalDecl()).second) 5219 llvm_unreachable("protocol already synthesized")__builtin_unreachable(); 5220} 5221 5222void RewriteObjCFragileABI::RewriteObjCProtocolListMetaData( 5223 const ObjCList<ObjCProtocolDecl> &Protocols, 5224 StringRef prefix, StringRef ClassName, 5225 std::string &Result) { 5226 if (Protocols.empty()) return; 5227 5228 for (unsigned i = 0; i != Protocols.size(); i++) 5229 RewriteObjCProtocolMetaData(Protocols[i], prefix, ClassName, Result); 5230 5231 // Output the top lovel protocol meta-data for the class. 5232 /* struct _objc_protocol_list { 5233 struct _objc_protocol_list *next; 5234 int protocol_count; 5235 struct _objc_protocol *class_protocols[]; 5236 } 5237 */ 5238 Result += "\nstatic struct {\n"; 5239 Result += "\tstruct _objc_protocol_list *next;\n"; 5240 Result += "\tint protocol_count;\n"; 5241 Result += "\tstruct _objc_protocol *class_protocols["; 5242 Result += utostr(Protocols.size()); 5243 Result += "];\n} _OBJC_"; 5244 Result += prefix; 5245 Result += "_PROTOCOLS_"; 5246 Result += ClassName; 5247 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= " 5248 "{\n\t0, "; 5249 Result += utostr(Protocols.size()); 5250 Result += "\n"; 5251 5252 Result += "\t,{&_OBJC_PROTOCOL_"; 5253 Result += Protocols[0]->getNameAsString(); 5254 Result += " \n"; 5255 5256 for (unsigned i = 1; i != Protocols.size(); i++) { 5257 Result += "\t ,&_OBJC_PROTOCOL_"; 5258 Result += Protocols[i]->getNameAsString(); 5259 Result += "\n"; 5260 } 5261 Result += "\t }\n};\n"; 5262} 5263 5264void RewriteObjCFragileABI::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl, 5265 std::string &Result) { 5266 ObjCInterfaceDecl *CDecl = IDecl->getClassInterface(); 5267 5268 // Explicitly declared @interface's are already synthesized. 5269 if (CDecl->isImplicitInterfaceDecl()) { 5270 // FIXME: Implementation of a class with no @interface (legacy) does not 5271 // produce correct synthesis as yet. 5272 RewriteObjCInternalStruct(CDecl, Result); 5273 } 5274 5275 // Build _objc_ivar_list metadata for classes ivars if needed 5276 unsigned NumIvars = 5277 !IDecl->ivar_empty() ? IDecl->ivar_size() : CDecl->ivar_size(); 5278 if (NumIvars > 0) { 5279 static bool objc_ivar = false; 5280 if (!objc_ivar) { 5281 /* struct _objc_ivar { 5282 char *ivar_name; 5283 char *ivar_type; 5284 int ivar_offset; 5285 }; 5286 */ 5287 Result += "\nstruct _objc_ivar {\n"; 5288 Result += "\tchar *ivar_name;\n"; 5289 Result += "\tchar *ivar_type;\n"; 5290 Result += "\tint ivar_offset;\n"; 5291 Result += "};\n"; 5292 5293 objc_ivar = true; 5294 } 5295 5296 /* struct { 5297 int ivar_count; 5298 struct _objc_ivar ivar_list[nIvars]; 5299 }; 5300 */ 5301 Result += "\nstatic struct {\n"; 5302 Result += "\tint ivar_count;\n"; 5303 Result += "\tstruct _objc_ivar ivar_list["; 5304 Result += utostr(NumIvars); 5305 Result += "];\n} _OBJC_INSTANCE_VARIABLES_"; 5306 Result += IDecl->getNameAsString(); 5307 Result += " __attribute__ ((used, section (\"__OBJC, __instance_vars\")))= " 5308 "{\n\t"; 5309 Result += utostr(NumIvars); 5310 Result += "\n"; 5311 5312 ObjCInterfaceDecl::ivar_iterator IVI, IVE; 5313 SmallVector<ObjCIvarDecl *, 8> IVars; 5314 if (!IDecl->ivar_empty()) { 5315 for (auto *IV : IDecl->ivars()) 5316 IVars.push_back(IV); 5317 IVI = IDecl->ivar_begin(); 5318 IVE = IDecl->ivar_end(); 5319 } else { 5320 IVI = CDecl->ivar_begin(); 5321 IVE = CDecl->ivar_end(); 5322 } 5323 Result += "\t,{{\""; 5324 Result += IVI->getNameAsString(); 5325 Result += "\", \""; 5326 std::string TmpString, StrEncoding; 5327 Context->getObjCEncodingForType(IVI->getType(), TmpString, *IVI); 5328 QuoteDoublequotes(TmpString, StrEncoding); 5329 Result += StrEncoding; 5330 Result += "\", "; 5331 RewriteIvarOffsetComputation(*IVI, Result); 5332 Result += "}\n"; 5333 for (++IVI; IVI != IVE; ++IVI) { 5334 Result += "\t ,{\""; 5335 Result += IVI->getNameAsString(); 5336 Result += "\", \""; 5337 std::string TmpString, StrEncoding; 5338 Context->getObjCEncodingForType(IVI->getType(), TmpString, *IVI); 5339 QuoteDoublequotes(TmpString, StrEncoding); 5340 Result += StrEncoding; 5341 Result += "\", "; 5342 RewriteIvarOffsetComputation(*IVI, Result); 5343 Result += "}\n"; 5344 } 5345 5346 Result += "\t }\n};\n"; 5347 } 5348 5349 // Build _objc_method_list for class's instance methods if needed 5350 SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instance_methods()); 5351 5352 // If any of our property implementations have associated getters or 5353 // setters, produce metadata for them as well. 5354 for (const auto *Prop : IDecl->property_impls()) { 5355 if (Prop->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) 5356 continue; 5357 if (!Prop->getPropertyIvarDecl()) 5358 continue; 5359 ObjCPropertyDecl *PD = Prop->getPropertyDecl(); 5360 if (!PD) 5361 continue; 5362 if (ObjCMethodDecl *Getter = Prop->getGetterMethodDecl()) 5363 if (!Getter->isDefined()) 5364 InstanceMethods.push_back(Getter); 5365 if (PD->isReadOnly()) 5366 continue; 5367 if (ObjCMethodDecl *Setter = Prop->getSetterMethodDecl()) 5368 if (!Setter->isDefined()) 5369 InstanceMethods.push_back(Setter); 5370 } 5371 RewriteObjCMethodsMetaData(InstanceMethods.begin(), InstanceMethods.end(), 5372 true, "", IDecl->getName(), Result); 5373 5374 // Build _objc_method_list for class's class methods if needed 5375 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(), 5376 false, "", IDecl->getName(), Result); 5377 5378 // Protocols referenced in class declaration? 5379 RewriteObjCProtocolListMetaData(CDecl->getReferencedProtocols(), 5380 "CLASS", CDecl->getName(), Result); 5381 5382 // Declaration of class/meta-class metadata 5383 /* struct _objc_class { 5384 struct _objc_class *isa; // or const char *root_class_name when metadata 5385 const char *super_class_name; 5386 char *name; 5387 long version; 5388 long info; 5389 long instance_size; 5390 struct _objc_ivar_list *ivars; 5391 struct _objc_method_list *methods; 5392 struct objc_cache *cache; 5393 struct objc_protocol_list *protocols; 5394 const char *ivar_layout; 5395 struct _objc_class_ext *ext; 5396 }; 5397 */ 5398 static bool objc_class = false; 5399 if (!objc_class) { 5400 Result += "\nstruct _objc_class {\n"; 5401 Result += "\tstruct _objc_class *isa;\n"; 5402 Result += "\tconst char *super_class_name;\n"; 5403 Result += "\tchar *name;\n"; 5404 Result += "\tlong version;\n"; 5405 Result += "\tlong info;\n"; 5406 Result += "\tlong instance_size;\n"; 5407 Result += "\tstruct _objc_ivar_list *ivars;\n"; 5408 Result += "\tstruct _objc_method_list *methods;\n"; 5409 Result += "\tstruct objc_cache *cache;\n"; 5410 Result += "\tstruct _objc_protocol_list *protocols;\n"; 5411 Result += "\tconst char *ivar_layout;\n"; 5412 Result += "\tstruct _objc_class_ext *ext;\n"; 5413 Result += "};\n"; 5414 objc_class = true; 5415 } 5416 5417 // Meta-class metadata generation. 5418 ObjCInterfaceDecl *RootClass = nullptr; 5419 ObjCInterfaceDecl *SuperClass = CDecl->getSuperClass(); 5420 while (SuperClass) { 5421 RootClass = SuperClass; 5422 SuperClass = SuperClass->getSuperClass(); 5423 } 5424 SuperClass = CDecl->getSuperClass(); 5425 5426 Result += "\nstatic struct _objc_class _OBJC_METACLASS_"; 5427 Result += CDecl->getNameAsString(); 5428 Result += " __attribute__ ((used, section (\"__OBJC, __meta_class\")))= " 5429 "{\n\t(struct _objc_class *)\""; 5430 Result += (RootClass ? RootClass->getNameAsString() : CDecl->getNameAsString()); 5431 Result += "\""; 5432 5433 if (SuperClass) { 5434 Result += ", \""; 5435 Result += SuperClass->getNameAsString(); 5436 Result += "\", \""; 5437 Result += CDecl->getNameAsString(); 5438 Result += "\""; 5439 } 5440 else { 5441 Result += ", 0, \""; 5442 Result += CDecl->getNameAsString(); 5443 Result += "\""; 5444 } 5445 // Set 'ivars' field for root class to 0. ObjC1 runtime does not use it. 5446 // 'info' field is initialized to CLS_META(2) for metaclass 5447 Result += ", 0,2, sizeof(struct _objc_class), 0"; 5448 if (IDecl->classmeth_begin() != IDecl->classmeth_end()) { 5449 Result += "\n\t, (struct _objc_method_list *)&_OBJC_CLASS_METHODS_"; 5450 Result += IDecl->getNameAsString(); 5451 Result += "\n"; 5452 } 5453 else 5454 Result += ", 0\n"; 5455 if (CDecl->protocol_begin() != CDecl->protocol_end()) { 5456 Result += "\t,0, (struct _objc_protocol_list *)&_OBJC_CLASS_PROTOCOLS_"; 5457 Result += CDecl->getNameAsString(); 5458 Result += ",0,0\n"; 5459 } 5460 else 5461 Result += "\t,0,0,0,0\n"; 5462 Result += "};\n"; 5463 5464 // class metadata generation. 5465 Result += "\nstatic struct _objc_class _OBJC_CLASS_"; 5466 Result += CDecl->getNameAsString(); 5467 Result += " __attribute__ ((used, section (\"__OBJC, __class\")))= " 5468 "{\n\t&_OBJC_METACLASS_"; 5469 Result += CDecl->getNameAsString(); 5470 if (SuperClass) { 5471 Result += ", \""; 5472 Result += SuperClass->getNameAsString(); 5473 Result += "\", \""; 5474 Result += CDecl->getNameAsString(); 5475 Result += "\""; 5476 } 5477 else { 5478 Result += ", 0, \""; 5479 Result += CDecl->getNameAsString(); 5480 Result += "\""; 5481 } 5482 // 'info' field is initialized to CLS_CLASS(1) for class 5483 Result += ", 0,1"; 5484 if (!ObjCSynthesizedStructs.count(CDecl)) 5485 Result += ",0"; 5486 else { 5487 // class has size. Must synthesize its size. 5488 Result += ",sizeof(struct "; 5489 Result += CDecl->getNameAsString(); 5490 if (LangOpts.MicrosoftExt) 5491 Result += "_IMPL"; 5492 Result += ")"; 5493 } 5494 if (NumIvars > 0) { 5495 Result += ", (struct _objc_ivar_list *)&_OBJC_INSTANCE_VARIABLES_"; 5496 Result += CDecl->getNameAsString(); 5497 Result += "\n\t"; 5498 } 5499 else 5500 Result += ",0"; 5501 if (IDecl->instmeth_begin() != IDecl->instmeth_end()) { 5502 Result += ", (struct _objc_method_list *)&_OBJC_INSTANCE_METHODS_"; 5503 Result += CDecl->getNameAsString(); 5504 Result += ", 0\n\t"; 5505 } 5506 else 5507 Result += ",0,0"; 5508 if (CDecl->protocol_begin() != CDecl->protocol_end()) { 5509 Result += ", (struct _objc_protocol_list*)&_OBJC_CLASS_PROTOCOLS_"; 5510 Result += CDecl->getNameAsString(); 5511 Result += ", 0,0\n"; 5512 } 5513 else 5514 Result += ",0,0,0\n"; 5515 Result += "};\n"; 5516} 5517 5518void RewriteObjCFragileABI::RewriteMetaDataIntoBuffer(std::string &Result) { 5519 int ClsDefCount = ClassImplementation.size(); 5520 int CatDefCount = CategoryImplementation.size(); 5521 5522 // For each implemented class, write out all its meta data. 5523 for (int i = 0; i < ClsDefCount; i++) 5524 RewriteObjCClassMetaData(ClassImplementation[i], Result); 5525 5526 // For each implemented category, write out all its meta data. 5527 for (int i = 0; i < CatDefCount; i++) 5528 RewriteObjCCategoryImplDecl(CategoryImplementation[i], Result); 5529 5530 // Write objc_symtab metadata 5531 /* 5532 struct _objc_symtab 5533 { 5534 long sel_ref_cnt; 5535 SEL *refs; 5536 short cls_def_cnt; 5537 short cat_def_cnt; 5538 void *defs[cls_def_cnt + cat_def_cnt]; 5539 }; 5540 */ 5541 5542 Result += "\nstruct _objc_symtab {\n"; 5543 Result += "\tlong sel_ref_cnt;\n"; 5544 Result += "\tSEL *refs;\n"; 5545 Result += "\tshort cls_def_cnt;\n"; 5546 Result += "\tshort cat_def_cnt;\n"; 5547 Result += "\tvoid *defs[" + utostr(ClsDefCount + CatDefCount)+ "];\n"; 5548 Result += "};\n\n"; 5549 5550 Result += "static struct _objc_symtab " 5551 "_OBJC_SYMBOLS __attribute__((used, section (\"__OBJC, __symbols\")))= {\n"; 5552 Result += "\t0, 0, " + utostr(ClsDefCount) 5553 + ", " + utostr(CatDefCount) + "\n"; 5554 for (int i = 0; i < ClsDefCount; i++) { 5555 Result += "\t,&_OBJC_CLASS_"; 5556 Result += ClassImplementation[i]->getNameAsString(); 5557 Result += "\n"; 5558 } 5559 5560 for (int i = 0; i < CatDefCount; i++) { 5561 Result += "\t,&_OBJC_CATEGORY_"; 5562 Result += CategoryImplementation[i]->getClassInterface()->getNameAsString(); 5563 Result += "_"; 5564 Result += CategoryImplementation[i]->getNameAsString(); 5565 Result += "\n"; 5566 } 5567 5568 Result += "};\n\n"; 5569 5570 // Write objc_module metadata 5571 5572 /* 5573 struct _objc_module { 5574 long version; 5575 long size; 5576 const char *name; 5577 struct _objc_symtab *symtab; 5578 } 5579 */ 5580 5581 Result += "\nstruct _objc_module {\n"; 5582 Result += "\tlong version;\n"; 5583 Result += "\tlong size;\n"; 5584 Result += "\tconst char *name;\n"; 5585 Result += "\tstruct _objc_symtab *symtab;\n"; 5586 Result += "};\n\n"; 5587 Result += "static struct _objc_module " 5588 "_OBJC_MODULES __attribute__ ((used, section (\"__OBJC, __module_info\")))= {\n"; 5589 Result += "\t" + utostr(OBJC_ABI_VERSION) + 5590 ", sizeof(struct _objc_module), \"\", &_OBJC_SYMBOLS\n"; 5591 Result += "};\n\n"; 5592 5593 if (LangOpts.MicrosoftExt) { 5594 if (ProtocolExprDecls.size()) { 5595 Result += "#pragma section(\".objc_protocol$B\",long,read,write)\n"; 5596 Result += "#pragma data_seg(push, \".objc_protocol$B\")\n"; 5597 for (ObjCProtocolDecl *ProtDecl : ProtocolExprDecls) { 5598 Result += "static struct _objc_protocol *_POINTER_OBJC_PROTOCOL_"; 5599 Result += ProtDecl->getNameAsString(); 5600 Result += " = &_OBJC_PROTOCOL_"; 5601 Result += ProtDecl->getNameAsString(); 5602 Result += ";\n"; 5603 } 5604 Result += "#pragma data_seg(pop)\n\n"; 5605 } 5606 Result += "#pragma section(\".objc_module_info$B\",long,read,write)\n"; 5607 Result += "#pragma data_seg(push, \".objc_module_info$B\")\n"; 5608 Result += "static struct _objc_module *_POINTER_OBJC_MODULES = "; 5609 Result += "&_OBJC_MODULES;\n"; 5610 Result += "#pragma data_seg(pop)\n\n"; 5611 } 5612} 5613 5614/// RewriteObjCCategoryImplDecl - Rewrite metadata for each category 5615/// implementation. 5616void RewriteObjCFragileABI::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl, 5617 std::string &Result) { 5618 ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface(); 5619 // Find category declaration for this implementation. 5620 ObjCCategoryDecl *CDecl 5621 = ClassDecl->FindCategoryDeclaration(IDecl->getIdentifier()); 5622 5623 std::string FullCategoryName = ClassDecl->getNameAsString(); 5624 FullCategoryName += '_'; 5625 FullCategoryName += IDecl->getNameAsString(); 5626 5627 // Build _objc_method_list for class's instance methods if needed 5628 SmallVector<ObjCMethodDecl *, 32> InstanceMethods(IDecl->instance_methods()); 5629 5630 // If any of our property implementations have associated getters or 5631 // setters, produce metadata for them as well. 5632 for (const auto *Prop : IDecl->property_impls()) { 5633 if (Prop->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic) 5634 continue; 5635 if (!Prop->getPropertyIvarDecl()) 5636 continue; 5637 ObjCPropertyDecl *PD = Prop->getPropertyDecl(); 5638 if (!PD) 5639 continue; 5640 if (ObjCMethodDecl *Getter = Prop->getGetterMethodDecl()) 5641 InstanceMethods.push_back(Getter); 5642 if (PD->isReadOnly()) 5643 continue; 5644 if (ObjCMethodDecl *Setter = Prop->getSetterMethodDecl()) 5645 InstanceMethods.push_back(Setter); 5646 } 5647 RewriteObjCMethodsMetaData(InstanceMethods.begin(), InstanceMethods.end(), 5648 true, "CATEGORY_", FullCategoryName, Result); 5649 5650 // Build _objc_method_list for class's class methods if needed 5651 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(), 5652 false, "CATEGORY_", FullCategoryName, Result); 5653 5654 // Protocols referenced in class declaration? 5655 // Null CDecl is case of a category implementation with no category interface 5656 if (CDecl) 5657 RewriteObjCProtocolListMetaData(CDecl->getReferencedProtocols(), "CATEGORY", 5658 FullCategoryName, Result); 5659 /* struct _objc_category { 5660 char *category_name; 5661 char *class_name; 5662 struct _objc_method_list *instance_methods; 5663 struct _objc_method_list *class_methods; 5664 struct _objc_protocol_list *protocols; 5665 // Objective-C 1.0 extensions 5666 uint32_t size; // sizeof (struct _objc_category) 5667 struct _objc_property_list *instance_properties; // category's own 5668 // @property decl. 5669 }; 5670 */ 5671 5672 static bool objc_category = false; 5673 if (!objc_category) { 5674 Result += "\nstruct _objc_category {\n"; 5675 Result += "\tchar *category_name;\n"; 5676 Result += "\tchar *class_name;\n"; 5677 Result += "\tstruct _objc_method_list *instance_methods;\n"; 5678 Result += "\tstruct _objc_method_list *class_methods;\n"; 5679 Result += "\tstruct _objc_protocol_list *protocols;\n"; 5680 Result += "\tunsigned int size;\n"; 5681 Result += "\tstruct _objc_property_list *instance_properties;\n"; 5682 Result += "};\n"; 5683 objc_category = true; 5684 } 5685 Result += "\nstatic struct _objc_category _OBJC_CATEGORY_"; 5686 Result += FullCategoryName; 5687 Result += " __attribute__ ((used, section (\"__OBJC, __category\")))= {\n\t\""; 5688 Result += IDecl->getNameAsString(); 5689 Result += "\"\n\t, \""; 5690 Result += ClassDecl->getNameAsString(); 5691 Result += "\"\n"; 5692 5693 if (IDecl->instmeth_begin() != IDecl->instmeth_end()) { 5694 Result += "\t, (struct _objc_method_list *)" 5695 "&_OBJC_CATEGORY_INSTANCE_METHODS_"; 5696 Result += FullCategoryName; 5697 Result += "\n"; 5698 } 5699 else 5700 Result += "\t, 0\n"; 5701 if (IDecl->classmeth_begin() != IDecl->classmeth_end()) { 5702 Result += "\t, (struct _objc_method_list *)" 5703 "&_OBJC_CATEGORY_CLASS_METHODS_"; 5704 Result += FullCategoryName; 5705 Result += "\n"; 5706 } 5707 else 5708 Result += "\t, 0\n"; 5709 5710 if (CDecl && CDecl->protocol_begin() != CDecl->protocol_end()) { 5711 Result += "\t, (struct _objc_protocol_list *)&_OBJC_CATEGORY_PROTOCOLS_"; 5712 Result += FullCategoryName; 5713 Result += "\n"; 5714 } 5715 else 5716 Result += "\t, 0\n"; 5717 Result += "\t, sizeof(struct _objc_category), 0\n};\n"; 5718} 5719 5720// RewriteObjCMethodsMetaData - Rewrite methods metadata for instance or 5721/// class methods. 5722template<typename MethodIterator> 5723void RewriteObjCFragileABI::RewriteObjCMethodsMetaData(MethodIterator MethodBegin, 5724 MethodIterator MethodEnd, 5725 bool IsInstanceMethod, 5726 StringRef prefix, 5727 StringRef ClassName, 5728 std::string &Result) { 5729 if (MethodBegin == MethodEnd) return; 5730 5731 if (!objc_impl_method) { 5732 /* struct _objc_method { 5733 SEL _cmd; 5734 char *method_types; 5735 void *_imp; 5736 } 5737 */ 5738 Result += "\nstruct _objc_method {\n"; 5739 Result += "\tSEL _cmd;\n"; 5740 Result += "\tchar *method_types;\n"; 5741 Result += "\tvoid *_imp;\n"; 5742 Result += "};\n"; 5743 5744 objc_impl_method = true; 5745 } 5746 5747 // Build _objc_method_list for class's methods if needed 5748 5749 /* struct { 5750 struct _objc_method_list *next_method; 5751 int method_count; 5752 struct _objc_method method_list[]; 5753 } 5754 */ 5755 unsigned NumMethods = std::distance(MethodBegin, MethodEnd); 5756 Result += "\nstatic struct {\n"; 5757 Result += "\tstruct _objc_method_list *next_method;\n"; 5758 Result += "\tint method_count;\n"; 5759 Result += "\tstruct _objc_method method_list["; 5760 Result += utostr(NumMethods); 5761 Result += "];\n} _OBJC_"; 5762 Result += prefix; 5763 Result += IsInstanceMethod ? "INSTANCE" : "CLASS"; 5764 Result += "_METHODS_"; 5765 Result += ClassName; 5766 Result += " __attribute__ ((used, section (\"__OBJC, __"; 5767 Result += IsInstanceMethod ? "inst" : "cls"; 5768 Result += "_meth\")))= "; 5769 Result += "{\n\t0, " + utostr(NumMethods) + "\n"; 5770 5771 Result += "\t,{{(SEL)\""; 5772 Result += (*MethodBegin)->getSelector().getAsString(); 5773 std::string MethodTypeString = 5774 Context->getObjCEncodingForMethodDecl(*MethodBegin); 5775 Result += "\", \""; 5776 Result += MethodTypeString; 5777 Result += "\", (void *)"; 5778 Result += MethodInternalNames[*MethodBegin]; 5779 Result += "}\n"; 5780 for (++MethodBegin; MethodBegin != MethodEnd; ++MethodBegin) { 5781 Result += "\t ,{(SEL)\""; 5782 Result += (*MethodBegin)->getSelector().getAsString(); 5783 std::string MethodTypeString = 5784 Context->getObjCEncodingForMethodDecl(*MethodBegin); 5785 Result += "\", \""; 5786 Result += MethodTypeString; 5787 Result += "\", (void *)"; 5788 Result += MethodInternalNames[*MethodBegin]; 5789 Result += "}\n"; 5790 } 5791 Result += "\t }\n};\n"; 5792} 5793 5794Stmt *RewriteObjCFragileABI::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV) { 5795 SourceRange OldRange = IV->getSourceRange(); 5796 Expr *BaseExpr = IV->getBase(); 5797 5798 // Rewrite the base, but without actually doing replaces. 5799 { 5800 DisableReplaceStmtScope S(*this); 5801 BaseExpr = cast<Expr>(RewriteFunctionBodyOrGlobalInitializer(BaseExpr));

Calling 'RewriteObjC::RewriteFunctionBodyOrGlobalInitializer'

→

5802 IV->setBase(BaseExpr); 5803 } 5804 5805 ObjCIvarDecl *D = IV->getDecl(); 5806 5807 Expr *Replacement = IV; 5808 if (CurMethodDef) { 5809 if (BaseExpr->getType()->isObjCObjectPointerType()) { 5810 const ObjCInterfaceType *iFaceDecl = 5811 dyn_cast<ObjCInterfaceType>(BaseExpr->getType()->getPointeeType()); 5812 assert(iFaceDecl && "RewriteObjCIvarRefExpr - iFaceDecl is null")(static_cast<void> (0)); 5813 // lookup which class implements the instance variable. 5814 ObjCInterfaceDecl *clsDeclared = nullptr; 5815 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), 5816 clsDeclared); 5817 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class")(static_cast<void> (0)); 5818 5819 // Synthesize an explicit cast to gain access to the ivar. 5820 std::string RecName = 5821 std::string(clsDeclared->getIdentifier()->getName()); 5822 RecName += "_IMPL"; 5823 IdentifierInfo *II = &Context->Idents.get(RecName); 5824 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl, 5825 SourceLocation(), SourceLocation(), 5826 II); 5827 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl")(static_cast<void> (0)); 5828 QualType castT = Context->getPointerType(Context->getTagDeclType(RD)); 5829 CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, castT, 5830 CK_BitCast, 5831 IV->getBase()); 5832 // Don't forget the parens to enforce the proper binding. 5833 ParenExpr *PE = new (Context) ParenExpr(OldRange.getBegin(), 5834 OldRange.getEnd(), 5835 castExpr); 5836 if (IV->isFreeIvar() && 5837 declaresSameEntity(CurMethodDef->getClassInterface(), 5838 iFaceDecl->getDecl())) { 5839 MemberExpr *ME = MemberExpr::CreateImplicit( 5840 *Context, PE, true, D, D->getType(), VK_LValue, OK_Ordinary); 5841 Replacement = ME; 5842 } else { 5843 IV->setBase(PE); 5844 } 5845 } 5846 } else { // we are outside a method. 5847 assert(!IV->isFreeIvar() && "Cannot have a free standing ivar outside a method")(static_cast<void> (0)); 5848 5849 // Explicit ivar refs need to have a cast inserted. 5850 // FIXME: consider sharing some of this code with the code above. 5851 if (BaseExpr->getType()->isObjCObjectPointerType()) { 5852 const ObjCInterfaceType *iFaceDecl = 5853 dyn_cast<ObjCInterfaceType>(BaseExpr->getType()->getPointeeType()); 5854 // lookup which class implements the instance variable. 5855 ObjCInterfaceDecl *clsDeclared = nullptr; 5856 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), 5857 clsDeclared); 5858 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class")(static_cast<void> (0)); 5859 5860 // Synthesize an explicit cast to gain access to the ivar. 5861 std::string RecName = 5862 std::string(clsDeclared->getIdentifier()->getName()); 5863 RecName += "_IMPL"; 5864 IdentifierInfo *II = &Context->Idents.get(RecName); 5865 RecordDecl *RD = RecordDecl::Create(*Context, TTK_Struct, TUDecl, 5866 SourceLocation(), SourceLocation(), 5867 II); 5868 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl")(static_cast<void> (0)); 5869 QualType castT = Context->getPointerType(Context->getTagDeclType(RD)); 5870 CastExpr *castExpr = NoTypeInfoCStyleCastExpr(Context, castT, 5871 CK_BitCast, 5872 IV->getBase()); 5873 // Don't forget the parens to enforce the proper binding. 5874 ParenExpr *PE = new (Context) ParenExpr( 5875 IV->getBase()->getBeginLoc(), IV->getBase()->getEndLoc(), castExpr); 5876 // Cannot delete IV->getBase(), since PE points to it. 5877 // Replace the old base with the cast. This is important when doing 5878 // embedded rewrites. For example, [newInv->_container addObject:0]. 5879 IV->setBase(PE); 5880 } 5881 } 5882 5883 ReplaceStmtWithRange(IV, Replacement, OldRange); 5884 return Replacement; 5885} 5886 5887#endif // CLANG_ENABLE_OBJC_REWRITER