blob: 65e8841ec79340480d8ef00e7d4aeb507a0c3e55 [file] [log] [blame]
Steve Naroffb29b4272008-04-14 22:03:09 +00001//===--- RewriteObjC.cpp - Playground for the code rewriter ---------------===//
Chris Lattner77cd2a02007-10-11 00:43:27 +00002//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner77cd2a02007-10-11 00:43:27 +00007//
8//===----------------------------------------------------------------------===//
9//
10// Hacks and fun related to the code rewriter.
11//
12//===----------------------------------------------------------------------===//
13
14#include "ASTConsumers.h"
Chris Lattner8a12c272007-10-11 18:38:32 +000015#include "clang/Rewrite/Rewriter.h"
Chris Lattner77cd2a02007-10-11 00:43:27 +000016#include "clang/AST/AST.h"
17#include "clang/AST/ASTConsumer.h"
Ted Kremeneke3a61982008-05-31 20:11:04 +000018#include "clang/AST/TranslationUnit.h"
Chris Lattner8a12c272007-10-11 18:38:32 +000019#include "clang/Basic/SourceManager.h"
Steve Naroffebf2b562007-10-23 23:50:29 +000020#include "clang/Basic/IdentifierTable.h"
Chris Lattner07506182007-11-30 22:53:43 +000021#include "clang/Basic/Diagnostic.h"
Chris Lattner26de4652007-12-02 01:13:47 +000022#include "clang/Lex/Lexer.h"
Chris Lattner158ecb92007-10-25 17:07:24 +000023#include "llvm/ADT/StringExtras.h"
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +000024#include "llvm/ADT/SmallPtrSet.h"
Ted Kremeneka95d3752008-09-13 05:16:45 +000025#include "llvm/ADT/OwningPtr.h"
Chris Lattner26de4652007-12-02 01:13:47 +000026#include "llvm/Support/MemoryBuffer.h"
Steve Naroff0113c9d2008-01-28 21:34:52 +000027#include "llvm/Support/CommandLine.h"
Dan Gohman63e2dcc2008-05-21 20:19:16 +000028#include "llvm/Support/Streams.h"
Ted Kremeneka95d3752008-09-13 05:16:45 +000029#include "llvm/Support/raw_ostream.h"
Chris Lattnerc68ab772008-03-22 00:08:40 +000030#include "llvm/System/Path.h"
Chris Lattner77cd2a02007-10-11 00:43:27 +000031using namespace clang;
Chris Lattner158ecb92007-10-25 17:07:24 +000032using llvm::utostr;
Chris Lattner77cd2a02007-10-11 00:43:27 +000033
Steve Naroff0113c9d2008-01-28 21:34:52 +000034static llvm::cl::opt<bool>
35SilenceRewriteMacroWarning("Wno-rewrite-macros", llvm::cl::init(false),
36 llvm::cl::desc("Silence ObjC rewriting warnings"));
37
Chris Lattner77cd2a02007-10-11 00:43:27 +000038namespace {
Steve Naroffb29b4272008-04-14 22:03:09 +000039 class RewriteObjC : public ASTConsumer {
Chris Lattner2c64b7b2007-10-16 21:07:07 +000040 Rewriter Rewrite;
Chris Lattnere365c502007-11-30 22:25:36 +000041 Diagnostic &Diags;
Steve Naroff4f943c22008-03-10 20:43:59 +000042 const LangOptions &LangOpts;
Steve Narofff69cc5d2008-01-30 19:17:43 +000043 unsigned RewriteFailedDiag;
44
Chris Lattner01c57482007-10-17 22:35:30 +000045 ASTContext *Context;
Chris Lattner77cd2a02007-10-11 00:43:27 +000046 SourceManager *SM;
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +000047 TranslationUnitDecl *TUDecl;
Chris Lattner8a12c272007-10-11 18:38:32 +000048 unsigned MainFileID;
Chris Lattner26de4652007-12-02 01:13:47 +000049 const char *MainFileStart, *MainFileEnd;
Chris Lattner2c64b7b2007-10-16 21:07:07 +000050 SourceLocation LastIncLoc;
Steve Naroffba92b2e2008-03-27 22:29:16 +000051
Ted Kremeneka526c5c2008-01-07 19:49:32 +000052 llvm::SmallVector<ObjCImplementationDecl *, 8> ClassImplementation;
53 llvm::SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation;
54 llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs;
Steve Narofffbfe8252008-05-06 18:26:51 +000055 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000056 llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCForwardDecls;
57 llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +000058 llvm::SmallVector<Stmt *, 32> Stmts;
59 llvm::SmallVector<int, 8> ObjCBcLabelNo;
Steve Naroffebf2b562007-10-23 23:50:29 +000060
Steve Naroffd82a9ab2008-03-15 00:55:56 +000061 unsigned NumObjCStringLiterals;
62
Steve Naroffebf2b562007-10-23 23:50:29 +000063 FunctionDecl *MsgSendFunctionDecl;
Steve Naroff874e2322007-11-15 10:28:18 +000064 FunctionDecl *MsgSendSuperFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +000065 FunctionDecl *MsgSendStretFunctionDecl;
66 FunctionDecl *MsgSendSuperStretFunctionDecl;
Fariborz Jahanianacb49772007-12-03 21:26:48 +000067 FunctionDecl *MsgSendFpretFunctionDecl;
Steve Naroffebf2b562007-10-23 23:50:29 +000068 FunctionDecl *GetClassFunctionDecl;
Steve Naroff9bcb5fc2007-12-07 03:50:46 +000069 FunctionDecl *GetMetaClassFunctionDecl;
Steve Naroff934f2762007-10-24 22:48:43 +000070 FunctionDecl *SelGetUidFunctionDecl;
Steve Naroff96984642007-11-08 14:30:50 +000071 FunctionDecl *CFStringFunctionDecl;
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +000072 FunctionDecl *GetProtocolFunctionDecl;
Steve Naroffc0a123c2008-03-11 17:37:02 +000073 FunctionDecl *SuperContructorFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +000074
Steve Naroffbeaf2992007-11-03 11:27:19 +000075 // ObjC string constant support.
Steve Naroff248a7532008-04-15 22:42:06 +000076 VarDecl *ConstantStringClassReference;
Steve Naroffbeaf2992007-11-03 11:27:19 +000077 RecordDecl *NSStringRecord;
Steve Naroffab972d32007-11-04 22:37:50 +000078
Fariborz Jahanianb586cce2008-01-16 00:09:11 +000079 // ObjC foreach break/continue generation support.
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +000080 int BcLabelCount;
81
Steve Naroff874e2322007-11-15 10:28:18 +000082 // Needed for super.
Steve Naroff54055232008-10-27 17:20:55 +000083 ObjCMethodDecl *CurMethodDef;
Steve Naroff874e2322007-11-15 10:28:18 +000084 RecordDecl *SuperStructDecl;
Steve Naroffd82a9ab2008-03-15 00:55:56 +000085 RecordDecl *ConstantStringDecl;
Steve Naroff874e2322007-11-15 10:28:18 +000086
Fariborz Jahanianb4b2f0c2008-01-18 01:15:54 +000087 // Needed for header files being rewritten
88 bool IsHeader;
89
Steve Naroffa7b402d2008-03-28 22:26:09 +000090 std::string InFileName;
91 std::string OutFileName;
92
Steve Naroffba92b2e2008-03-27 22:29:16 +000093 std::string Preamble;
Steve Naroff54055232008-10-27 17:20:55 +000094
95 // Block expressions.
96 llvm::SmallVector<BlockExpr *, 32> Blocks;
97 llvm::SmallVector<BlockDeclRefExpr *, 32> BlockDeclRefs;
98 llvm::DenseMap<BlockDeclRefExpr *, CallExpr *> BlockCallExprs;
Steve Naroffba92b2e2008-03-27 22:29:16 +000099
Steve Naroff54055232008-10-27 17:20:55 +0000100 // Block related declarations.
101 llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDecls;
102 llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDecls;
103 llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls;
104
105 llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;
106
107 FunctionDecl *CurFunctionDef;
Steve Naroff8e2f57a2008-10-29 18:15:37 +0000108 VarDecl *GlobalVarDecl;
109
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +0000110 static const int OBJC_ABI_VERSION =7 ;
Chris Lattner77cd2a02007-10-11 00:43:27 +0000111 public:
Ted Kremeneke3a61982008-05-31 20:11:04 +0000112 virtual void Initialize(ASTContext &context);
113
114 virtual void InitializeTU(TranslationUnit &TU) {
115 TU.SetOwnsDecls(false);
116 Initialize(TU.getContext());
117 }
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000118
Chris Lattner8a12c272007-10-11 18:38:32 +0000119
Chris Lattnerf04da132007-10-24 17:06:59 +0000120 // Top Level Driver code.
121 virtual void HandleTopLevelDecl(Decl *D);
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000122 void HandleDeclInMainFile(Decl *D);
Steve Naroffb29b4272008-04-14 22:03:09 +0000123 RewriteObjC(std::string inFile, std::string outFile,
Steve Naroffa7b402d2008-03-28 22:26:09 +0000124 Diagnostic &D, const LangOptions &LOpts);
Ted Kremeneke452e0f2008-08-08 04:15:52 +0000125
126 ~RewriteObjC() {}
127
128 virtual void HandleTranslationUnit(TranslationUnit& TU);
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000129
130 void ReplaceStmt(Stmt *Old, Stmt *New) {
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000131 // If replacement succeeded or warning disabled return with no warning.
132 if (!Rewrite.ReplaceStmt(Old, New) || SilenceRewriteMacroWarning)
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000133 return;
134
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000135 SourceRange Range = Old->getSourceRange();
136 Diags.Report(Context->getFullLoc(Old->getLocStart()), RewriteFailedDiag,
137 0, 0, &Range, 1);
138 }
139
Steve Naroffba92b2e2008-03-27 22:29:16 +0000140 void InsertText(SourceLocation Loc, const char *StrData, unsigned StrLen,
141 bool InsertAfter = true) {
Chris Lattneraadaf782008-01-31 19:51:04 +0000142 // If insertion succeeded or warning disabled return with no warning.
Steve Naroffba92b2e2008-03-27 22:29:16 +0000143 if (!Rewrite.InsertText(Loc, StrData, StrLen, InsertAfter) ||
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000144 SilenceRewriteMacroWarning)
145 return;
146
147 Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
148 }
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000149
Chris Lattneraadaf782008-01-31 19:51:04 +0000150 void RemoveText(SourceLocation Loc, unsigned StrLen) {
151 // If removal succeeded or warning disabled return with no warning.
152 if (!Rewrite.RemoveText(Loc, StrLen) || SilenceRewriteMacroWarning)
153 return;
154
155 Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
156 }
Chris Lattnerf04da132007-10-24 17:06:59 +0000157
Chris Lattneraadaf782008-01-31 19:51:04 +0000158 void ReplaceText(SourceLocation Start, unsigned OrigLength,
159 const char *NewStr, unsigned NewLength) {
160 // If removal succeeded or warning disabled return with no warning.
161 if (!Rewrite.ReplaceText(Start, OrigLength, NewStr, NewLength) ||
162 SilenceRewriteMacroWarning)
163 return;
164
165 Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag);
166 }
167
Chris Lattnerf04da132007-10-24 17:06:59 +0000168 // Syntactic Rewriting.
Steve Naroffab972d32007-11-04 22:37:50 +0000169 void RewritePrologue(SourceLocation Loc);
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000170 void RewriteInclude();
Chris Lattnerf04da132007-10-24 17:06:59 +0000171 void RewriteTabs();
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000172 void RewriteForwardClassDecl(ObjCClassDecl *Dcl);
173 void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl);
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000174 void RewriteImplementationDecl(NamedDecl *Dcl);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000175 void RewriteObjCMethodDecl(ObjCMethodDecl *MDecl, std::string &ResultStr);
176 void RewriteCategoryDecl(ObjCCategoryDecl *Dcl);
177 void RewriteProtocolDecl(ObjCProtocolDecl *Dcl);
178 void RewriteForwardProtocolDecl(ObjCForwardProtocolDecl *Dcl);
179 void RewriteMethodDeclaration(ObjCMethodDecl *Method);
Chris Lattner55d13b42008-03-16 21:23:50 +0000180 void RewriteProperties(unsigned nProperties, ObjCPropertyDecl **Properties);
Steve Naroff09b266e2007-10-30 23:14:51 +0000181 void RewriteFunctionDecl(FunctionDecl *FD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000182 void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl);
Steve Naroff4f95b752008-07-29 18:15:38 +0000183 void RewriteObjCQualifiedInterfaceTypes(Expr *E);
Steve Naroffd5255f52007-11-01 13:24:47 +0000184 bool needToScanForQualifiers(QualType T);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000185 ObjCInterfaceDecl *isSuperReceiver(Expr *recExpr);
Steve Naroff874e2322007-11-15 10:28:18 +0000186 QualType getSuperStructType();
Steve Naroffd82a9ab2008-03-15 00:55:56 +0000187 QualType getConstantStringStructType();
Steve Naroffbaf58c32008-05-31 14:15:04 +0000188 bool BufferContainsPPDirectives(const char *startBuf, const char *endBuf);
Chris Lattner311ff022007-10-16 22:36:42 +0000189
Chris Lattnerf04da132007-10-24 17:06:59 +0000190 // Expression Rewriting.
Steve Narofff3473a72007-11-09 15:20:18 +0000191 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
Chris Lattnere64b7772007-10-24 16:57:36 +0000192 Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
Chris Lattner3b2c58c2008-05-23 20:40:52 +0000193 Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation OrigStart);
Steve Naroffb42f8412007-11-05 14:50:49 +0000194 Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
Chris Lattnere64b7772007-10-24 16:57:36 +0000195 Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
Steve Naroffbeaf2992007-11-03 11:27:19 +0000196 Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +0000197 Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000198 Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
Fariborz Jahaniana0f55792008-01-29 22:59:37 +0000199 Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000200 Stmt *RewriteObjCCatchStmt(ObjCAtCatchStmt *S);
201 Stmt *RewriteObjCFinallyStmt(ObjCAtFinallyStmt *S);
202 Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
Chris Lattner338d1e22008-01-31 05:10:40 +0000203 Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
204 SourceLocation OrigEnd);
Steve Naroff934f2762007-10-24 22:48:43 +0000205 CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
206 Expr **args, unsigned nargs);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +0000207 Stmt *SynthMessageExpr(ObjCMessageExpr *Exp);
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +0000208 Stmt *RewriteBreakStmt(BreakStmt *S);
209 Stmt *RewriteContinueStmt(ContinueStmt *S);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +0000210 void SynthCountByEnumWithState(std::string &buf);
211
Steve Naroff09b266e2007-10-30 23:14:51 +0000212 void SynthMsgSendFunctionDecl();
Steve Naroff874e2322007-11-15 10:28:18 +0000213 void SynthMsgSendSuperFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +0000214 void SynthMsgSendStretFunctionDecl();
Fariborz Jahanianacb49772007-12-03 21:26:48 +0000215 void SynthMsgSendFpretFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +0000216 void SynthMsgSendSuperStretFunctionDecl();
Steve Naroff09b266e2007-10-30 23:14:51 +0000217 void SynthGetClassFunctionDecl();
Steve Naroff9bcb5fc2007-12-07 03:50:46 +0000218 void SynthGetMetaClassFunctionDecl();
Fariborz Jahaniana70711b2007-12-04 21:47:40 +0000219 void SynthSelGetUidFunctionDecl();
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +0000220 void SynthGetProtocolFunctionDecl();
Steve Naroffc0a123c2008-03-11 17:37:02 +0000221 void SynthSuperContructorFunctionDecl();
Steve Naroff96984642007-11-08 14:30:50 +0000222
Chris Lattnerf04da132007-10-24 17:06:59 +0000223 // Metadata emission.
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000224 void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +0000225 std::string &Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000226
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000227 void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +0000228 std::string &Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000229
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000230 typedef ObjCCategoryImplDecl::instmeth_iterator instmeth_iterator;
231 void RewriteObjCMethodsMetaData(instmeth_iterator MethodBegin,
Chris Lattnerab4c4d52007-12-12 07:46:12 +0000232 instmeth_iterator MethodEnd,
Fariborz Jahanian8e991ba2007-10-25 00:14:44 +0000233 bool IsInstanceMethod,
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000234 const char *prefix,
Chris Lattner158ecb92007-10-25 17:07:24 +0000235 const char *ClassName,
236 std::string &Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000237
Chris Lattner780f3292008-07-21 21:32:27 +0000238 void RewriteObjCProtocolsMetaData(const ObjCList<ObjCProtocolDecl>
239 &Protocols,
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000240 const char *prefix,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +0000241 const char *ClassName,
242 std::string &Result);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000243 void SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +0000244 std::string &Result);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000245 void SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl,
246 ObjCIvarDecl *ivar,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +0000247 std::string &Result);
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +0000248 void RewriteImplementations(std::string &Result);
Steve Naroff54055232008-10-27 17:20:55 +0000249
250 // Block rewriting.
251 void RewriteBlocksInFunctionTypeProto(QualType funcType, NamedDecl *D);
252 void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
253
254 void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);
255 void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD);
256
Steve Naroff8e2f57a2008-10-29 18:15:37 +0000257 // Block specific rewrite rules.
Steve Naroff54055232008-10-27 17:20:55 +0000258 void RewriteBlockCall(CallExpr *Exp);
259 void RewriteBlockPointerDecl(NamedDecl *VD);
260 void RewriteBlockDeclRefExpr(BlockDeclRefExpr *VD);
261 void RewriteBlockPointerFunctionArgs(FunctionDecl *FD);
262
263 std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
264 const char *funcName, std::string Tag);
265 std::string SynthesizeBlockFunc(BlockExpr *CE, int i,
266 const char *funcName, std::string Tag);
267 std::string SynthesizeBlockImpl(BlockExpr *CE, std::string Tag,
268 bool hasCopyDisposeHelpers);
Steve Naroffaa4d5ae2008-10-30 10:07:53 +0000269 Stmt *SynthesizeBlockCall(CallExpr *Exp);
Steve Naroff54055232008-10-27 17:20:55 +0000270 void SynthesizeBlockLiterals(SourceLocation FunLocStart,
271 const char *FunName);
272
273 void CollectBlockDeclRefInfo(BlockExpr *Exp);
274 void GetBlockCallExprs(Stmt *S);
275 void GetBlockDeclRefExprs(Stmt *S);
276
277 // We avoid calling Type::isBlockPointerType(), since it operates on the
278 // canonical type. We only care if the top-level type is a closure pointer.
279 bool isBlockPointerType(QualType T) { return isa<BlockPointerType>(T); }
280
281 // FIXME: This predicate seems like it would be useful to add to ASTContext.
282 bool isObjCType(QualType T) {
283 if (!LangOpts.ObjC1 && !LangOpts.ObjC2)
284 return false;
285
286 QualType OCT = Context->getCanonicalType(T).getUnqualifiedType();
287
288 if (OCT == Context->getCanonicalType(Context->getObjCIdType()) ||
289 OCT == Context->getCanonicalType(Context->getObjCClassType()))
290 return true;
291
292 if (const PointerType *PT = OCT->getAsPointerType()) {
293 if (isa<ObjCInterfaceType>(PT->getPointeeType()) ||
294 isa<ObjCQualifiedIdType>(PT->getPointeeType()))
295 return true;
296 }
297 return false;
298 }
299 bool PointerTypeTakesAnyBlockArguments(QualType QT);
300 void GetExtentOfArgList(const char *Name, const char *&LParen, const char *&RParen);
Steve Naroffb2f9e512008-11-03 23:29:32 +0000301 void RewriteCastExpr(CStyleCastExpr *CE);
Steve Narofffa15fd92008-10-28 20:29:00 +0000302
303 FunctionDecl *SynthBlockInitFunctionDecl(const char *name);
Steve Naroff8e2f57a2008-10-29 18:15:37 +0000304 Stmt *SynthBlockInitExpr(BlockExpr *Exp);
Chris Lattner77cd2a02007-10-11 00:43:27 +0000305 };
306}
307
Steve Naroff54055232008-10-27 17:20:55 +0000308void RewriteObjC::RewriteBlocksInFunctionTypeProto(QualType funcType,
309 NamedDecl *D) {
310 if (FunctionTypeProto *fproto = dyn_cast<FunctionTypeProto>(funcType)) {
311 for (FunctionTypeProto::arg_type_iterator I = fproto->arg_type_begin(),
312 E = fproto->arg_type_end(); I && (I != E); ++I)
313 if (isBlockPointerType(*I)) {
314 // All the args are checked/rewritten. Don't call twice!
315 RewriteBlockPointerDecl(D);
316 break;
317 }
318 }
319}
320
321void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
322 const PointerType *PT = funcType->getAsPointerType();
323 if (PT && PointerTypeTakesAnyBlockArguments(funcType))
324 RewriteBlocksInFunctionTypeProto(PT->getPointeeType(), ND);
325}
326
Fariborz Jahanianb4b2f0c2008-01-18 01:15:54 +0000327static bool IsHeaderFile(const std::string &Filename) {
328 std::string::size_type DotPos = Filename.rfind('.');
329
330 if (DotPos == std::string::npos) {
331 // no file extension
332 return false;
333 }
334
335 std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end());
336 // C header: .h
337 // C++ header: .hh or .H;
338 return Ext == "h" || Ext == "hh" || Ext == "H";
339}
340
Steve Naroffb29b4272008-04-14 22:03:09 +0000341RewriteObjC::RewriteObjC(std::string inFile, std::string outFile,
Steve Naroffa7b402d2008-03-28 22:26:09 +0000342 Diagnostic &D, const LangOptions &LOpts)
343 : Diags(D), LangOpts(LOpts) {
344 IsHeader = IsHeaderFile(inFile);
345 InFileName = inFile;
346 OutFileName = outFile;
347 RewriteFailedDiag = Diags.getCustomDiagID(Diagnostic::Warning,
348 "rewriting sub-expression within a macro (may not be correct)");
349}
350
Fariborz Jahanianb4b2f0c2008-01-18 01:15:54 +0000351ASTConsumer *clang::CreateCodeRewriterTest(const std::string& InFile,
Chris Lattnerc68ab772008-03-22 00:08:40 +0000352 const std::string& OutFile,
Steve Naroff4f943c22008-03-10 20:43:59 +0000353 Diagnostic &Diags,
354 const LangOptions &LOpts) {
Steve Naroffb29b4272008-04-14 22:03:09 +0000355 return new RewriteObjC(InFile, OutFile, Diags, LOpts);
Chris Lattnere365c502007-11-30 22:25:36 +0000356}
Chris Lattner77cd2a02007-10-11 00:43:27 +0000357
Steve Naroffb29b4272008-04-14 22:03:09 +0000358void RewriteObjC::Initialize(ASTContext &context) {
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000359 Context = &context;
360 SM = &Context->getSourceManager();
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +0000361 TUDecl = Context->getTranslationUnitDecl();
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000362 MsgSendFunctionDecl = 0;
363 MsgSendSuperFunctionDecl = 0;
364 MsgSendStretFunctionDecl = 0;
365 MsgSendSuperStretFunctionDecl = 0;
366 MsgSendFpretFunctionDecl = 0;
367 GetClassFunctionDecl = 0;
368 GetMetaClassFunctionDecl = 0;
369 SelGetUidFunctionDecl = 0;
370 CFStringFunctionDecl = 0;
371 GetProtocolFunctionDecl = 0;
372 ConstantStringClassReference = 0;
373 NSStringRecord = 0;
Steve Naroff54055232008-10-27 17:20:55 +0000374 CurMethodDef = 0;
375 CurFunctionDef = 0;
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000376 SuperStructDecl = 0;
Steve Naroff9630ec52008-03-27 22:59:54 +0000377 ConstantStringDecl = 0;
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000378 BcLabelCount = 0;
Steve Naroffc0a123c2008-03-11 17:37:02 +0000379 SuperContructorFunctionDecl = 0;
Steve Naroffd82a9ab2008-03-15 00:55:56 +0000380 NumObjCStringLiterals = 0;
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000381
382 // Get the ID and start/end of the main file.
383 MainFileID = SM->getMainFileID();
384 const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID);
385 MainFileStart = MainBuf->getBufferStart();
386 MainFileEnd = MainBuf->getBufferEnd();
Steve Naroffba92b2e2008-03-27 22:29:16 +0000387
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000388 Rewrite.setSourceMgr(Context->getSourceManager());
Steve Naroff61ed9ca2008-03-10 23:16:54 +0000389
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000390 // declaring objc_selector outside the parameter list removes a silly
391 // scope related warning...
Steve Naroffba92b2e2008-03-27 22:29:16 +0000392 if (IsHeader)
393 Preamble = "#pragma once\n";
394 Preamble += "struct objc_selector; struct objc_class;\n";
395 Preamble += "#ifndef OBJC_SUPER\n";
396 Preamble += "struct objc_super { struct objc_object *object; ";
397 Preamble += "struct objc_object *superClass; ";
Steve Naroffc0a123c2008-03-11 17:37:02 +0000398 if (LangOpts.Microsoft) {
399 // Add a constructor for creating temporary objects.
Steve Naroffba92b2e2008-03-27 22:29:16 +0000400 Preamble += "objc_super(struct objc_object *o, struct objc_object *s) : ";
401 Preamble += "object(o), superClass(s) {} ";
Steve Naroffc0a123c2008-03-11 17:37:02 +0000402 }
Steve Naroffba92b2e2008-03-27 22:29:16 +0000403 Preamble += "};\n";
404 Preamble += "#define OBJC_SUPER\n";
405 Preamble += "#endif\n";
406 Preamble += "#ifndef _REWRITER_typedef_Protocol\n";
407 Preamble += "typedef struct objc_object Protocol;\n";
408 Preamble += "#define _REWRITER_typedef_Protocol\n";
409 Preamble += "#endif\n";
Steve Naroff3c64d9e2008-03-12 13:19:12 +0000410 if (LangOpts.Microsoft)
Steve Naroff69c827f2008-05-06 22:45:19 +0000411 Preamble += "#define __OBJC_RW_EXTERN extern \"C\" __declspec(dllimport)\n";
412 else
413 Preamble += "#define __OBJC_RW_EXTERN extern\n";
414 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_msgSend";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000415 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
Steve Naroff69c827f2008-05-06 22:45:19 +0000416 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_msgSendSuper";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000417 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n";
Steve Naroff69c827f2008-05-06 22:45:19 +0000418 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_msgSend_stret";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000419 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
Steve Naroff69c827f2008-05-06 22:45:19 +0000420 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_msgSendSuper_stret";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000421 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n";
Steve Naroff1284db82008-05-08 22:02:18 +0000422 Preamble += "__OBJC_RW_EXTERN double objc_msgSend_fpret";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000423 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
Steve Narofff0757612008-05-08 17:52:16 +0000424 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_getClass";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000425 Preamble += "(const char *);\n";
Steve Naroff69c827f2008-05-06 22:45:19 +0000426 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_getMetaClass";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000427 Preamble += "(const char *);\n";
Steve Naroff69c827f2008-05-06 22:45:19 +0000428 Preamble += "__OBJC_RW_EXTERN void objc_exception_throw(struct objc_object *);\n";
429 Preamble += "__OBJC_RW_EXTERN void objc_exception_try_enter(void *);\n";
430 Preamble += "__OBJC_RW_EXTERN void objc_exception_try_exit(void *);\n";
431 Preamble += "__OBJC_RW_EXTERN struct objc_object *objc_exception_extract(void *);\n";
432 Preamble += "__OBJC_RW_EXTERN int objc_exception_match";
Steve Naroff580ca782008-05-09 21:17:56 +0000433 Preamble += "(struct objc_class *, struct objc_object *);\n";
Steve Naroff59f05a42008-07-16 18:58:11 +0000434 // @synchronized hooks.
435 Preamble += "__OBJC_RW_EXTERN void objc_sync_enter(struct objc_object *);\n";
436 Preamble += "__OBJC_RW_EXTERN void objc_sync_exit(struct objc_object *);\n";
Steve Naroff69c827f2008-05-06 22:45:19 +0000437 Preamble += "__OBJC_RW_EXTERN Protocol *objc_getProtocol(const char *);\n";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000438 Preamble += "#ifndef __FASTENUMERATIONSTATE\n";
439 Preamble += "struct __objcFastEnumerationState {\n\t";
440 Preamble += "unsigned long state;\n\t";
Steve Naroffb10f2732008-04-04 22:58:22 +0000441 Preamble += "void **itemsPtr;\n\t";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000442 Preamble += "unsigned long *mutationsPtr;\n\t";
443 Preamble += "unsigned long extra[5];\n};\n";
Steve Naroff73ebd6d2008-06-02 20:23:21 +0000444 Preamble += "__OBJC_RW_EXTERN void objc_enumerationMutation(struct objc_object *);\n";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000445 Preamble += "#define __FASTENUMERATIONSTATE\n";
446 Preamble += "#endif\n";
447 Preamble += "#ifndef __NSCONSTANTSTRINGIMPL\n";
448 Preamble += "struct __NSConstantStringImpl {\n";
449 Preamble += " int *isa;\n";
450 Preamble += " int flags;\n";
451 Preamble += " char *str;\n";
452 Preamble += " long length;\n";
453 Preamble += "};\n";
Steve Naroff88bee742008-08-05 20:04:48 +0000454 Preamble += "#ifdef CF_EXPORT_CONSTANT_STRING\n";
455 Preamble += "extern \"C\" __declspec(dllexport) int __CFConstantStringClassReference[];\n";
456 Preamble += "#else\n";
Steve Naroff73b17cd2008-05-15 21:12:10 +0000457 Preamble += "__OBJC_RW_EXTERN int __CFConstantStringClassReference[];\n";
Steve Naroff88bee742008-08-05 20:04:48 +0000458 Preamble += "#endif\n";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000459 Preamble += "#define __NSCONSTANTSTRINGIMPL\n";
460 Preamble += "#endif\n";
Steve Naroff54055232008-10-27 17:20:55 +0000461 // Blocks preamble.
462 Preamble += "#ifndef BLOCK_IMPL\n";
463 Preamble += "#define BLOCK_IMPL\n";
464 Preamble += "struct __block_impl {\n";
465 Preamble += " void *isa;\n";
466 Preamble += " int Flags;\n";
467 Preamble += " int Size;\n";
468 Preamble += " void *FuncPtr;\n";
469 Preamble += "};\n";
470 Preamble += "enum {\n";
471 Preamble += " BLOCK_HAS_COPY_DISPOSE = (1<<25),\n";
472 Preamble += " BLOCK_IS_GLOBAL = (1<<28)\n";
473 Preamble += "};\n";
Steve Naroff54055232008-10-27 17:20:55 +0000474 Preamble += "// Runtime copy/destroy helper functions\n";
475 Preamble += "__OBJC_RW_EXTERN void _Block_copy_assign(void *, void *);\n";
476 Preamble += "__OBJC_RW_EXTERN void _Block_byref_assign_copy(void *, void *);\n";
477 Preamble += "__OBJC_RW_EXTERN void _Block_destroy(void *);\n";
478 Preamble += "__OBJC_RW_EXTERN void _Block_byref_release(void *);\n";
479 Preamble += "__OBJC_RW_EXTERN void *_NSConcreteGlobalBlock;\n";
480 Preamble += "__OBJC_RW_EXTERN void *_NSConcreteStackBlock;\n";
481 Preamble += "#endif\n";
Steve Naroffa48396e2008-10-27 18:50:14 +0000482 if (LangOpts.Microsoft) {
483 Preamble += "#undef __OBJC_RW_EXTERN\n";
484 Preamble += "#define __attribute__(X)\n";
485 }
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000486}
487
488
Chris Lattnerf04da132007-10-24 17:06:59 +0000489//===----------------------------------------------------------------------===//
490// Top Level Driver Code
491//===----------------------------------------------------------------------===//
492
Steve Naroffb29b4272008-04-14 22:03:09 +0000493void RewriteObjC::HandleTopLevelDecl(Decl *D) {
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000494 // Two cases: either the decl could be in the main file, or it could be in a
495 // #included file. If the former, rewrite it now. If the later, check to see
496 // if we rewrote the #include/#import.
497 SourceLocation Loc = D->getLocation();
498 Loc = SM->getLogicalLoc(Loc);
499
500 // If this is for a builtin, ignore it.
501 if (Loc.isInvalid()) return;
502
Steve Naroffebf2b562007-10-23 23:50:29 +0000503 // Look for built-in declarations that we need to refer during the rewrite.
504 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Steve Naroff09b266e2007-10-30 23:14:51 +0000505 RewriteFunctionDecl(FD);
Steve Naroff248a7532008-04-15 22:42:06 +0000506 } else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) {
Steve Naroffbeaf2992007-11-03 11:27:19 +0000507 // declared in <Foundation/NSString.h>
508 if (strcmp(FVD->getName(), "_NSConstantStringClassReference") == 0) {
509 ConstantStringClassReference = FVD;
510 return;
511 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000512 } else if (ObjCInterfaceDecl *MD = dyn_cast<ObjCInterfaceDecl>(D)) {
Steve Naroffbef11852007-10-26 20:53:56 +0000513 RewriteInterfaceDecl(MD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000514 } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
Steve Naroff423cb562007-10-30 13:30:57 +0000515 RewriteCategoryDecl(CD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000516 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
Steve Naroff752d6ef2007-10-30 16:42:30 +0000517 RewriteProtocolDecl(PD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000518 } else if (ObjCForwardProtocolDecl *FP =
519 dyn_cast<ObjCForwardProtocolDecl>(D)){
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000520 RewriteForwardProtocolDecl(FP);
Steve Naroffebf2b562007-10-23 23:50:29 +0000521 }
Chris Lattnerf04da132007-10-24 17:06:59 +0000522 // If we have a decl in the main file, see if we should rewrite it.
Ted Kremenekcf7e9582008-04-14 21:24:13 +0000523 if (SM->isFromMainFile(Loc))
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000524 return HandleDeclInMainFile(D);
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000525}
526
Chris Lattnerf04da132007-10-24 17:06:59 +0000527//===----------------------------------------------------------------------===//
528// Syntactic (non-AST) Rewriting Code
529//===----------------------------------------------------------------------===//
530
Steve Naroffb29b4272008-04-14 22:03:09 +0000531void RewriteObjC::RewriteInclude() {
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000532 SourceLocation LocStart = SourceLocation::getFileLoc(MainFileID, 0);
533 std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID);
534 const char *MainBufStart = MainBuf.first;
535 const char *MainBufEnd = MainBuf.second;
536 size_t ImportLen = strlen("import");
537 size_t IncludeLen = strlen("include");
538
Fariborz Jahanianaf57b462008-01-19 01:03:17 +0000539 // Loop over the whole file, looking for includes.
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000540 for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr) {
541 if (*BufPtr == '#') {
542 if (++BufPtr == MainBufEnd)
543 return;
544 while (*BufPtr == ' ' || *BufPtr == '\t')
545 if (++BufPtr == MainBufEnd)
546 return;
547 if (!strncmp(BufPtr, "import", ImportLen)) {
548 // replace import with include
549 SourceLocation ImportLoc =
550 LocStart.getFileLocWithOffset(BufPtr-MainBufStart);
Chris Lattneraadaf782008-01-31 19:51:04 +0000551 ReplaceText(ImportLoc, ImportLen, "include", IncludeLen);
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000552 BufPtr += ImportLen;
553 }
554 }
555 }
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000556}
557
Steve Naroffb29b4272008-04-14 22:03:09 +0000558void RewriteObjC::RewriteTabs() {
Chris Lattnerf04da132007-10-24 17:06:59 +0000559 std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID);
560 const char *MainBufStart = MainBuf.first;
561 const char *MainBufEnd = MainBuf.second;
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +0000562
Chris Lattnerf04da132007-10-24 17:06:59 +0000563 // Loop over the whole file, looking for tabs.
564 for (const char *BufPtr = MainBufStart; BufPtr != MainBufEnd; ++BufPtr) {
565 if (*BufPtr != '\t')
566 continue;
567
568 // Okay, we found a tab. This tab will turn into at least one character,
569 // but it depends on which 'virtual column' it is in. Compute that now.
570 unsigned VCol = 0;
571 while (BufPtr-VCol != MainBufStart && BufPtr[-VCol-1] != '\t' &&
572 BufPtr[-VCol-1] != '\n' && BufPtr[-VCol-1] != '\r')
573 ++VCol;
574
575 // Okay, now that we know the virtual column, we know how many spaces to
576 // insert. We assume 8-character tab-stops.
577 unsigned Spaces = 8-(VCol & 7);
578
579 // Get the location of the tab.
580 SourceLocation TabLoc =
581 SourceLocation::getFileLoc(MainFileID, BufPtr-MainBufStart);
582
583 // Rewrite the single tab character into a sequence of spaces.
Chris Lattneraadaf782008-01-31 19:51:04 +0000584 ReplaceText(TabLoc, 1, " ", Spaces);
Chris Lattnerf04da132007-10-24 17:06:59 +0000585 }
Chris Lattner8a12c272007-10-11 18:38:32 +0000586}
587
588
Steve Naroffb29b4272008-04-14 22:03:09 +0000589void RewriteObjC::RewriteForwardClassDecl(ObjCClassDecl *ClassDecl) {
Chris Lattnerf04da132007-10-24 17:06:59 +0000590 int numDecls = ClassDecl->getNumForwardDecls();
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000591 ObjCInterfaceDecl **ForwardDecls = ClassDecl->getForwardDecls();
Chris Lattnerf04da132007-10-24 17:06:59 +0000592
593 // Get the start location and compute the semi location.
594 SourceLocation startLoc = ClassDecl->getLocation();
595 const char *startBuf = SM->getCharacterData(startLoc);
596 const char *semiPtr = strchr(startBuf, ';');
597
598 // Translate to typedef's that forward reference structs with the same name
599 // as the class. As a convenience, we include the original declaration
600 // as a comment.
601 std::string typedefString;
602 typedefString += "// ";
Steve Naroff934f2762007-10-24 22:48:43 +0000603 typedefString.append(startBuf, semiPtr-startBuf+1);
604 typedefString += "\n";
605 for (int i = 0; i < numDecls; i++) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000606 ObjCInterfaceDecl *ForwardDecl = ForwardDecls[i];
Steve Naroff32174822007-11-09 12:50:28 +0000607 typedefString += "#ifndef _REWRITER_typedef_";
608 typedefString += ForwardDecl->getName();
609 typedefString += "\n";
610 typedefString += "#define _REWRITER_typedef_";
611 typedefString += ForwardDecl->getName();
612 typedefString += "\n";
Steve Naroff352336b2007-11-05 14:36:37 +0000613 typedefString += "typedef struct objc_object ";
Steve Naroff934f2762007-10-24 22:48:43 +0000614 typedefString += ForwardDecl->getName();
Steve Naroff32174822007-11-09 12:50:28 +0000615 typedefString += ";\n#endif\n";
Steve Naroff934f2762007-10-24 22:48:43 +0000616 }
617
618 // Replace the @class with typedefs corresponding to the classes.
Chris Lattneraadaf782008-01-31 19:51:04 +0000619 ReplaceText(startLoc, semiPtr-startBuf+1,
620 typedefString.c_str(), typedefString.size());
Chris Lattnerf04da132007-10-24 17:06:59 +0000621}
622
Steve Naroffb29b4272008-04-14 22:03:09 +0000623void RewriteObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) {
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000624 SourceLocation LocStart = Method->getLocStart();
625 SourceLocation LocEnd = Method->getLocEnd();
Steve Naroff423cb562007-10-30 13:30:57 +0000626
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000627 if (SM->getLineNumber(LocEnd) > SM->getLineNumber(LocStart)) {
Steve Naroff94ac21e2008-10-21 13:37:27 +0000628 InsertText(LocStart, "#if 0\n", 6);
629 ReplaceText(LocEnd, 1, ";\n#endif\n", 9);
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000630 } else {
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000631 InsertText(LocStart, "// ", 3);
Steve Naroff423cb562007-10-30 13:30:57 +0000632 }
633}
634
Steve Naroffb29b4272008-04-14 22:03:09 +0000635void RewriteObjC::RewriteProperties(unsigned nProperties, ObjCPropertyDecl **Properties)
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000636{
Chris Lattner55d13b42008-03-16 21:23:50 +0000637 for (unsigned i = 0; i < nProperties; i++) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000638 ObjCPropertyDecl *Property = Properties[i];
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000639 SourceLocation Loc = Property->getLocation();
640
Chris Lattneraadaf782008-01-31 19:51:04 +0000641 ReplaceText(Loc, 0, "// ", 3);
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000642
643 // FIXME: handle properties that are declared across multiple lines.
644 }
645}
646
Steve Naroffb29b4272008-04-14 22:03:09 +0000647void RewriteObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) {
Steve Naroff423cb562007-10-30 13:30:57 +0000648 SourceLocation LocStart = CatDecl->getLocStart();
649
650 // FIXME: handle category headers that are declared across multiple lines.
Chris Lattneraadaf782008-01-31 19:51:04 +0000651 ReplaceText(LocStart, 0, "// ", 3);
Steve Naroff423cb562007-10-30 13:30:57 +0000652
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000653 for (ObjCCategoryDecl::instmeth_iterator I = CatDecl->instmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000654 E = CatDecl->instmeth_end(); I != E; ++I)
655 RewriteMethodDeclaration(*I);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000656 for (ObjCCategoryDecl::classmeth_iterator I = CatDecl->classmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000657 E = CatDecl->classmeth_end(); I != E; ++I)
658 RewriteMethodDeclaration(*I);
659
Steve Naroff423cb562007-10-30 13:30:57 +0000660 // Lastly, comment out the @end.
Chris Lattneraadaf782008-01-31 19:51:04 +0000661 ReplaceText(CatDecl->getAtEndLoc(), 0, "// ", 3);
Steve Naroff423cb562007-10-30 13:30:57 +0000662}
663
Steve Naroffb29b4272008-04-14 22:03:09 +0000664void RewriteObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) {
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000665 std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID);
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000666
Steve Naroff752d6ef2007-10-30 16:42:30 +0000667 SourceLocation LocStart = PDecl->getLocStart();
668
669 // FIXME: handle protocol headers that are declared across multiple lines.
Chris Lattneraadaf782008-01-31 19:51:04 +0000670 ReplaceText(LocStart, 0, "// ", 3);
Steve Naroff752d6ef2007-10-30 16:42:30 +0000671
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000672 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000673 E = PDecl->instmeth_end(); I != E; ++I)
674 RewriteMethodDeclaration(*I);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000675 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000676 E = PDecl->classmeth_end(); I != E; ++I)
677 RewriteMethodDeclaration(*I);
678
Steve Naroff752d6ef2007-10-30 16:42:30 +0000679 // Lastly, comment out the @end.
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000680 SourceLocation LocEnd = PDecl->getAtEndLoc();
Chris Lattneraadaf782008-01-31 19:51:04 +0000681 ReplaceText(LocEnd, 0, "// ", 3);
Steve Naroff8cc764c2007-11-14 15:03:57 +0000682
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000683 // Must comment out @optional/@required
684 const char *startBuf = SM->getCharacterData(LocStart);
685 const char *endBuf = SM->getCharacterData(LocEnd);
686 for (const char *p = startBuf; p < endBuf; p++) {
687 if (*p == '@' && !strncmp(p+1, "optional", strlen("optional"))) {
688 std::string CommentedOptional = "/* @optional */";
Steve Naroff8cc764c2007-11-14 15:03:57 +0000689 SourceLocation OptionalLoc = LocStart.getFileLocWithOffset(p-startBuf);
Chris Lattneraadaf782008-01-31 19:51:04 +0000690 ReplaceText(OptionalLoc, strlen("@optional"),
691 CommentedOptional.c_str(), CommentedOptional.size());
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000692
693 }
694 else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))) {
695 std::string CommentedRequired = "/* @required */";
Steve Naroff8cc764c2007-11-14 15:03:57 +0000696 SourceLocation OptionalLoc = LocStart.getFileLocWithOffset(p-startBuf);
Chris Lattneraadaf782008-01-31 19:51:04 +0000697 ReplaceText(OptionalLoc, strlen("@required"),
698 CommentedRequired.c_str(), CommentedRequired.size());
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000699
700 }
701 }
Steve Naroff752d6ef2007-10-30 16:42:30 +0000702}
703
Steve Naroffb29b4272008-04-14 22:03:09 +0000704void RewriteObjC::RewriteForwardProtocolDecl(ObjCForwardProtocolDecl *PDecl) {
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000705 SourceLocation LocStart = PDecl->getLocation();
Steve Naroffb7fa9922007-11-14 03:37:28 +0000706 if (LocStart.isInvalid())
707 assert(false && "Invalid SourceLocation");
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000708 // FIXME: handle forward protocol that are declared across multiple lines.
Chris Lattneraadaf782008-01-31 19:51:04 +0000709 ReplaceText(LocStart, 0, "// ", 3);
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000710}
711
Steve Naroffb29b4272008-04-14 22:03:09 +0000712void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD,
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000713 std::string &ResultStr) {
Steve Naroffced80a82008-10-30 12:09:33 +0000714 //fprintf(stderr,"In RewriteObjCMethodDecl\n");
Steve Naroff76e429d2008-07-16 14:40:40 +0000715 const FunctionType *FPRetType = 0;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000716 ResultStr += "\nstatic ";
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000717 if (OMD->getResultType()->isObjCQualifiedIdType())
Fariborz Jahanianc5692492007-12-17 21:03:50 +0000718 ResultStr += "id";
Steve Naroff76e429d2008-07-16 14:40:40 +0000719 else if (OMD->getResultType()->isFunctionPointerType()) {
720 // needs special handling, since pointer-to-functions have special
721 // syntax (where a decaration models use).
722 QualType retType = OMD->getResultType();
723 if (const PointerType* PT = retType->getAsPointerType()) {
724 QualType PointeeTy = PT->getPointeeType();
725 if ((FPRetType = PointeeTy->getAsFunctionType())) {
726 ResultStr += FPRetType->getResultType().getAsString();
727 ResultStr += "(*";
728 }
729 }
730 } else
Fariborz Jahanianc5692492007-12-17 21:03:50 +0000731 ResultStr += OMD->getResultType().getAsString();
Fariborz Jahanian531a1ea2008-01-10 01:39:52 +0000732 ResultStr += " ";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000733
734 // Unique method name
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000735 std::string NameStr;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000736
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000737 if (OMD->isInstance())
738 NameStr += "_I_";
739 else
740 NameStr += "_C_";
741
742 NameStr += OMD->getClassInterface()->getName();
743 NameStr += "_";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000744
745 NamedDecl *MethodContext = OMD->getMethodContext();
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000746 if (ObjCCategoryImplDecl *CID =
747 dyn_cast<ObjCCategoryImplDecl>(MethodContext)) {
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000748 NameStr += CID->getName();
749 NameStr += "_";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000750 }
Steve Naroff563b8282008-04-04 22:23:44 +0000751 // Append selector names, replacing ':' with '_'
752 if (OMD->getSelector().getName().find(':') == std::string::npos)
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000753 NameStr += OMD->getSelector().getName();
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000754 else {
755 std::string selString = OMD->getSelector().getName();
756 int len = selString.size();
757 for (int i = 0; i < len; i++)
758 if (selString[i] == ':')
759 selString[i] = '_';
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000760 NameStr += selString;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000761 }
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000762 // Remember this name for metadata emission
763 MethodInternalNames[OMD] = NameStr;
764 ResultStr += NameStr;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000765
766 // Rewrite arguments
767 ResultStr += "(";
768
769 // invisible arguments
770 if (OMD->isInstance()) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000771 QualType selfTy = Context->getObjCInterfaceType(OMD->getClassInterface());
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000772 selfTy = Context->getPointerType(selfTy);
Steve Naroff05b8c782008-03-12 00:25:36 +0000773 if (!LangOpts.Microsoft) {
774 if (ObjCSynthesizedStructs.count(OMD->getClassInterface()))
775 ResultStr += "struct ";
776 }
777 // When rewriting for Microsoft, explicitly omit the structure name.
Steve Naroff61ed9ca2008-03-10 23:16:54 +0000778 ResultStr += OMD->getClassInterface()->getName();
Steve Naroff61ed9ca2008-03-10 23:16:54 +0000779 ResultStr += " *";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000780 }
781 else
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000782 ResultStr += Context->getObjCIdType().getAsString();
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000783
784 ResultStr += " self, ";
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000785 ResultStr += Context->getObjCSelType().getAsString();
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000786 ResultStr += " _cmd";
787
788 // Method arguments.
Chris Lattner58cce3b2008-03-16 01:07:14 +0000789 for (unsigned i = 0; i < OMD->getNumParams(); i++) {
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000790 ParmVarDecl *PDecl = OMD->getParamDecl(i);
791 ResultStr += ", ";
Steve Naroff543409e2008-04-18 21:13:19 +0000792 if (PDecl->getType()->isObjCQualifiedIdType()) {
793 ResultStr += "id ";
794 ResultStr += PDecl->getName();
795 } else {
796 std::string Name = PDecl->getName();
Steve Naroffc8ad87b2008-10-30 14:45:29 +0000797 if (isBlockPointerType(PDecl->getType())) {
798 // Make sure we convert "t (^)(...)" to "t (*)(...)".
799 const BlockPointerType *BPT = PDecl->getType()->getAsBlockPointerType();
800 Context->getPointerType(BPT->getPointeeType()).getAsStringInternal(Name);
801 } else
802 PDecl->getType().getAsStringInternal(Name);
Steve Naroff543409e2008-04-18 21:13:19 +0000803 ResultStr += Name;
804 }
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000805 }
Fariborz Jahanian7c39ff72008-01-21 20:14:23 +0000806 if (OMD->isVariadic())
807 ResultStr += ", ...";
Fariborz Jahanian531a1ea2008-01-10 01:39:52 +0000808 ResultStr += ") ";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000809
Steve Naroff76e429d2008-07-16 14:40:40 +0000810 if (FPRetType) {
811 ResultStr += ")"; // close the precedence "scope" for "*".
812
813 // Now, emit the argument types (if any).
814 if (const FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(FPRetType)) {
815 ResultStr += "(";
816 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) {
817 if (i) ResultStr += ", ";
818 std::string ParamStr = FT->getArgType(i).getAsString();
819 ResultStr += ParamStr;
820 }
821 if (FT->isVariadic()) {
822 if (FT->getNumArgs()) ResultStr += ", ";
823 ResultStr += "...";
824 }
825 ResultStr += ")";
826 } else {
827 ResultStr += "()";
828 }
829 }
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000830}
Steve Naroffb29b4272008-04-14 22:03:09 +0000831void RewriteObjC::RewriteImplementationDecl(NamedDecl *OID) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000832 ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID);
833 ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000834
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000835 if (IMD)
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000836 InsertText(IMD->getLocStart(), "// ", 3);
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000837 else
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000838 InsertText(CID->getLocStart(), "// ", 3);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000839
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000840 for (ObjCCategoryImplDecl::instmeth_iterator
Chris Lattnerab4c4d52007-12-12 07:46:12 +0000841 I = IMD ? IMD->instmeth_begin() : CID->instmeth_begin(),
842 E = IMD ? IMD->instmeth_end() : CID->instmeth_end(); I != E; ++I) {
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000843 std::string ResultStr;
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000844 ObjCMethodDecl *OMD = *I;
845 RewriteObjCMethodDecl(OMD, ResultStr);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000846 SourceLocation LocStart = OMD->getLocStart();
847 SourceLocation LocEnd = OMD->getBody()->getLocStart();
848
849 const char *startBuf = SM->getCharacterData(LocStart);
850 const char *endBuf = SM->getCharacterData(LocEnd);
Chris Lattneraadaf782008-01-31 19:51:04 +0000851 ReplaceText(LocStart, endBuf-startBuf,
852 ResultStr.c_str(), ResultStr.size());
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000853 }
854
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000855 for (ObjCCategoryImplDecl::classmeth_iterator
Chris Lattnerab4c4d52007-12-12 07:46:12 +0000856 I = IMD ? IMD->classmeth_begin() : CID->classmeth_begin(),
857 E = IMD ? IMD->classmeth_end() : CID->classmeth_end(); I != E; ++I) {
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000858 std::string ResultStr;
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000859 ObjCMethodDecl *OMD = *I;
860 RewriteObjCMethodDecl(OMD, ResultStr);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000861 SourceLocation LocStart = OMD->getLocStart();
862 SourceLocation LocEnd = OMD->getBody()->getLocStart();
863
864 const char *startBuf = SM->getCharacterData(LocStart);
865 const char *endBuf = SM->getCharacterData(LocEnd);
Chris Lattneraadaf782008-01-31 19:51:04 +0000866 ReplaceText(LocStart, endBuf-startBuf,
867 ResultStr.c_str(), ResultStr.size());
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000868 }
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000869 if (IMD)
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000870 InsertText(IMD->getLocEnd(), "// ", 3);
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000871 else
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000872 InsertText(CID->getLocEnd(), "// ", 3);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000873}
874
Steve Naroffb29b4272008-04-14 22:03:09 +0000875void RewriteObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) {
Steve Narofff908a872007-10-30 02:23:23 +0000876 std::string ResultStr;
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000877 if (!ObjCForwardDecls.count(ClassDecl)) {
Steve Naroff6c6a2db2007-11-01 03:35:41 +0000878 // we haven't seen a forward decl - generate a typedef.
Steve Naroff5086a8d2007-11-14 23:02:56 +0000879 ResultStr = "#ifndef _REWRITER_typedef_";
Steve Naroff32174822007-11-09 12:50:28 +0000880 ResultStr += ClassDecl->getName();
881 ResultStr += "\n";
882 ResultStr += "#define _REWRITER_typedef_";
883 ResultStr += ClassDecl->getName();
884 ResultStr += "\n";
Steve Naroff61ed9ca2008-03-10 23:16:54 +0000885 ResultStr += "typedef struct objc_object ";
Steve Naroff6c6a2db2007-11-01 03:35:41 +0000886 ResultStr += ClassDecl->getName();
Steve Naroff32174822007-11-09 12:50:28 +0000887 ResultStr += ";\n#endif\n";
Steve Naroff6c6a2db2007-11-01 03:35:41 +0000888 // Mark this typedef as having been generated.
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000889 ObjCForwardDecls.insert(ClassDecl);
Steve Naroff6c6a2db2007-11-01 03:35:41 +0000890 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000891 SynthesizeObjCInternalStruct(ClassDecl, ResultStr);
Steve Narofff908a872007-10-30 02:23:23 +0000892
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000893 RewriteProperties(ClassDecl->getNumPropertyDecl(),
894 ClassDecl->getPropertyDecl());
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000895 for (ObjCInterfaceDecl::instmeth_iterator I = ClassDecl->instmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000896 E = ClassDecl->instmeth_end(); I != E; ++I)
897 RewriteMethodDeclaration(*I);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000898 for (ObjCInterfaceDecl::classmeth_iterator I = ClassDecl->classmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000899 E = ClassDecl->classmeth_end(); I != E; ++I)
900 RewriteMethodDeclaration(*I);
901
Steve Naroff2feac5e2007-10-30 03:43:13 +0000902 // Lastly, comment out the @end.
Chris Lattneraadaf782008-01-31 19:51:04 +0000903 ReplaceText(ClassDecl->getAtEndLoc(), 0, "// ", 3);
Steve Naroffbef11852007-10-26 20:53:56 +0000904}
905
Chris Lattner3b2c58c2008-05-23 20:40:52 +0000906Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV,
907 SourceLocation OrigStart) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000908 ObjCIvarDecl *D = IV->getDecl();
Steve Naroff54055232008-10-27 17:20:55 +0000909 if (CurMethodDef) {
Steve Naroff05b8c782008-03-12 00:25:36 +0000910 if (const PointerType *pType = IV->getBase()->getType()->getAsPointerType()) {
Steve Narofff0757612008-05-08 17:52:16 +0000911 ObjCInterfaceType *iFaceDecl = dyn_cast<ObjCInterfaceType>(pType->getPointeeType());
912 // lookup which class implements the instance variable.
913 ObjCInterfaceDecl *clsDeclared = 0;
914 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), clsDeclared);
915 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class");
916
917 // Synthesize an explicit cast to gain access to the ivar.
918 std::string RecName = clsDeclared->getIdentifier()->getName();
919 RecName += "_IMPL";
920 IdentifierInfo *II = &Context->Idents.get(RecName.c_str());
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +0000921 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Ted Kremenekdf042e62008-09-05 01:34:33 +0000922 SourceLocation(), II);
Steve Narofff0757612008-05-08 17:52:16 +0000923 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
924 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
Douglas Gregor6eec8e82008-10-28 15:36:24 +0000925 CastExpr *castExpr = new CStyleCastExpr(castT, IV->getBase(), castT,
Steve Naroffb2f9e512008-11-03 23:29:32 +0000926 SourceLocation(), SourceLocation());
Steve Narofff0757612008-05-08 17:52:16 +0000927 // Don't forget the parens to enforce the proper binding.
Chris Lattner3b2c58c2008-05-23 20:40:52 +0000928 ParenExpr *PE = new ParenExpr(IV->getBase()->getLocStart(),
929 IV->getBase()->getLocEnd(),
930 castExpr);
Steve Narofff0757612008-05-08 17:52:16 +0000931 if (IV->isFreeIvar() &&
Steve Naroff54055232008-10-27 17:20:55 +0000932 CurMethodDef->getClassInterface() == iFaceDecl->getDecl()) {
Chris Lattner3b2c58c2008-05-23 20:40:52 +0000933 MemberExpr *ME = new MemberExpr(PE, true, D, IV->getLocation(),
934 D->getType());
Steve Narofff0757612008-05-08 17:52:16 +0000935 ReplaceStmt(IV, ME);
936 delete IV;
937 return ME;
Steve Naroffc2a689b2007-11-15 11:33:00 +0000938 }
Chris Lattner3b2c58c2008-05-23 20:40:52 +0000939
940 ReplaceStmt(IV->getBase(), PE);
941 // Cannot delete IV->getBase(), since PE points to it.
942 // Replace the old base with the cast. This is important when doing
943 // embedded rewrites. For example, [newInv->_container addObject:0].
944 IV->setBase(PE);
945 return IV;
Steve Naroffc2a689b2007-11-15 11:33:00 +0000946 }
Steve Naroff84472a82008-04-18 21:55:08 +0000947 } else { // we are outside a method.
Steve Naroff9f525972008-05-06 23:20:07 +0000948 assert(!IV->isFreeIvar() && "Cannot have a free standing ivar outside a method");
949
950 // Explicit ivar refs need to have a cast inserted.
951 // FIXME: consider sharing some of this code with the code above.
952 if (const PointerType *pType = IV->getBase()->getType()->getAsPointerType()) {
Steve Narofff0757612008-05-08 17:52:16 +0000953 ObjCInterfaceType *iFaceDecl = dyn_cast<ObjCInterfaceType>(pType->getPointeeType());
Steve Naroff9f525972008-05-06 23:20:07 +0000954 // lookup which class implements the instance variable.
955 ObjCInterfaceDecl *clsDeclared = 0;
Steve Narofff0757612008-05-08 17:52:16 +0000956 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), clsDeclared);
Steve Naroff9f525972008-05-06 23:20:07 +0000957 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class");
958
959 // Synthesize an explicit cast to gain access to the ivar.
960 std::string RecName = clsDeclared->getIdentifier()->getName();
961 RecName += "_IMPL";
962 IdentifierInfo *II = &Context->Idents.get(RecName.c_str());
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +0000963 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Ted Kremenekdf042e62008-09-05 01:34:33 +0000964 SourceLocation(), II);
Steve Naroff9f525972008-05-06 23:20:07 +0000965 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
966 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
Douglas Gregor6eec8e82008-10-28 15:36:24 +0000967 CastExpr *castExpr = new CStyleCastExpr(castT, IV->getBase(), castT,
Steve Naroffb2f9e512008-11-03 23:29:32 +0000968 SourceLocation(), SourceLocation());
Steve Naroff9f525972008-05-06 23:20:07 +0000969 // Don't forget the parens to enforce the proper binding.
Chris Lattner8d366162008-05-28 16:38:23 +0000970 ParenExpr *PE = new ParenExpr(IV->getBase()->getLocStart(),
971 IV->getBase()->getLocEnd(), castExpr);
Steve Naroff9f525972008-05-06 23:20:07 +0000972 ReplaceStmt(IV->getBase(), PE);
973 // Cannot delete IV->getBase(), since PE points to it.
974 // Replace the old base with the cast. This is important when doing
975 // embedded rewrites. For example, [newInv->_container addObject:0].
976 IV->setBase(PE);
977 return IV;
978 }
Steve Naroffc2a689b2007-11-15 11:33:00 +0000979 }
Steve Naroff84472a82008-04-18 21:55:08 +0000980 return IV;
Steve Naroff7e3411b2007-11-15 02:58:25 +0000981}
982
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +0000983/// SynthCountByEnumWithState - To print:
984/// ((unsigned int (*)
985/// (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
986/// (void *)objc_msgSend)((id)l_collection,
987/// sel_registerName(
988/// "countByEnumeratingWithState:objects:count:"),
989/// &enumState,
990/// (id *)items, (unsigned int)16)
991///
Steve Naroffb29b4272008-04-14 22:03:09 +0000992void RewriteObjC::SynthCountByEnumWithState(std::string &buf) {
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +0000993 buf += "((unsigned int (*) (id, SEL, struct __objcFastEnumerationState *, "
994 "id *, unsigned int))(void *)objc_msgSend)";
995 buf += "\n\t\t";
996 buf += "((id)l_collection,\n\t\t";
997 buf += "sel_registerName(\"countByEnumeratingWithState:objects:count:\"),";
998 buf += "\n\t\t";
999 buf += "&enumState, "
1000 "(id *)items, (unsigned int)16)";
1001}
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001002
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001003/// RewriteBreakStmt - Rewrite for a break-stmt inside an ObjC2's foreach
1004/// statement to exit to its outer synthesized loop.
1005///
Steve Naroffb29b4272008-04-14 22:03:09 +00001006Stmt *RewriteObjC::RewriteBreakStmt(BreakStmt *S) {
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001007 if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1008 return S;
1009 // replace break with goto __break_label
1010 std::string buf;
1011
1012 SourceLocation startLoc = S->getLocStart();
1013 buf = "goto __break_label_";
1014 buf += utostr(ObjCBcLabelNo.back());
Chris Lattneraadaf782008-01-31 19:51:04 +00001015 ReplaceText(startLoc, strlen("break"), buf.c_str(), buf.size());
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001016
1017 return 0;
1018}
1019
1020/// RewriteContinueStmt - Rewrite for a continue-stmt inside an ObjC2's foreach
1021/// statement to continue with its inner synthesized loop.
1022///
Steve Naroffb29b4272008-04-14 22:03:09 +00001023Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) {
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001024 if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1025 return S;
1026 // replace continue with goto __continue_label
1027 std::string buf;
1028
1029 SourceLocation startLoc = S->getLocStart();
1030 buf = "goto __continue_label_";
1031 buf += utostr(ObjCBcLabelNo.back());
Chris Lattneraadaf782008-01-31 19:51:04 +00001032 ReplaceText(startLoc, strlen("continue"), buf.c_str(), buf.size());
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001033
1034 return 0;
1035}
1036
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001037/// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement.
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001038/// It rewrites:
1039/// for ( type elem in collection) { stmts; }
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00001040
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001041/// Into:
1042/// {
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001043/// type elem;
1044/// struct __objcFastEnumerationState enumState = { 0 };
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001045/// id items[16];
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001046/// id l_collection = (id)collection;
1047/// unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1048/// objects:items count:16];
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001049/// if (limit) {
1050/// unsigned long startMutations = *enumState.mutationsPtr;
1051/// do {
1052/// unsigned long counter = 0;
1053/// do {
1054/// if (startMutations != *enumState.mutationsPtr)
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001055/// objc_enumerationMutation(l_collection);
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001056/// elem = (type)enumState.itemsPtr[counter++];
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001057/// stmts;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001058/// __continue_label: ;
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001059/// } while (counter < limit);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001060/// } while (limit = [l_collection countByEnumeratingWithState:&enumState
1061/// objects:items count:16]);
1062/// elem = nil;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001063/// __break_label: ;
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001064/// }
1065/// else
1066/// elem = nil;
1067/// }
1068///
Steve Naroffb29b4272008-04-14 22:03:09 +00001069Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
Chris Lattner338d1e22008-01-31 05:10:40 +00001070 SourceLocation OrigEnd) {
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001071 assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty");
1072 assert(isa<ObjCForCollectionStmt>(Stmts.back()) &&
1073 "ObjCForCollectionStmt Statement stack mismatch");
1074 assert(!ObjCBcLabelNo.empty() &&
1075 "ObjCForCollectionStmt - Label No stack empty");
1076
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001077 SourceLocation startLoc = S->getLocStart();
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001078 const char *startBuf = SM->getCharacterData(startLoc);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001079 const char *elementName;
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001080 std::string elementTypeAsString;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001081 std::string buf;
1082 buf = "\n{\n\t";
1083 if (DeclStmt *DS = dyn_cast<DeclStmt>(S->getElement())) {
1084 // type elem;
Ted Kremenek1ed8e2a2008-10-06 22:16:13 +00001085 ScopedDecl* D = DS->getSolitaryDecl();
1086 QualType ElementType = cast<ValueDecl>(D)->getType();
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001087 elementTypeAsString = ElementType.getAsString();
1088 buf += elementTypeAsString;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001089 buf += " ";
Ted Kremenek1ed8e2a2008-10-06 22:16:13 +00001090 elementName = D->getName();
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001091 buf += elementName;
1092 buf += ";\n\t";
1093 }
Chris Lattner06767512008-04-08 05:52:18 +00001094 else {
1095 DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001096 elementName = DR->getDecl()->getName();
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001097 elementTypeAsString
1098 = cast<ValueDecl>(DR->getDecl())->getType().getAsString();
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001099 }
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001100
1101 // struct __objcFastEnumerationState enumState = { 0 };
1102 buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t";
1103 // id items[16];
1104 buf += "id items[16];\n\t";
1105 // id l_collection = (id)
1106 buf += "id l_collection = (id)";
Fariborz Jahanian75712282008-01-10 00:24:29 +00001107 // Find start location of 'collection' the hard way!
1108 const char *startCollectionBuf = startBuf;
1109 startCollectionBuf += 3; // skip 'for'
1110 startCollectionBuf = strchr(startCollectionBuf, '(');
1111 startCollectionBuf++; // skip '('
1112 // find 'in' and skip it.
1113 while (*startCollectionBuf != ' ' ||
1114 *(startCollectionBuf+1) != 'i' || *(startCollectionBuf+2) != 'n' ||
1115 (*(startCollectionBuf+3) != ' ' &&
1116 *(startCollectionBuf+3) != '[' && *(startCollectionBuf+3) != '('))
1117 startCollectionBuf++;
1118 startCollectionBuf += 3;
1119
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001120 // Replace: "for (type element in" with string constructed thus far.
Chris Lattneraadaf782008-01-31 19:51:04 +00001121 ReplaceText(startLoc, startCollectionBuf - startBuf,
1122 buf.c_str(), buf.size());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001123 // Replace ')' in for '(' type elem in collection ')' with ';'
Fariborz Jahanian75712282008-01-10 00:24:29 +00001124 SourceLocation rightParenLoc = S->getRParenLoc();
1125 const char *rparenBuf = SM->getCharacterData(rightParenLoc);
1126 SourceLocation lparenLoc = startLoc.getFileLocWithOffset(rparenBuf-startBuf);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001127 buf = ";\n\t";
1128
1129 // unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1130 // objects:items count:16];
1131 // which is synthesized into:
1132 // unsigned int limit =
1133 // ((unsigned int (*)
1134 // (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
1135 // (void *)objc_msgSend)((id)l_collection,
1136 // sel_registerName(
1137 // "countByEnumeratingWithState:objects:count:"),
1138 // (struct __objcFastEnumerationState *)&state,
1139 // (id *)items, (unsigned int)16);
1140 buf += "unsigned long limit =\n\t\t";
1141 SynthCountByEnumWithState(buf);
1142 buf += ";\n\t";
1143 /// if (limit) {
1144 /// unsigned long startMutations = *enumState.mutationsPtr;
1145 /// do {
1146 /// unsigned long counter = 0;
1147 /// do {
1148 /// if (startMutations != *enumState.mutationsPtr)
1149 /// objc_enumerationMutation(l_collection);
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001150 /// elem = (type)enumState.itemsPtr[counter++];
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001151 buf += "if (limit) {\n\t";
1152 buf += "unsigned long startMutations = *enumState.mutationsPtr;\n\t";
1153 buf += "do {\n\t\t";
1154 buf += "unsigned long counter = 0;\n\t\t";
1155 buf += "do {\n\t\t\t";
1156 buf += "if (startMutations != *enumState.mutationsPtr)\n\t\t\t\t";
1157 buf += "objc_enumerationMutation(l_collection);\n\t\t\t";
1158 buf += elementName;
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001159 buf += " = (";
1160 buf += elementTypeAsString;
1161 buf += ")enumState.itemsPtr[counter++];";
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001162 // Replace ')' in for '(' type elem in collection ')' with all of these.
Chris Lattneraadaf782008-01-31 19:51:04 +00001163 ReplaceText(lparenLoc, 1, buf.c_str(), buf.size());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001164
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001165 /// __continue_label: ;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001166 /// } while (counter < limit);
1167 /// } while (limit = [l_collection countByEnumeratingWithState:&enumState
1168 /// objects:items count:16]);
1169 /// elem = nil;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001170 /// __break_label: ;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001171 /// }
1172 /// else
1173 /// elem = nil;
1174 /// }
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001175 ///
1176 buf = ";\n\t";
1177 buf += "__continue_label_";
1178 buf += utostr(ObjCBcLabelNo.back());
1179 buf += ": ;";
1180 buf += "\n\t\t";
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001181 buf += "} while (counter < limit);\n\t";
1182 buf += "} while (limit = ";
1183 SynthCountByEnumWithState(buf);
1184 buf += ");\n\t";
1185 buf += elementName;
1186 buf += " = nil;\n\t";
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001187 buf += "__break_label_";
1188 buf += utostr(ObjCBcLabelNo.back());
1189 buf += ": ;\n\t";
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001190 buf += "}\n\t";
1191 buf += "else\n\t\t";
1192 buf += elementName;
1193 buf += " = nil;\n";
1194 buf += "}\n";
Steve Naroff600e4e82008-07-21 18:26:02 +00001195
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001196 // Insert all these *after* the statement body.
Steve Naroff600e4e82008-07-21 18:26:02 +00001197 if (isa<CompoundStmt>(S->getBody())) {
1198 SourceLocation endBodyLoc = OrigEnd.getFileLocWithOffset(1);
1199 InsertText(endBodyLoc, buf.c_str(), buf.size());
1200 } else {
1201 /* Need to treat single statements specially. For example:
1202 *
1203 * for (A *a in b) if (stuff()) break;
1204 * for (A *a in b) xxxyy;
1205 *
1206 * The following code simply scans ahead to the semi to find the actual end.
1207 */
1208 const char *stmtBuf = SM->getCharacterData(OrigEnd);
1209 const char *semiBuf = strchr(stmtBuf, ';');
1210 assert(semiBuf && "Can't find ';'");
1211 SourceLocation endBodyLoc = OrigEnd.getFileLocWithOffset(semiBuf-stmtBuf+1);
1212 InsertText(endBodyLoc, buf.c_str(), buf.size());
1213 }
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001214 Stmts.pop_back();
1215 ObjCBcLabelNo.pop_back();
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001216 return 0;
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001217}
1218
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001219/// RewriteObjCSynchronizedStmt -
1220/// This routine rewrites @synchronized(expr) stmt;
1221/// into:
1222/// objc_sync_enter(expr);
1223/// @try stmt @finally { objc_sync_exit(expr); }
1224///
Steve Naroffb29b4272008-04-14 22:03:09 +00001225Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001226 // Get the start location and compute the semi location.
1227 SourceLocation startLoc = S->getLocStart();
1228 const char *startBuf = SM->getCharacterData(startLoc);
1229
1230 assert((*startBuf == '@') && "bogus @synchronized location");
1231
1232 std::string buf;
Steve Naroff3498cc92008-08-21 13:03:03 +00001233 buf = "objc_sync_enter((id)";
1234 const char *lparenBuf = startBuf;
1235 while (*lparenBuf != '(') lparenBuf++;
1236 ReplaceText(startLoc, lparenBuf-startBuf+1, buf.c_str(), buf.size());
Steve Naroffc7089f12008-08-19 13:04:19 +00001237 // We can't use S->getSynchExpr()->getLocEnd() to find the end location, since
1238 // the sync expression is typically a message expression that's already
1239 // been rewritten! (which implies the SourceLocation's are invalid).
1240 SourceLocation endLoc = S->getSynchBody()->getLocStart();
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001241 const char *endBuf = SM->getCharacterData(endLoc);
Steve Naroffc7089f12008-08-19 13:04:19 +00001242 while (*endBuf != ')') endBuf--;
1243 SourceLocation rparenLoc = startLoc.getFileLocWithOffset(endBuf-startBuf);
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001244 buf = ");\n";
1245 // declare a new scope with two variables, _stack and _rethrow.
1246 buf += "/* @try scope begin */ \n{ struct _objc_exception_data {\n";
1247 buf += "int buf[18/*32-bit i386*/];\n";
1248 buf += "char *pointers[4];} _stack;\n";
1249 buf += "id volatile _rethrow = 0;\n";
1250 buf += "objc_exception_try_enter(&_stack);\n";
1251 buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
Chris Lattneraadaf782008-01-31 19:51:04 +00001252 ReplaceText(rparenLoc, 1, buf.c_str(), buf.size());
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001253 startLoc = S->getSynchBody()->getLocEnd();
1254 startBuf = SM->getCharacterData(startLoc);
1255
Steve Naroffc7089f12008-08-19 13:04:19 +00001256 assert((*startBuf == '}') && "bogus @synchronized block");
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001257 SourceLocation lastCurlyLoc = startLoc;
1258 buf = "}\nelse {\n";
1259 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1260 buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
Steve Naroffb2a39452008-07-16 19:47:39 +00001261 buf += " objc_sync_exit(";
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001262 Expr *syncExpr = new CStyleCastExpr(Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00001263 S->getSynchExpr(),
1264 Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00001265 SourceLocation(), SourceLocation());
Ted Kremeneka95d3752008-09-13 05:16:45 +00001266 std::string syncExprBufS;
1267 llvm::raw_string_ostream syncExprBuf(syncExprBufS);
Steve Naroff3498cc92008-08-21 13:03:03 +00001268 syncExpr->printPretty(syncExprBuf);
Steve Naroffb2a39452008-07-16 19:47:39 +00001269 buf += syncExprBuf.str();
1270 buf += ");\n";
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001271 buf += " if (_rethrow) objc_exception_throw(_rethrow);\n";
1272 buf += "}\n";
1273 buf += "}";
1274
Chris Lattneraadaf782008-01-31 19:51:04 +00001275 ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size());
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001276 return 0;
1277}
1278
Steve Naroffb29b4272008-04-14 22:03:09 +00001279Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
Steve Naroff75730982007-11-07 04:08:17 +00001280 // Get the start location and compute the semi location.
1281 SourceLocation startLoc = S->getLocStart();
1282 const char *startBuf = SM->getCharacterData(startLoc);
1283
1284 assert((*startBuf == '@') && "bogus @try location");
1285
1286 std::string buf;
1287 // declare a new scope with two variables, _stack and _rethrow.
1288 buf = "/* @try scope begin */ { struct _objc_exception_data {\n";
1289 buf += "int buf[18/*32-bit i386*/];\n";
1290 buf += "char *pointers[4];} _stack;\n";
1291 buf += "id volatile _rethrow = 0;\n";
1292 buf += "objc_exception_try_enter(&_stack);\n";
Steve Naroff21867b12007-11-07 18:43:40 +00001293 buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
Steve Naroff75730982007-11-07 04:08:17 +00001294
Chris Lattneraadaf782008-01-31 19:51:04 +00001295 ReplaceText(startLoc, 4, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001296
1297 startLoc = S->getTryBody()->getLocEnd();
1298 startBuf = SM->getCharacterData(startLoc);
1299
1300 assert((*startBuf == '}') && "bogus @try block");
Steve Naroffc9ba1722008-07-16 15:31:30 +00001301
Steve Naroff75730982007-11-07 04:08:17 +00001302 SourceLocation lastCurlyLoc = startLoc;
Steve Naroffc9ba1722008-07-16 15:31:30 +00001303 ObjCAtCatchStmt *catchList = S->getCatchStmts();
1304 if (catchList) {
1305 startLoc = startLoc.getFileLocWithOffset(1);
1306 buf = " /* @catch begin */ else {\n";
1307 buf += " id _caught = objc_exception_extract(&_stack);\n";
1308 buf += " objc_exception_try_enter (&_stack);\n";
1309 buf += " if (_setjmp(_stack.buf))\n";
1310 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1311 buf += " else { /* @catch continue */";
1312
1313 InsertText(startLoc, buf.c_str(), buf.size());
Steve Naroff8bd3dc62008-09-09 19:59:12 +00001314 } else { /* no catch list */
1315 buf = "}\nelse {\n";
1316 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1317 buf += "}";
1318 ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size());
Steve Naroffc9ba1722008-07-16 15:31:30 +00001319 }
Steve Naroff75730982007-11-07 04:08:17 +00001320 bool sawIdTypedCatch = false;
1321 Stmt *lastCatchBody = 0;
Steve Naroff75730982007-11-07 04:08:17 +00001322 while (catchList) {
1323 Stmt *catchStmt = catchList->getCatchParamStmt();
1324
1325 if (catchList == S->getCatchStmts())
1326 buf = "if ("; // we are generating code for the first catch clause
1327 else
1328 buf = "else if (";
1329 startLoc = catchList->getLocStart();
1330 startBuf = SM->getCharacterData(startLoc);
1331
1332 assert((*startBuf == '@') && "bogus @catch location");
1333
1334 const char *lParenLoc = strchr(startBuf, '(');
1335
Steve Naroffbe4b3332008-02-01 22:08:12 +00001336 if (catchList->hasEllipsis()) {
Steve Naroffe12e6922008-02-01 20:02:07 +00001337 // Now rewrite the body...
1338 lastCatchBody = catchList->getCatchBody();
Steve Naroffe12e6922008-02-01 20:02:07 +00001339 SourceLocation bodyLoc = lastCatchBody->getLocStart();
1340 const char *bodyBuf = SM->getCharacterData(bodyLoc);
Chris Lattner06767512008-04-08 05:52:18 +00001341 assert(*SM->getCharacterData(catchList->getRParenLoc()) == ')' &&
1342 "bogus @catch paren location");
Steve Naroffe12e6922008-02-01 20:02:07 +00001343 assert((*bodyBuf == '{') && "bogus @catch body location");
1344
1345 buf += "1) { id _tmp = _caught;";
1346 Rewrite.ReplaceText(startLoc, bodyBuf-startBuf+1,
1347 buf.c_str(), buf.size());
1348 } else if (DeclStmt *declStmt = dyn_cast<DeclStmt>(catchStmt)) {
Ted Kremenek50a25e22008-10-06 22:39:38 +00001349 QualType t = dyn_cast<ValueDecl>(declStmt->getSolitaryDecl())->getType();
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001350 if (t == Context->getObjCIdType()) {
Steve Naroff75730982007-11-07 04:08:17 +00001351 buf += "1) { ";
Chris Lattneraadaf782008-01-31 19:51:04 +00001352 ReplaceText(startLoc, lParenLoc-startBuf+1, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001353 sawIdTypedCatch = true;
1354 } else if (const PointerType *pType = t->getAsPointerType()) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001355 ObjCInterfaceType *cls; // Should be a pointer to a class.
Steve Naroff75730982007-11-07 04:08:17 +00001356
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001357 cls = dyn_cast<ObjCInterfaceType>(pType->getPointeeType().getTypePtr());
Steve Naroff75730982007-11-07 04:08:17 +00001358 if (cls) {
Steve Naroff21867b12007-11-07 18:43:40 +00001359 buf += "objc_exception_match((struct objc_class *)objc_getClass(\"";
Steve Naroff75730982007-11-07 04:08:17 +00001360 buf += cls->getDecl()->getName();
Steve Naroff21867b12007-11-07 18:43:40 +00001361 buf += "\"), (struct objc_object *)_caught)) { ";
Chris Lattneraadaf782008-01-31 19:51:04 +00001362 ReplaceText(startLoc, lParenLoc-startBuf+1, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001363 }
1364 }
1365 // Now rewrite the body...
1366 lastCatchBody = catchList->getCatchBody();
1367 SourceLocation rParenLoc = catchList->getRParenLoc();
1368 SourceLocation bodyLoc = lastCatchBody->getLocStart();
1369 const char *bodyBuf = SM->getCharacterData(bodyLoc);
1370 const char *rParenBuf = SM->getCharacterData(rParenLoc);
1371 assert((*rParenBuf == ')') && "bogus @catch paren location");
1372 assert((*bodyBuf == '{') && "bogus @catch body location");
1373
1374 buf = " = _caught;";
1375 // Here we replace ") {" with "= _caught;" (which initializes and
1376 // declares the @catch parameter).
Chris Lattneraadaf782008-01-31 19:51:04 +00001377 ReplaceText(rParenLoc, bodyBuf-rParenBuf+1, buf.c_str(), buf.size());
Steve Naroff2bd03922007-11-07 15:32:26 +00001378 } else if (!isa<NullStmt>(catchStmt)) {
Steve Naroff75730982007-11-07 04:08:17 +00001379 assert(false && "@catch rewrite bug");
Steve Naroff2bd03922007-11-07 15:32:26 +00001380 }
Steve Naroffe12e6922008-02-01 20:02:07 +00001381 // make sure all the catch bodies get rewritten!
Steve Naroff75730982007-11-07 04:08:17 +00001382 catchList = catchList->getNextCatchStmt();
1383 }
1384 // Complete the catch list...
1385 if (lastCatchBody) {
1386 SourceLocation bodyLoc = lastCatchBody->getLocEnd();
Chris Lattner06767512008-04-08 05:52:18 +00001387 assert(*SM->getCharacterData(bodyLoc) == '}' &&
1388 "bogus @catch body location");
Steve Naroff75730982007-11-07 04:08:17 +00001389
Steve Naroff378f47a2008-09-11 15:29:03 +00001390 // Insert the last (implicit) else clause *before* the right curly brace.
1391 bodyLoc = bodyLoc.getFileLocWithOffset(-1);
1392 buf = "} /* last catch end */\n";
1393 buf += "else {\n";
1394 buf += " _rethrow = _caught;\n";
1395 buf += " objc_exception_try_exit(&_stack);\n";
1396 buf += "} } /* @catch end */\n";
1397 if (!S->getFinallyStmt())
1398 buf += "}\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001399 InsertText(bodyLoc, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001400
1401 // Set lastCurlyLoc
1402 lastCurlyLoc = lastCatchBody->getLocEnd();
1403 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001404 if (ObjCAtFinallyStmt *finalStmt = S->getFinallyStmt()) {
Steve Naroff75730982007-11-07 04:08:17 +00001405 startLoc = finalStmt->getLocStart();
1406 startBuf = SM->getCharacterData(startLoc);
1407 assert((*startBuf == '@') && "bogus @finally start");
1408
1409 buf = "/* @finally */";
Chris Lattneraadaf782008-01-31 19:51:04 +00001410 ReplaceText(startLoc, 8, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001411
1412 Stmt *body = finalStmt->getFinallyBody();
1413 SourceLocation startLoc = body->getLocStart();
1414 SourceLocation endLoc = body->getLocEnd();
Chris Lattner06767512008-04-08 05:52:18 +00001415 assert(*SM->getCharacterData(startLoc) == '{' &&
1416 "bogus @finally body location");
1417 assert(*SM->getCharacterData(endLoc) == '}' &&
1418 "bogus @finally body location");
Steve Naroff75730982007-11-07 04:08:17 +00001419
1420 startLoc = startLoc.getFileLocWithOffset(1);
1421 buf = " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001422 InsertText(startLoc, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001423 endLoc = endLoc.getFileLocWithOffset(-1);
1424 buf = " if (_rethrow) objc_exception_throw(_rethrow);\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001425 InsertText(endLoc, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001426
1427 // Set lastCurlyLoc
1428 lastCurlyLoc = body->getLocEnd();
Steve Naroff378f47a2008-09-11 15:29:03 +00001429 } else { /* no finally clause - make sure we synthesize an implicit one */
1430 buf = "{ /* implicit finally clause */\n";
1431 buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
1432 buf += " if (_rethrow) objc_exception_throw(_rethrow);\n";
1433 buf += "}";
1434 ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001435 }
1436 // Now emit the final closing curly brace...
1437 lastCurlyLoc = lastCurlyLoc.getFileLocWithOffset(1);
1438 buf = " } /* @try scope end */\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001439 InsertText(lastCurlyLoc, buf.c_str(), buf.size());
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001440 return 0;
1441}
1442
Steve Naroffb29b4272008-04-14 22:03:09 +00001443Stmt *RewriteObjC::RewriteObjCCatchStmt(ObjCAtCatchStmt *S) {
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001444 return 0;
1445}
1446
Steve Naroffb29b4272008-04-14 22:03:09 +00001447Stmt *RewriteObjC::RewriteObjCFinallyStmt(ObjCAtFinallyStmt *S) {
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001448 return 0;
1449}
1450
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001451// This can't be done with ReplaceStmt(S, ThrowExpr), since
Steve Naroff2bd03922007-11-07 15:32:26 +00001452// the throw expression is typically a message expression that's already
1453// been rewritten! (which implies the SourceLocation's are invalid).
Steve Naroffb29b4272008-04-14 22:03:09 +00001454Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
Steve Naroff2bd03922007-11-07 15:32:26 +00001455 // Get the start location and compute the semi location.
1456 SourceLocation startLoc = S->getLocStart();
1457 const char *startBuf = SM->getCharacterData(startLoc);
1458
1459 assert((*startBuf == '@') && "bogus @throw location");
1460
1461 std::string buf;
1462 /* void objc_exception_throw(id) __attribute__((noreturn)); */
Steve Naroff20ebf8f2008-01-19 00:42:38 +00001463 if (S->getThrowExpr())
1464 buf = "objc_exception_throw(";
1465 else // add an implicit argument
1466 buf = "objc_exception_throw(_caught";
Steve Naroff4ba0acb2008-07-25 15:41:30 +00001467
1468 // handle "@ throw" correctly.
1469 const char *wBuf = strchr(startBuf, 'w');
1470 assert((*wBuf == 'w') && "@throw: can't find 'w'");
1471 ReplaceText(startLoc, wBuf-startBuf+1, buf.c_str(), buf.size());
1472
Steve Naroff2bd03922007-11-07 15:32:26 +00001473 const char *semiBuf = strchr(startBuf, ';');
1474 assert((*semiBuf == ';') && "@throw: can't find ';'");
1475 SourceLocation semiLoc = startLoc.getFileLocWithOffset(semiBuf-startBuf);
1476 buf = ");";
Chris Lattneraadaf782008-01-31 19:51:04 +00001477 ReplaceText(semiLoc, 1, buf.c_str(), buf.size());
Steve Naroff2bd03922007-11-07 15:32:26 +00001478 return 0;
1479}
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001480
Steve Naroffb29b4272008-04-14 22:03:09 +00001481Stmt *RewriteObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
Chris Lattner01c57482007-10-17 22:35:30 +00001482 // Create a new string expression.
1483 QualType StrType = Context->getPointerType(Context->CharTy);
Anders Carlsson85f9bce2007-10-29 05:01:08 +00001484 std::string StrEncoding;
Daniel Dunbar0d504c12008-10-17 20:21:44 +00001485 Context->getObjCEncodingForType(Exp->getEncodedType(), StrEncoding);
Anders Carlsson85f9bce2007-10-29 05:01:08 +00001486 Expr *Replacement = new StringLiteral(StrEncoding.c_str(),
1487 StrEncoding.length(), false, StrType,
Chris Lattner01c57482007-10-17 22:35:30 +00001488 SourceLocation(), SourceLocation());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001489 ReplaceStmt(Exp, Replacement);
Chris Lattnere365c502007-11-30 22:25:36 +00001490
Chris Lattner07506182007-11-30 22:53:43 +00001491 // Replace this subexpr in the parent.
Chris Lattnere64b7772007-10-24 16:57:36 +00001492 delete Exp;
1493 return Replacement;
Chris Lattner311ff022007-10-16 22:36:42 +00001494}
1495
Steve Naroffb29b4272008-04-14 22:03:09 +00001496Stmt *RewriteObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
Steve Naroffb42f8412007-11-05 14:50:49 +00001497 assert(SelGetUidFunctionDecl && "Can't find sel_registerName() decl");
1498 // Create a call to sel_registerName("selName").
1499 llvm::SmallVector<Expr*, 8> SelExprs;
1500 QualType argType = Context->getPointerType(Context->CharTy);
1501 SelExprs.push_back(new StringLiteral(Exp->getSelector().getName().c_str(),
1502 Exp->getSelector().getName().size(),
1503 false, argType, SourceLocation(),
1504 SourceLocation()));
1505 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
1506 &SelExprs[0], SelExprs.size());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001507 ReplaceStmt(Exp, SelExp);
Steve Naroffb42f8412007-11-05 14:50:49 +00001508 delete Exp;
1509 return SelExp;
1510}
1511
Steve Naroffb29b4272008-04-14 22:03:09 +00001512CallExpr *RewriteObjC::SynthesizeCallToFunctionDecl(
Steve Naroff934f2762007-10-24 22:48:43 +00001513 FunctionDecl *FD, Expr **args, unsigned nargs) {
Steve Naroffebf2b562007-10-23 23:50:29 +00001514 // Get the type, we will need to reference it in a couple spots.
Steve Naroff934f2762007-10-24 22:48:43 +00001515 QualType msgSendType = FD->getType();
Steve Naroffebf2b562007-10-23 23:50:29 +00001516
1517 // Create a reference to the objc_msgSend() declaration.
Steve Naroff934f2762007-10-24 22:48:43 +00001518 DeclRefExpr *DRE = new DeclRefExpr(FD, msgSendType, SourceLocation());
Steve Naroffebf2b562007-10-23 23:50:29 +00001519
1520 // Now, we cast the reference to a pointer to the objc_msgSend type.
Chris Lattnerf04da132007-10-24 17:06:59 +00001521 QualType pToFunc = Context->getPointerType(msgSendType);
Douglas Gregoreb8f3062008-11-12 17:17:38 +00001522 ImplicitCastExpr *ICE = new ImplicitCastExpr(pToFunc, DRE,
1523 /*isLvalue=*/false);
Steve Naroffebf2b562007-10-23 23:50:29 +00001524
1525 const FunctionType *FT = msgSendType->getAsFunctionType();
Chris Lattnere64b7772007-10-24 16:57:36 +00001526
Steve Naroff934f2762007-10-24 22:48:43 +00001527 return new CallExpr(ICE, args, nargs, FT->getResultType(), SourceLocation());
1528}
1529
Steve Naroffd5255f52007-11-01 13:24:47 +00001530static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
1531 const char *&startRef, const char *&endRef) {
1532 while (startBuf < endBuf) {
1533 if (*startBuf == '<')
1534 startRef = startBuf; // mark the start.
1535 if (*startBuf == '>') {
Steve Naroff32174822007-11-09 12:50:28 +00001536 if (startRef && *startRef == '<') {
1537 endRef = startBuf; // mark the end.
1538 return true;
1539 }
1540 return false;
Steve Naroffd5255f52007-11-01 13:24:47 +00001541 }
1542 startBuf++;
1543 }
1544 return false;
1545}
1546
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001547static void scanToNextArgument(const char *&argRef) {
1548 int angle = 0;
1549 while (*argRef != ')' && (*argRef != ',' || angle > 0)) {
1550 if (*argRef == '<')
1551 angle++;
1552 else if (*argRef == '>')
1553 angle--;
1554 argRef++;
1555 }
1556 assert(angle == 0 && "scanToNextArgument - bad protocol type syntax");
1557}
Fariborz Jahanian291e04b2007-12-11 23:04:08 +00001558
Steve Naroffb29b4272008-04-14 22:03:09 +00001559bool RewriteObjC::needToScanForQualifiers(QualType T) {
Fariborz Jahanianc5692492007-12-17 21:03:50 +00001560
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001561 if (T->isObjCQualifiedIdType())
Fariborz Jahanianc5692492007-12-17 21:03:50 +00001562 return true;
1563
Steve Naroffd5255f52007-11-01 13:24:47 +00001564 if (const PointerType *pType = T->getAsPointerType()) {
Steve Naroff9165ad32007-10-31 04:38:33 +00001565 Type *pointeeType = pType->getPointeeType().getTypePtr();
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001566 if (isa<ObjCQualifiedInterfaceType>(pointeeType))
Steve Naroff9165ad32007-10-31 04:38:33 +00001567 return true; // we have "Class <Protocol> *".
1568 }
Steve Naroffd5255f52007-11-01 13:24:47 +00001569 return false;
1570}
1571
Steve Naroff4f95b752008-07-29 18:15:38 +00001572void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
1573 QualType Type = E->getType();
1574 if (needToScanForQualifiers(Type)) {
1575 SourceLocation Loc = E->getLocStart();
1576 const char *startBuf = SM->getCharacterData(Loc);
1577 const char *endBuf = SM->getCharacterData(E->getLocEnd());
1578 const char *startRef = 0, *endRef = 0;
1579 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
1580 // Get the locations of the startRef, endRef.
1581 SourceLocation LessLoc = Loc.getFileLocWithOffset(startRef-startBuf);
1582 SourceLocation GreaterLoc = Loc.getFileLocWithOffset(endRef-startBuf+1);
1583 // Comment out the protocol references.
1584 InsertText(LessLoc, "/*", 2);
1585 InsertText(GreaterLoc, "*/", 2);
1586 }
1587 }
1588}
1589
Steve Naroffb29b4272008-04-14 22:03:09 +00001590void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) {
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001591 SourceLocation Loc;
1592 QualType Type;
1593 const FunctionTypeProto *proto = 0;
1594 if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) {
1595 Loc = VD->getLocation();
1596 Type = VD->getType();
1597 }
1598 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Dcl)) {
1599 Loc = FD->getLocation();
1600 // Check for ObjC 'id' and class types that have been adorned with protocol
1601 // information (id<p>, C<p>*). The protocol references need to be rewritten!
1602 const FunctionType *funcType = FD->getType()->getAsFunctionType();
1603 assert(funcType && "missing function type");
1604 proto = dyn_cast<FunctionTypeProto>(funcType);
1605 if (!proto)
1606 return;
1607 Type = proto->getResultType();
1608 }
1609 else
1610 return;
Steve Naroffd5255f52007-11-01 13:24:47 +00001611
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001612 if (needToScanForQualifiers(Type)) {
Steve Naroffd5255f52007-11-01 13:24:47 +00001613 // Since types are unique, we need to scan the buffer.
Steve Naroffd5255f52007-11-01 13:24:47 +00001614
1615 const char *endBuf = SM->getCharacterData(Loc);
1616 const char *startBuf = endBuf;
Steve Naroff6cafbf22008-05-31 05:02:17 +00001617 while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart)
Steve Naroffd5255f52007-11-01 13:24:47 +00001618 startBuf--; // scan backward (from the decl location) for return type.
1619 const char *startRef = 0, *endRef = 0;
1620 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
1621 // Get the locations of the startRef, endRef.
1622 SourceLocation LessLoc = Loc.getFileLocWithOffset(startRef-endBuf);
1623 SourceLocation GreaterLoc = Loc.getFileLocWithOffset(endRef-endBuf+1);
1624 // Comment out the protocol references.
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001625 InsertText(LessLoc, "/*", 2);
1626 InsertText(GreaterLoc, "*/", 2);
Steve Naroff9165ad32007-10-31 04:38:33 +00001627 }
1628 }
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001629 if (!proto)
1630 return; // most likely, was a variable
Steve Naroffd5255f52007-11-01 13:24:47 +00001631 // Now check arguments.
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001632 const char *startBuf = SM->getCharacterData(Loc);
1633 const char *startFuncBuf = startBuf;
Steve Naroffd5255f52007-11-01 13:24:47 +00001634 for (unsigned i = 0; i < proto->getNumArgs(); i++) {
1635 if (needToScanForQualifiers(proto->getArgType(i))) {
1636 // Since types are unique, we need to scan the buffer.
Steve Naroffd5255f52007-11-01 13:24:47 +00001637
Steve Naroffd5255f52007-11-01 13:24:47 +00001638 const char *endBuf = startBuf;
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001639 // scan forward (from the decl location) for argument types.
1640 scanToNextArgument(endBuf);
Steve Naroffd5255f52007-11-01 13:24:47 +00001641 const char *startRef = 0, *endRef = 0;
1642 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
1643 // Get the locations of the startRef, endRef.
Fariborz Jahanian291e04b2007-12-11 23:04:08 +00001644 SourceLocation LessLoc =
1645 Loc.getFileLocWithOffset(startRef-startFuncBuf);
1646 SourceLocation GreaterLoc =
1647 Loc.getFileLocWithOffset(endRef-startFuncBuf+1);
Steve Naroffd5255f52007-11-01 13:24:47 +00001648 // Comment out the protocol references.
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001649 InsertText(LessLoc, "/*", 2);
1650 InsertText(GreaterLoc, "*/", 2);
Steve Naroffd5255f52007-11-01 13:24:47 +00001651 }
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001652 startBuf = ++endBuf;
1653 }
1654 else {
Steve Naroffaba49d12008-08-06 15:58:23 +00001655 // If the function name is derived from a macro expansion, then the
1656 // argument buffer will not follow the name. Need to speak with Chris.
1657 while (*startBuf && *startBuf != ')' && *startBuf != ',')
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001658 startBuf++; // scan forward (from the decl location) for argument types.
1659 startBuf++;
1660 }
Steve Naroffd5255f52007-11-01 13:24:47 +00001661 }
Steve Naroff9165ad32007-10-31 04:38:33 +00001662}
1663
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001664// SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
Steve Naroffb29b4272008-04-14 22:03:09 +00001665void RewriteObjC::SynthSelGetUidFunctionDecl() {
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001666 IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
1667 llvm::SmallVector<QualType, 16> ArgTys;
1668 ArgTys.push_back(Context->getPointerType(
1669 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001670 QualType getFuncType = Context->getFunctionType(Context->getObjCSelType(),
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001671 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001672 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001673 SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001674 SourceLocation(),
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001675 SelGetUidIdent, getFuncType,
1676 FunctionDecl::Extern, false, 0);
1677}
1678
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001679// SynthGetProtocolFunctionDecl - Protocol objc_getProtocol(const char *proto);
Steve Naroffb29b4272008-04-14 22:03:09 +00001680void RewriteObjC::SynthGetProtocolFunctionDecl() {
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001681 IdentifierInfo *SelGetProtoIdent = &Context->Idents.get("objc_getProtocol");
1682 llvm::SmallVector<QualType, 16> ArgTys;
1683 ArgTys.push_back(Context->getPointerType(
1684 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001685 QualType getFuncType = Context->getFunctionType(Context->getObjCProtoType(),
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001686 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001687 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001688 GetProtocolFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001689 SourceLocation(),
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001690 SelGetProtoIdent, getFuncType,
1691 FunctionDecl::Extern, false, 0);
1692}
1693
Steve Naroffb29b4272008-04-14 22:03:09 +00001694void RewriteObjC::RewriteFunctionDecl(FunctionDecl *FD) {
Steve Naroff09b266e2007-10-30 23:14:51 +00001695 // declared in <objc/objc.h>
Steve Naroffbeaf2992007-11-03 11:27:19 +00001696 if (strcmp(FD->getName(), "sel_registerName") == 0) {
Steve Naroff09b266e2007-10-30 23:14:51 +00001697 SelGetUidFunctionDecl = FD;
Steve Naroff9165ad32007-10-31 04:38:33 +00001698 return;
1699 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001700 RewriteObjCQualifiedInterfaceTypes(FD);
Steve Naroff09b266e2007-10-30 23:14:51 +00001701}
1702
Steve Naroffc0a123c2008-03-11 17:37:02 +00001703// SynthSuperContructorFunctionDecl - id objc_super(id obj, id super);
Steve Naroffb29b4272008-04-14 22:03:09 +00001704void RewriteObjC::SynthSuperContructorFunctionDecl() {
Steve Naroffc0a123c2008-03-11 17:37:02 +00001705 if (SuperContructorFunctionDecl)
1706 return;
1707 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_super");
1708 llvm::SmallVector<QualType, 16> ArgTys;
1709 QualType argT = Context->getObjCIdType();
1710 assert(!argT.isNull() && "Can't find 'id' type");
1711 ArgTys.push_back(argT);
1712 ArgTys.push_back(argT);
1713 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
1714 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001715 false, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001716 SuperContructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001717 SourceLocation(),
Steve Naroffc0a123c2008-03-11 17:37:02 +00001718 msgSendIdent, msgSendType,
1719 FunctionDecl::Extern, false, 0);
1720}
1721
Steve Naroff09b266e2007-10-30 23:14:51 +00001722// SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001723void RewriteObjC::SynthMsgSendFunctionDecl() {
Steve Naroff09b266e2007-10-30 23:14:51 +00001724 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
1725 llvm::SmallVector<QualType, 16> ArgTys;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001726 QualType argT = Context->getObjCIdType();
Steve Naroff09b266e2007-10-30 23:14:51 +00001727 assert(!argT.isNull() && "Can't find 'id' type");
1728 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001729 argT = Context->getObjCSelType();
Steve Naroff09b266e2007-10-30 23:14:51 +00001730 assert(!argT.isNull() && "Can't find 'SEL' type");
1731 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001732 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff09b266e2007-10-30 23:14:51 +00001733 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001734 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001735 MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001736 SourceLocation(),
Steve Naroff09b266e2007-10-30 23:14:51 +00001737 msgSendIdent, msgSendType,
1738 FunctionDecl::Extern, false, 0);
1739}
1740
Steve Naroff874e2322007-11-15 10:28:18 +00001741// SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(struct objc_super *, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001742void RewriteObjC::SynthMsgSendSuperFunctionDecl() {
Steve Naroff874e2322007-11-15 10:28:18 +00001743 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
1744 llvm::SmallVector<QualType, 16> ArgTys;
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001745 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001746 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00001747 &Context->Idents.get("objc_super"));
Steve Naroff874e2322007-11-15 10:28:18 +00001748 QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
1749 assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
1750 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001751 argT = Context->getObjCSelType();
Steve Naroff874e2322007-11-15 10:28:18 +00001752 assert(!argT.isNull() && "Can't find 'SEL' type");
1753 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001754 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff874e2322007-11-15 10:28:18 +00001755 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001756 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001757 MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001758 SourceLocation(),
Steve Naroff874e2322007-11-15 10:28:18 +00001759 msgSendIdent, msgSendType,
1760 FunctionDecl::Extern, false, 0);
1761}
1762
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001763// SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001764void RewriteObjC::SynthMsgSendStretFunctionDecl() {
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001765 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
1766 llvm::SmallVector<QualType, 16> ArgTys;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001767 QualType argT = Context->getObjCIdType();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001768 assert(!argT.isNull() && "Can't find 'id' type");
1769 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001770 argT = Context->getObjCSelType();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001771 assert(!argT.isNull() && "Can't find 'SEL' type");
1772 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001773 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001774 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001775 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001776 MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001777 SourceLocation(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001778 msgSendIdent, msgSendType,
1779 FunctionDecl::Extern, false, 0);
1780}
1781
1782// SynthMsgSendSuperStretFunctionDecl -
1783// id objc_msgSendSuper_stret(struct objc_super *, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001784void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() {
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001785 IdentifierInfo *msgSendIdent =
1786 &Context->Idents.get("objc_msgSendSuper_stret");
1787 llvm::SmallVector<QualType, 16> ArgTys;
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001788 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001789 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00001790 &Context->Idents.get("objc_super"));
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001791 QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
1792 assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
1793 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001794 argT = Context->getObjCSelType();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001795 assert(!argT.isNull() && "Can't find 'SEL' type");
1796 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001797 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001798 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001799 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001800 MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattnera98e58d2008-03-15 21:24:04 +00001801 SourceLocation(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001802 msgSendIdent, msgSendType,
1803 FunctionDecl::Extern, false, 0);
1804}
1805
Steve Naroff1284db82008-05-08 22:02:18 +00001806// SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001807void RewriteObjC::SynthMsgSendFpretFunctionDecl() {
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001808 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
1809 llvm::SmallVector<QualType, 16> ArgTys;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001810 QualType argT = Context->getObjCIdType();
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001811 assert(!argT.isNull() && "Can't find 'id' type");
1812 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001813 argT = Context->getObjCSelType();
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001814 assert(!argT.isNull() && "Can't find 'SEL' type");
1815 ArgTys.push_back(argT);
Steve Naroff1284db82008-05-08 22:02:18 +00001816 QualType msgSendType = Context->getFunctionType(Context->DoubleTy,
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001817 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001818 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001819 MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001820 SourceLocation(),
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001821 msgSendIdent, msgSendType,
1822 FunctionDecl::Extern, false, 0);
1823}
1824
Steve Naroff09b266e2007-10-30 23:14:51 +00001825// SynthGetClassFunctionDecl - id objc_getClass(const char *name);
Steve Naroffb29b4272008-04-14 22:03:09 +00001826void RewriteObjC::SynthGetClassFunctionDecl() {
Steve Naroff09b266e2007-10-30 23:14:51 +00001827 IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
1828 llvm::SmallVector<QualType, 16> ArgTys;
1829 ArgTys.push_back(Context->getPointerType(
1830 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001831 QualType getClassType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff09b266e2007-10-30 23:14:51 +00001832 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001833 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001834 GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001835 SourceLocation(),
Steve Naroff09b266e2007-10-30 23:14:51 +00001836 getClassIdent, getClassType,
1837 FunctionDecl::Extern, false, 0);
1838}
1839
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00001840// SynthGetMetaClassFunctionDecl - id objc_getClass(const char *name);
Steve Naroffb29b4272008-04-14 22:03:09 +00001841void RewriteObjC::SynthGetMetaClassFunctionDecl() {
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00001842 IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
1843 llvm::SmallVector<QualType, 16> ArgTys;
1844 ArgTys.push_back(Context->getPointerType(
1845 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001846 QualType getClassType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00001847 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001848 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001849 GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001850 SourceLocation(),
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00001851 getClassIdent, getClassType,
1852 FunctionDecl::Extern, false, 0);
1853}
1854
Steve Naroffb29b4272008-04-14 22:03:09 +00001855Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001856 QualType strType = getConstantStringStructType();
1857
1858 std::string S = "__NSConstantStringImpl_";
Steve Naroff7691d9b2008-05-31 03:35:42 +00001859
1860 std::string tmpName = InFileName;
1861 unsigned i;
1862 for (i=0; i < tmpName.length(); i++) {
1863 char c = tmpName.at(i);
1864 // replace any non alphanumeric characters with '_'.
1865 if (!isalpha(c) && (c < '0' || c > '9'))
1866 tmpName[i] = '_';
1867 }
1868 S += tmpName;
1869 S += "_";
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001870 S += utostr(NumObjCStringLiterals++);
1871
Steve Naroffba92b2e2008-03-27 22:29:16 +00001872 Preamble += "static __NSConstantStringImpl " + S;
1873 Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
1874 Preamble += "0x000007c8,"; // utf8_str
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001875 // The pretty printer for StringLiteral handles escape characters properly.
Ted Kremeneka95d3752008-09-13 05:16:45 +00001876 std::string prettyBufS;
1877 llvm::raw_string_ostream prettyBuf(prettyBufS);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001878 Exp->getString()->printPretty(prettyBuf);
Steve Naroffba92b2e2008-03-27 22:29:16 +00001879 Preamble += prettyBuf.str();
1880 Preamble += ",";
Steve Naroff3652c2d2008-03-15 01:36:04 +00001881 // The minus 2 removes the begin/end double quotes.
Steve Naroffba92b2e2008-03-27 22:29:16 +00001882 Preamble += utostr(prettyBuf.str().size()-2) + "};\n";
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001883
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001884 VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
Steve Naroff248a7532008-04-15 22:42:06 +00001885 &Context->Idents.get(S.c_str()), strType,
1886 VarDecl::Static, NULL);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001887 DeclRefExpr *DRE = new DeclRefExpr(NewVD, strType, SourceLocation());
1888 Expr *Unop = new UnaryOperator(DRE, UnaryOperator::AddrOf,
1889 Context->getPointerType(DRE->getType()),
1890 SourceLocation());
Steve Naroff96984642007-11-08 14:30:50 +00001891 // cast to NSConstantString *
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001892 CastExpr *cast = new CStyleCastExpr(Exp->getType(), Unop,
Steve Naroffb2f9e512008-11-03 23:29:32 +00001893 Exp->getType(), SourceLocation(), SourceLocation());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001894 ReplaceStmt(Exp, cast);
Steve Naroff96984642007-11-08 14:30:50 +00001895 delete Exp;
1896 return cast;
Steve Naroffbeaf2992007-11-03 11:27:19 +00001897}
1898
Steve Naroffb29b4272008-04-14 22:03:09 +00001899ObjCInterfaceDecl *RewriteObjC::isSuperReceiver(Expr *recExpr) {
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00001900 // check if we are sending a message to 'super'
Steve Naroff54055232008-10-27 17:20:55 +00001901 if (!CurMethodDef || !CurMethodDef->isInstance()) return 0;
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00001902
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00001903 if (ObjCSuperExpr *Super = dyn_cast<ObjCSuperExpr>(recExpr)) {
1904 const PointerType *PT = Super->getType()->getAsPointerType();
Chris Lattner0d17f6f2008-06-21 18:04:54 +00001905 assert(PT);
1906 ObjCInterfaceType *IT = cast<ObjCInterfaceType>(PT->getPointeeType());
1907 return IT->getDecl();
1908 }
1909 return 0;
Steve Naroff874e2322007-11-15 10:28:18 +00001910}
1911
1912// struct objc_super { struct objc_object *receiver; struct objc_class *super; };
Steve Naroffb29b4272008-04-14 22:03:09 +00001913QualType RewriteObjC::getSuperStructType() {
Steve Naroff874e2322007-11-15 10:28:18 +00001914 if (!SuperStructDecl) {
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001915 SuperStructDecl = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattnerc63e6602008-03-15 21:32:50 +00001916 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00001917 &Context->Idents.get("objc_super"));
Steve Naroff874e2322007-11-15 10:28:18 +00001918 QualType FieldTypes[2];
1919
1920 // struct objc_object *receiver;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001921 FieldTypes[0] = Context->getObjCIdType();
Steve Naroff874e2322007-11-15 10:28:18 +00001922 // struct objc_class *super;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001923 FieldTypes[1] = Context->getObjCClassType();
Steve Naroff874e2322007-11-15 10:28:18 +00001924 // Create fields
1925 FieldDecl *FieldDecls[2];
1926
1927 for (unsigned i = 0; i < 2; ++i)
Chris Lattnerb048c982008-04-06 04:47:34 +00001928 FieldDecls[i] = FieldDecl::Create(*Context, SourceLocation(), 0,
Chris Lattner8e25d862008-03-16 00:16:02 +00001929 FieldTypes[i]);
Steve Naroff874e2322007-11-15 10:28:18 +00001930
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001931 SuperStructDecl->defineBody(*Context, FieldDecls, 4);
Steve Naroff874e2322007-11-15 10:28:18 +00001932 }
1933 return Context->getTagDeclType(SuperStructDecl);
1934}
1935
Steve Naroffb29b4272008-04-14 22:03:09 +00001936QualType RewriteObjC::getConstantStringStructType() {
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001937 if (!ConstantStringDecl) {
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001938 ConstantStringDecl = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattnerc63e6602008-03-15 21:32:50 +00001939 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00001940 &Context->Idents.get("__NSConstantStringImpl"));
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001941 QualType FieldTypes[4];
1942
1943 // struct objc_object *receiver;
1944 FieldTypes[0] = Context->getObjCIdType();
1945 // int flags;
1946 FieldTypes[1] = Context->IntTy;
1947 // char *str;
1948 FieldTypes[2] = Context->getPointerType(Context->CharTy);
1949 // long length;
1950 FieldTypes[3] = Context->LongTy;
1951 // Create fields
Steve Naroff9630ec52008-03-27 22:59:54 +00001952 FieldDecl *FieldDecls[4];
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001953
1954 for (unsigned i = 0; i < 4; ++i)
Chris Lattnerb048c982008-04-06 04:47:34 +00001955 FieldDecls[i] = FieldDecl::Create(*Context, SourceLocation(), 0,
Chris Lattner8e25d862008-03-16 00:16:02 +00001956 FieldTypes[i]);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001957
Ted Kremenek4b7c9832008-09-05 17:16:31 +00001958 ConstantStringDecl->defineBody(*Context, FieldDecls, 4);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00001959 }
1960 return Context->getTagDeclType(ConstantStringDecl);
1961}
1962
Steve Naroffb29b4272008-04-14 22:03:09 +00001963Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001964 if (!SelGetUidFunctionDecl)
1965 SynthSelGetUidFunctionDecl();
Steve Naroff09b266e2007-10-30 23:14:51 +00001966 if (!MsgSendFunctionDecl)
1967 SynthMsgSendFunctionDecl();
Steve Naroff874e2322007-11-15 10:28:18 +00001968 if (!MsgSendSuperFunctionDecl)
1969 SynthMsgSendSuperFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001970 if (!MsgSendStretFunctionDecl)
1971 SynthMsgSendStretFunctionDecl();
1972 if (!MsgSendSuperStretFunctionDecl)
1973 SynthMsgSendSuperStretFunctionDecl();
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001974 if (!MsgSendFpretFunctionDecl)
1975 SynthMsgSendFpretFunctionDecl();
Steve Naroff09b266e2007-10-30 23:14:51 +00001976 if (!GetClassFunctionDecl)
1977 SynthGetClassFunctionDecl();
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00001978 if (!GetMetaClassFunctionDecl)
1979 SynthGetMetaClassFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001980
Steve Naroff874e2322007-11-15 10:28:18 +00001981 // default to objc_msgSend().
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001982 FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
1983 // May need to use objc_msgSend_stret() as well.
1984 FunctionDecl *MsgSendStretFlavor = 0;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001985 if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001986 QualType resultType = mDecl->getResultType();
Chris Lattner8b51fd72008-07-26 22:36:27 +00001987 if (resultType->isStructureType() || resultType->isUnionType())
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001988 MsgSendStretFlavor = MsgSendStretFunctionDecl;
Chris Lattner8b51fd72008-07-26 22:36:27 +00001989 else if (resultType->isRealFloatingType())
Fariborz Jahanianacb49772007-12-03 21:26:48 +00001990 MsgSendFlavor = MsgSendFpretFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00001991 }
Steve Naroff874e2322007-11-15 10:28:18 +00001992
Steve Naroff934f2762007-10-24 22:48:43 +00001993 // Synthesize a call to objc_msgSend().
1994 llvm::SmallVector<Expr*, 8> MsgExprs;
1995 IdentifierInfo *clsName = Exp->getClassName();
1996
1997 // Derive/push the receiver/selector, 2 implicit arguments to objc_msgSend().
1998 if (clsName) { // class message.
Steve Narofffc93d522008-07-24 19:44:33 +00001999 // FIXME: We need to fix Sema (and the AST for ObjCMessageExpr) to handle
2000 // the 'super' idiom within a class method.
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002001 if (!strcmp(clsName->getName(), "super")) {
2002 MsgSendFlavor = MsgSendSuperFunctionDecl;
2003 if (MsgSendStretFlavor)
2004 MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
2005 assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
2006
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002007 ObjCInterfaceDecl *SuperDecl =
Steve Naroff54055232008-10-27 17:20:55 +00002008 CurMethodDef->getClassInterface()->getSuperClass();
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002009
2010 llvm::SmallVector<Expr*, 4> InitExprs;
2011
2012 // set the receiver to self, the first argument to all methods.
Chris Lattner41110242008-06-17 18:05:57 +00002013 InitExprs.push_back(new DeclRefExpr(
Steve Naroff54055232008-10-27 17:20:55 +00002014 CurMethodDef->getSelfDecl(),
Chris Lattner41110242008-06-17 18:05:57 +00002015 Context->getObjCIdType(),
2016 SourceLocation()));
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002017 llvm::SmallVector<Expr*, 8> ClsExprs;
2018 QualType argType = Context->getPointerType(Context->CharTy);
2019 ClsExprs.push_back(new StringLiteral(SuperDecl->getIdentifier()->getName(),
2020 SuperDecl->getIdentifier()->getLength(),
2021 false, argType, SourceLocation(),
2022 SourceLocation()));
2023 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
2024 &ClsExprs[0],
2025 ClsExprs.size());
2026 // To turn off a warning, type-cast to 'id'
Douglas Gregor49badde2008-10-27 19:41:14 +00002027 InitExprs.push_back( // set 'super class', using objc_getClass().
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002028 new CStyleCastExpr(Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00002029 Cls, Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002030 SourceLocation(), SourceLocation()));
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002031 // struct objc_super
2032 QualType superType = getSuperStructType();
Steve Naroff23f41272008-03-11 18:14:26 +00002033 Expr *SuperRep;
Steve Naroffc0a123c2008-03-11 17:37:02 +00002034
Steve Naroff23f41272008-03-11 18:14:26 +00002035 if (LangOpts.Microsoft) {
2036 SynthSuperContructorFunctionDecl();
2037 // Simulate a contructor call...
2038 DeclRefExpr *DRE = new DeclRefExpr(SuperContructorFunctionDecl,
2039 superType, SourceLocation());
2040 SuperRep = new CallExpr(DRE, &InitExprs[0], InitExprs.size(),
2041 superType, SourceLocation());
2042 } else {
2043 // (struct objc_super) { <exprs from above> }
2044 InitListExpr *ILE = new InitListExpr(SourceLocation(),
2045 &InitExprs[0], InitExprs.size(),
Chris Lattner418f6c72008-10-26 23:43:26 +00002046 SourceLocation(), false);
2047 SuperRep = new CompoundLiteralExpr(SourceLocation(), superType, ILE,
2048 false);
Steve Naroff23f41272008-03-11 18:14:26 +00002049 }
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002050 // struct objc_super *
2051 Expr *Unop = new UnaryOperator(SuperRep, UnaryOperator::AddrOf,
2052 Context->getPointerType(SuperRep->getType()),
2053 SourceLocation());
2054 MsgExprs.push_back(Unop);
2055 } else {
2056 llvm::SmallVector<Expr*, 8> ClsExprs;
2057 QualType argType = Context->getPointerType(Context->CharTy);
2058 ClsExprs.push_back(new StringLiteral(clsName->getName(),
2059 clsName->getLength(),
2060 false, argType, SourceLocation(),
2061 SourceLocation()));
2062 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl,
2063 &ClsExprs[0],
2064 ClsExprs.size());
2065 MsgExprs.push_back(Cls);
2066 }
Steve Naroff6568d4d2007-11-14 23:54:14 +00002067 } else { // instance message.
2068 Expr *recExpr = Exp->getReceiver();
Steve Naroff874e2322007-11-15 10:28:18 +00002069
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002070 if (ObjCInterfaceDecl *SuperDecl = isSuperReceiver(recExpr)) {
Steve Naroff874e2322007-11-15 10:28:18 +00002071 MsgSendFlavor = MsgSendSuperFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002072 if (MsgSendStretFlavor)
2073 MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
Steve Naroff874e2322007-11-15 10:28:18 +00002074 assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
2075
2076 llvm::SmallVector<Expr*, 4> InitExprs;
2077
Fariborz Jahanianceee3e82007-12-04 22:32:58 +00002078 InitExprs.push_back(
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002079 new CStyleCastExpr(Context->getObjCIdType(),
Steve Naroff54055232008-10-27 17:20:55 +00002080 new DeclRefExpr(CurMethodDef->getSelfDecl(),
Steve Narofff616ebb2008-07-16 22:35:27 +00002081 Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00002082 SourceLocation()),
2083 Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002084 SourceLocation(), SourceLocation())); // set the 'receiver'.
Steve Naroff874e2322007-11-15 10:28:18 +00002085
2086 llvm::SmallVector<Expr*, 8> ClsExprs;
2087 QualType argType = Context->getPointerType(Context->CharTy);
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002088 ClsExprs.push_back(new StringLiteral(SuperDecl->getIdentifier()->getName(),
2089 SuperDecl->getIdentifier()->getLength(),
Steve Naroff874e2322007-11-15 10:28:18 +00002090 false, argType, SourceLocation(),
2091 SourceLocation()));
2092 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl,
Fariborz Jahanianceee3e82007-12-04 22:32:58 +00002093 &ClsExprs[0],
2094 ClsExprs.size());
Fariborz Jahanian71274312007-12-05 17:29:46 +00002095 // To turn off a warning, type-cast to 'id'
Fariborz Jahanianceee3e82007-12-04 22:32:58 +00002096 InitExprs.push_back(
Douglas Gregor49badde2008-10-27 19:41:14 +00002097 // set 'super class', using objc_getClass().
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002098 new CStyleCastExpr(Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002099 Cls, Context->getObjCIdType(), SourceLocation(), SourceLocation()));
Steve Naroff874e2322007-11-15 10:28:18 +00002100 // struct objc_super
2101 QualType superType = getSuperStructType();
Steve Naroffc0a123c2008-03-11 17:37:02 +00002102 Expr *SuperRep;
2103
2104 if (LangOpts.Microsoft) {
2105 SynthSuperContructorFunctionDecl();
2106 // Simulate a contructor call...
2107 DeclRefExpr *DRE = new DeclRefExpr(SuperContructorFunctionDecl,
2108 superType, SourceLocation());
2109 SuperRep = new CallExpr(DRE, &InitExprs[0], InitExprs.size(),
2110 superType, SourceLocation());
2111 } else {
2112 // (struct objc_super) { <exprs from above> }
2113 InitListExpr *ILE = new InitListExpr(SourceLocation(),
2114 &InitExprs[0], InitExprs.size(),
Chris Lattner418f6c72008-10-26 23:43:26 +00002115 SourceLocation(), false);
Steve Naroffc0a123c2008-03-11 17:37:02 +00002116 SuperRep = new CompoundLiteralExpr(SourceLocation(), superType, ILE, false);
2117 }
Steve Naroff874e2322007-11-15 10:28:18 +00002118 // struct objc_super *
2119 Expr *Unop = new UnaryOperator(SuperRep, UnaryOperator::AddrOf,
2120 Context->getPointerType(SuperRep->getType()),
2121 SourceLocation());
2122 MsgExprs.push_back(Unop);
2123 } else {
Fariborz Jahanian7dd82832007-12-07 21:21:21 +00002124 // Remove all type-casts because it may contain objc-style types; e.g.
2125 // Foo<Proto> *.
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002126 while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr))
Fariborz Jahanian7dd82832007-12-07 21:21:21 +00002127 recExpr = CE->getSubExpr();
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002128 recExpr = new CStyleCastExpr(Context->getObjCIdType(), recExpr,
Douglas Gregor49badde2008-10-27 19:41:14 +00002129 Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002130 SourceLocation(), SourceLocation());
Steve Naroff874e2322007-11-15 10:28:18 +00002131 MsgExprs.push_back(recExpr);
2132 }
Steve Naroff6568d4d2007-11-14 23:54:14 +00002133 }
Steve Naroffbeaf2992007-11-03 11:27:19 +00002134 // Create a call to sel_registerName("selName"), it will be the 2nd argument.
Steve Naroff934f2762007-10-24 22:48:43 +00002135 llvm::SmallVector<Expr*, 8> SelExprs;
2136 QualType argType = Context->getPointerType(Context->CharTy);
2137 SelExprs.push_back(new StringLiteral(Exp->getSelector().getName().c_str(),
2138 Exp->getSelector().getName().size(),
2139 false, argType, SourceLocation(),
2140 SourceLocation()));
2141 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2142 &SelExprs[0], SelExprs.size());
2143 MsgExprs.push_back(SelExp);
2144
2145 // Now push any user supplied arguments.
2146 for (unsigned i = 0; i < Exp->getNumArgs(); i++) {
Steve Naroff6568d4d2007-11-14 23:54:14 +00002147 Expr *userExpr = Exp->getArg(i);
Steve Naroff7e3411b2007-11-15 02:58:25 +00002148 // Make all implicit casts explicit...ICE comes in handy:-)
2149 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) {
2150 // Reuse the ICE type, it is exactly what the doctor ordered.
Douglas Gregor49badde2008-10-27 19:41:14 +00002151 QualType type = ICE->getType()->isObjCQualifiedIdType()
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002152 ? Context->getObjCIdType()
Douglas Gregor49badde2008-10-27 19:41:14 +00002153 : ICE->getType();
Steve Naroffb2f9e512008-11-03 23:29:32 +00002154 userExpr = new CStyleCastExpr(type, userExpr, type, SourceLocation(), SourceLocation());
Fariborz Jahaniand58fabf2007-12-18 21:33:44 +00002155 }
2156 // Make id<P...> cast into an 'id' cast.
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002157 else if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(userExpr)) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002158 if (CE->getType()->isObjCQualifiedIdType()) {
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002159 while ((CE = dyn_cast<CStyleCastExpr>(userExpr)))
Fariborz Jahaniand58fabf2007-12-18 21:33:44 +00002160 userExpr = CE->getSubExpr();
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002161 userExpr = new CStyleCastExpr(Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00002162 userExpr, Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002163 SourceLocation(), SourceLocation());
Fariborz Jahaniand58fabf2007-12-18 21:33:44 +00002164 }
Steve Naroff7e3411b2007-11-15 02:58:25 +00002165 }
Steve Naroff6568d4d2007-11-14 23:54:14 +00002166 MsgExprs.push_back(userExpr);
Steve Naroff934f2762007-10-24 22:48:43 +00002167 // We've transferred the ownership to MsgExprs. Null out the argument in
2168 // the original expression, since we will delete it below.
2169 Exp->setArg(i, 0);
2170 }
Steve Naroffab972d32007-11-04 22:37:50 +00002171 // Generate the funky cast.
2172 CastExpr *cast;
2173 llvm::SmallVector<QualType, 8> ArgTypes;
2174 QualType returnType;
2175
2176 // Push 'id' and 'SEL', the 2 implicit arguments.
Steve Naroffc3a438c2007-11-15 10:43:57 +00002177 if (MsgSendFlavor == MsgSendSuperFunctionDecl)
2178 ArgTypes.push_back(Context->getPointerType(getSuperStructType()));
2179 else
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002180 ArgTypes.push_back(Context->getObjCIdType());
2181 ArgTypes.push_back(Context->getObjCSelType());
2182 if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
Steve Naroffab972d32007-11-04 22:37:50 +00002183 // Push any user argument types.
Chris Lattner58cce3b2008-03-16 01:07:14 +00002184 for (unsigned i = 0; i < mDecl->getNumParams(); i++) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002185 QualType t = mDecl->getParamDecl(i)->getType()->isObjCQualifiedIdType()
2186 ? Context->getObjCIdType()
Fariborz Jahanianc5692492007-12-17 21:03:50 +00002187 : mDecl->getParamDecl(i)->getType();
Steve Naroffa206b062008-10-29 14:49:46 +00002188 // Make sure we convert "t (^)(...)" to "t (*)(...)".
2189 if (isBlockPointerType(t)) {
2190 const BlockPointerType *BPT = t->getAsBlockPointerType();
2191 t = Context->getPointerType(BPT->getPointeeType());
2192 }
Steve Naroff352336b2007-11-05 14:36:37 +00002193 ArgTypes.push_back(t);
2194 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002195 returnType = mDecl->getResultType()->isObjCQualifiedIdType()
2196 ? Context->getObjCIdType() : mDecl->getResultType();
Steve Naroffab972d32007-11-04 22:37:50 +00002197 } else {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002198 returnType = Context->getObjCIdType();
Steve Naroffab972d32007-11-04 22:37:50 +00002199 }
2200 // Get the type, we will need to reference it in a couple spots.
Steve Naroff874e2322007-11-15 10:28:18 +00002201 QualType msgSendType = MsgSendFlavor->getType();
Steve Naroffab972d32007-11-04 22:37:50 +00002202
2203 // Create a reference to the objc_msgSend() declaration.
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002204 DeclRefExpr *DRE = new DeclRefExpr(MsgSendFlavor, msgSendType,
2205 SourceLocation());
Steve Naroffab972d32007-11-04 22:37:50 +00002206
2207 // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
2208 // If we don't do this cast, we get the following bizarre warning/note:
2209 // xx.m:13: warning: function called through a non-compatible type
2210 // xx.m:13: note: if this code is reached, the program will abort
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002211 cast = new CStyleCastExpr(Context->getPointerType(Context->VoidTy), DRE,
Douglas Gregor49badde2008-10-27 19:41:14 +00002212 Context->getPointerType(Context->VoidTy),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002213 SourceLocation(), SourceLocation());
Steve Naroff335eafa2007-11-15 12:35:21 +00002214
Steve Naroffab972d32007-11-04 22:37:50 +00002215 // Now do the "normal" pointer to function cast.
2216 QualType castType = Context->getFunctionType(returnType,
Fariborz Jahaniand0ee6f92007-12-06 19:49:56 +00002217 &ArgTypes[0], ArgTypes.size(),
Steve Naroff2679e482008-03-18 02:02:04 +00002218 // If we don't have a method decl, force a variadic cast.
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002219 Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : true, 0);
Steve Naroffab972d32007-11-04 22:37:50 +00002220 castType = Context->getPointerType(castType);
Steve Naroffb2f9e512008-11-03 23:29:32 +00002221 cast = new CStyleCastExpr(castType, cast, castType, SourceLocation(), SourceLocation());
Steve Naroffab972d32007-11-04 22:37:50 +00002222
2223 // Don't forget the parens to enforce the proper binding.
2224 ParenExpr *PE = new ParenExpr(SourceLocation(), SourceLocation(), cast);
2225
2226 const FunctionType *FT = msgSendType->getAsFunctionType();
2227 CallExpr *CE = new CallExpr(PE, &MsgExprs[0], MsgExprs.size(),
2228 FT->getResultType(), SourceLocation());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002229 Stmt *ReplacingStmt = CE;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002230 if (MsgSendStretFlavor) {
2231 // We have the method which returns a struct/union. Must also generate
2232 // call to objc_msgSend_stret and hang both varieties on a conditional
2233 // expression which dictate which one to envoke depending on size of
2234 // method's return type.
2235
2236 // Create a reference to the objc_msgSend_stret() declaration.
2237 DeclRefExpr *STDRE = new DeclRefExpr(MsgSendStretFlavor, msgSendType,
2238 SourceLocation());
2239 // Need to cast objc_msgSend_stret to "void *" (see above comment).
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002240 cast = new CStyleCastExpr(Context->getPointerType(Context->VoidTy), STDRE,
Douglas Gregor49badde2008-10-27 19:41:14 +00002241 Context->getPointerType(Context->VoidTy),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002242 SourceLocation(), SourceLocation());
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002243 // Now do the "normal" pointer to function cast.
2244 castType = Context->getFunctionType(returnType,
Fariborz Jahaniand0ee6f92007-12-06 19:49:56 +00002245 &ArgTypes[0], ArgTypes.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002246 Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : false, 0);
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002247 castType = Context->getPointerType(castType);
Steve Naroffb2f9e512008-11-03 23:29:32 +00002248 cast = new CStyleCastExpr(castType, cast, castType, SourceLocation(), SourceLocation());
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002249
2250 // Don't forget the parens to enforce the proper binding.
2251 PE = new ParenExpr(SourceLocation(), SourceLocation(), cast);
2252
2253 FT = msgSendType->getAsFunctionType();
2254 CallExpr *STCE = new CallExpr(PE, &MsgExprs[0], MsgExprs.size(),
2255 FT->getResultType(), SourceLocation());
2256
2257 // Build sizeof(returnType)
Sebastian Redl05189992008-11-11 17:56:53 +00002258 SizeOfAlignOfExpr *sizeofExpr = new SizeOfAlignOfExpr(true, true,
2259 returnType.getAsOpaquePtr(),
2260 Context->getSizeType(),
2261 SourceLocation(), SourceLocation());
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002262 // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
2263 // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases.
2264 // For X86 it is more complicated and some kind of target specific routine
2265 // is needed to decide what to do.
Chris Lattner98be4942008-03-05 18:54:05 +00002266 unsigned IntSize =
2267 static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002268 IntegerLiteral *limit = new IntegerLiteral(llvm::APInt(IntSize, 8),
2269 Context->IntTy,
2270 SourceLocation());
2271 BinaryOperator *lessThanExpr = new BinaryOperator(sizeofExpr, limit,
2272 BinaryOperator::LE,
2273 Context->IntTy,
2274 SourceLocation());
2275 // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
2276 ConditionalOperator *CondExpr =
2277 new ConditionalOperator(lessThanExpr, CE, STCE, returnType);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002278 ReplacingStmt = new ParenExpr(SourceLocation(), SourceLocation(), CondExpr);
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002279 }
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002280 return ReplacingStmt;
2281}
2282
Steve Naroffb29b4272008-04-14 22:03:09 +00002283Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002284 Stmt *ReplacingStmt = SynthMessageExpr(Exp);
Steve Naroff80c28552008-10-27 20:54:44 +00002285
Steve Naroff934f2762007-10-24 22:48:43 +00002286 // Now do the actual rewrite.
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00002287 ReplaceStmt(Exp, ReplacingStmt);
Steve Naroff934f2762007-10-24 22:48:43 +00002288
Chris Lattnere64b7772007-10-24 16:57:36 +00002289 delete Exp;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002290 return ReplacingStmt;
Steve Naroffebf2b562007-10-23 23:50:29 +00002291}
2292
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002293/// RewriteObjCProtocolExpr - Rewrite a protocol expression into
2294/// call to objc_getProtocol("proto-name").
Steve Naroffb29b4272008-04-14 22:03:09 +00002295Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002296 if (!GetProtocolFunctionDecl)
2297 SynthGetProtocolFunctionDecl();
2298 // Create a call to objc_getProtocol("ProtocolName").
2299 llvm::SmallVector<Expr*, 8> ProtoExprs;
2300 QualType argType = Context->getPointerType(Context->CharTy);
2301 ProtoExprs.push_back(new StringLiteral(Exp->getProtocol()->getName(),
2302 strlen(Exp->getProtocol()->getName()),
2303 false, argType, SourceLocation(),
2304 SourceLocation()));
2305 CallExpr *ProtoExp = SynthesizeCallToFunctionDecl(GetProtocolFunctionDecl,
2306 &ProtoExprs[0],
2307 ProtoExprs.size());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00002308 ReplaceStmt(Exp, ProtoExp);
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002309 delete Exp;
2310 return ProtoExp;
2311
2312}
2313
Steve Naroffbaf58c32008-05-31 14:15:04 +00002314bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf,
2315 const char *endBuf) {
2316 while (startBuf < endBuf) {
2317 if (*startBuf == '#') {
2318 // Skip whitespace.
2319 for (++startBuf; startBuf[0] == ' ' || startBuf[0] == '\t'; ++startBuf)
2320 ;
2321 if (!strncmp(startBuf, "if", strlen("if")) ||
2322 !strncmp(startBuf, "ifdef", strlen("ifdef")) ||
2323 !strncmp(startBuf, "ifndef", strlen("ifndef")) ||
2324 !strncmp(startBuf, "define", strlen("define")) ||
2325 !strncmp(startBuf, "undef", strlen("undef")) ||
2326 !strncmp(startBuf, "else", strlen("else")) ||
2327 !strncmp(startBuf, "elif", strlen("elif")) ||
2328 !strncmp(startBuf, "endif", strlen("endif")) ||
2329 !strncmp(startBuf, "pragma", strlen("pragma")) ||
2330 !strncmp(startBuf, "include", strlen("include")) ||
2331 !strncmp(startBuf, "import", strlen("import")) ||
2332 !strncmp(startBuf, "include_next", strlen("include_next")))
2333 return true;
2334 }
2335 startBuf++;
2336 }
2337 return false;
2338}
2339
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002340/// SynthesizeObjCInternalStruct - Rewrite one internal struct corresponding to
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002341/// an objective-c class with ivars.
Steve Naroffb29b4272008-04-14 22:03:09 +00002342void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002343 std::string &Result) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002344 assert(CDecl && "Class missing in SynthesizeObjCInternalStruct");
2345 assert(CDecl->getName() && "Name missing in SynthesizeObjCInternalStruct");
Fariborz Jahanian212b7682007-10-31 23:08:24 +00002346 // Do not synthesize more than once.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002347 if (ObjCSynthesizedStructs.count(CDecl))
Fariborz Jahanian212b7682007-10-31 23:08:24 +00002348 return;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002349 ObjCInterfaceDecl *RCDecl = CDecl->getSuperClass();
Chris Lattnerf3a7af92008-03-16 21:08:55 +00002350 int NumIvars = CDecl->ivar_size();
Steve Narofffea763e82007-11-14 19:25:57 +00002351 SourceLocation LocStart = CDecl->getLocStart();
2352 SourceLocation LocEnd = CDecl->getLocEnd();
2353
2354 const char *startBuf = SM->getCharacterData(LocStart);
2355 const char *endBuf = SM->getCharacterData(LocEnd);
Steve Naroffbaf58c32008-05-31 14:15:04 +00002356
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002357 // If no ivars and no root or if its root, directly or indirectly,
2358 // have no ivars (thus not synthesized) then no need to synthesize this class.
Chris Lattnerf3a7af92008-03-16 21:08:55 +00002359 if ((CDecl->isForwardDecl() || NumIvars == 0) &&
2360 (!RCDecl || !ObjCSynthesizedStructs.count(RCDecl))) {
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002361 endBuf += Lexer::MeasureTokenLength(LocEnd, *SM);
Chris Lattneraadaf782008-01-31 19:51:04 +00002362 ReplaceText(LocStart, endBuf-startBuf, Result.c_str(), Result.size());
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002363 return;
2364 }
2365
2366 // FIXME: This has potential of causing problem. If
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002367 // SynthesizeObjCInternalStruct is ever called recursively.
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002368 Result += "\nstruct ";
2369 Result += CDecl->getName();
Steve Naroff61ed9ca2008-03-10 23:16:54 +00002370 if (LangOpts.Microsoft)
2371 Result += "_IMPL";
Steve Naroff05b8c782008-03-12 00:25:36 +00002372
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002373 if (NumIvars > 0) {
Steve Narofffea763e82007-11-14 19:25:57 +00002374 const char *cursor = strchr(startBuf, '{');
2375 assert((cursor && endBuf)
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002376 && "SynthesizeObjCInternalStruct - malformed @interface");
Steve Naroffbaf58c32008-05-31 14:15:04 +00002377 // If the buffer contains preprocessor directives, we do more fine-grained
2378 // rewrites. This is intended to fix code that looks like (which occurs in
2379 // NSURL.h, for example):
2380 //
2381 // #ifdef XYZ
2382 // @interface Foo : NSObject
2383 // #else
2384 // @interface FooBar : NSObject
2385 // #endif
2386 // {
2387 // int i;
2388 // }
2389 // @end
2390 //
2391 // This clause is segregated to avoid breaking the common case.
2392 if (BufferContainsPPDirectives(startBuf, cursor)) {
2393 SourceLocation L = RCDecl ? CDecl->getSuperClassLoc() :
2394 CDecl->getClassLoc();
2395 const char *endHeader = SM->getCharacterData(L);
2396 endHeader += Lexer::MeasureTokenLength(L, *SM);
2397
Chris Lattner3db6cae2008-07-21 18:19:38 +00002398 if (!CDecl->getReferencedProtocols().empty()) {
Steve Naroffbaf58c32008-05-31 14:15:04 +00002399 // advance to the end of the referenced protocols.
2400 while (endHeader < cursor && *endHeader != '>') endHeader++;
2401 endHeader++;
2402 }
2403 // rewrite the original header
2404 ReplaceText(LocStart, endHeader-startBuf, Result.c_str(), Result.size());
2405 } else {
2406 // rewrite the original header *without* disturbing the '{'
2407 ReplaceText(LocStart, cursor-startBuf-1, Result.c_str(), Result.size());
2408 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002409 if (RCDecl && ObjCSynthesizedStructs.count(RCDecl)) {
Steve Narofffea763e82007-11-14 19:25:57 +00002410 Result = "\n struct ";
2411 Result += RCDecl->getName();
Steve Naroff39bbd9f2008-03-12 21:09:20 +00002412 Result += "_IMPL ";
2413 Result += RCDecl->getName();
Steve Naroff819173c2008-03-12 21:22:52 +00002414 Result += "_IVARS;\n";
Steve Narofffea763e82007-11-14 19:25:57 +00002415
2416 // insert the super class structure definition.
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002417 SourceLocation OnePastCurly =
2418 LocStart.getFileLocWithOffset(cursor-startBuf+1);
2419 InsertText(OnePastCurly, Result.c_str(), Result.size());
Steve Narofffea763e82007-11-14 19:25:57 +00002420 }
2421 cursor++; // past '{'
2422
2423 // Now comment out any visibility specifiers.
2424 while (cursor < endBuf) {
2425 if (*cursor == '@') {
2426 SourceLocation atLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
Chris Lattnerdf6a51b2007-11-14 22:57:51 +00002427 // Skip whitespace.
2428 for (++cursor; cursor[0] == ' ' || cursor[0] == '\t'; ++cursor)
2429 /*scan*/;
2430
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002431 // FIXME: presence of @public, etc. inside comment results in
2432 // this transformation as well, which is still correct c-code.
Steve Narofffea763e82007-11-14 19:25:57 +00002433 if (!strncmp(cursor, "public", strlen("public")) ||
2434 !strncmp(cursor, "private", strlen("private")) ||
Steve Naroffc5e32772008-04-04 22:34:24 +00002435 !strncmp(cursor, "package", strlen("package")) ||
Fariborz Jahanian95673922007-11-14 22:26:25 +00002436 !strncmp(cursor, "protected", strlen("protected")))
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002437 InsertText(atLoc, "// ", 3);
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002438 }
Fariborz Jahanian95673922007-11-14 22:26:25 +00002439 // FIXME: If there are cases where '<' is used in ivar declaration part
2440 // of user code, then scan the ivar list and use needToScanForQualifiers
2441 // for type checking.
2442 else if (*cursor == '<') {
2443 SourceLocation atLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002444 InsertText(atLoc, "/* ", 3);
Fariborz Jahanian95673922007-11-14 22:26:25 +00002445 cursor = strchr(cursor, '>');
2446 cursor++;
2447 atLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002448 InsertText(atLoc, " */", 3);
Steve Naroffced80a82008-10-30 12:09:33 +00002449 } else if (*cursor == '^') { // rewrite block specifier.
2450 SourceLocation caretLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
2451 ReplaceText(caretLoc, 1, "*", 1);
Fariborz Jahanian95673922007-11-14 22:26:25 +00002452 }
Steve Narofffea763e82007-11-14 19:25:57 +00002453 cursor++;
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002454 }
Steve Narofffea763e82007-11-14 19:25:57 +00002455 // Don't forget to add a ';'!!
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002456 InsertText(LocEnd.getFileLocWithOffset(1), ";", 1);
Steve Narofffea763e82007-11-14 19:25:57 +00002457 } else { // we don't have any instance variables - insert super struct.
2458 endBuf += Lexer::MeasureTokenLength(LocEnd, *SM);
2459 Result += " {\n struct ";
2460 Result += RCDecl->getName();
Steve Naroff39bbd9f2008-03-12 21:09:20 +00002461 Result += "_IMPL ";
2462 Result += RCDecl->getName();
Steve Naroff819173c2008-03-12 21:22:52 +00002463 Result += "_IVARS;\n};\n";
Chris Lattneraadaf782008-01-31 19:51:04 +00002464 ReplaceText(LocStart, endBuf-startBuf, Result.c_str(), Result.size());
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002465 }
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002466 // Mark this struct as having been generated.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002467 if (!ObjCSynthesizedStructs.insert(CDecl))
Steve Narofffbfe8252008-05-06 18:26:51 +00002468 assert(false && "struct already synthesize- SynthesizeObjCInternalStruct");
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002469}
2470
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002471// RewriteObjCMethodsMetaData - Rewrite methods metadata for instance or
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002472/// class methods.
Steve Naroffb29b4272008-04-14 22:03:09 +00002473void RewriteObjC::RewriteObjCMethodsMetaData(instmeth_iterator MethodBegin,
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002474 instmeth_iterator MethodEnd,
Fariborz Jahanian8e991ba2007-10-25 00:14:44 +00002475 bool IsInstanceMethod,
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002476 const char *prefix,
Chris Lattner158ecb92007-10-25 17:07:24 +00002477 const char *ClassName,
2478 std::string &Result) {
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002479 if (MethodBegin == MethodEnd) return;
2480
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002481 static bool objc_impl_method = false;
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002482 if (!objc_impl_method) {
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002483 /* struct _objc_method {
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002484 SEL _cmd;
2485 char *method_types;
2486 void *_imp;
2487 }
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002488 */
Chris Lattner158ecb92007-10-25 17:07:24 +00002489 Result += "\nstruct _objc_method {\n";
2490 Result += "\tSEL _cmd;\n";
2491 Result += "\tchar *method_types;\n";
2492 Result += "\tvoid *_imp;\n";
2493 Result += "};\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002494
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002495 objc_impl_method = true;
Fariborz Jahanian776d6ff2007-10-19 00:36:46 +00002496 }
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002497
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002498 // Build _objc_method_list for class's methods if needed
Steve Naroff946a6932008-03-11 00:12:29 +00002499
2500 /* struct {
2501 struct _objc_method_list *next_method;
2502 int method_count;
2503 struct _objc_method method_list[];
2504 }
2505 */
2506 Result += "\nstatic struct {\n";
2507 Result += "\tstruct _objc_method_list *next_method;\n";
2508 Result += "\tint method_count;\n";
2509 Result += "\tstruct _objc_method method_list[";
2510 Result += utostr(MethodEnd-MethodBegin);
2511 Result += "];\n} _OBJC_";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002512 Result += prefix;
2513 Result += IsInstanceMethod ? "INSTANCE" : "CLASS";
2514 Result += "_METHODS_";
2515 Result += ClassName;
Steve Naroffdbb65432008-03-12 17:18:30 +00002516 Result += " __attribute__ ((used, section (\"__OBJC, __";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002517 Result += IsInstanceMethod ? "inst" : "cls";
2518 Result += "_meth\")))= ";
2519 Result += "{\n\t0, " + utostr(MethodEnd-MethodBegin) + "\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002520
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002521 Result += "\t,{{(SEL)\"";
2522 Result += (*MethodBegin)->getSelector().getName().c_str();
2523 std::string MethodTypeString;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002524 Context->getObjCEncodingForMethodDecl(*MethodBegin, MethodTypeString);
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002525 Result += "\", \"";
2526 Result += MethodTypeString;
Steve Naroff946a6932008-03-11 00:12:29 +00002527 Result += "\", (void *)";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002528 Result += MethodInternalNames[*MethodBegin];
2529 Result += "}\n";
2530 for (++MethodBegin; MethodBegin != MethodEnd; ++MethodBegin) {
2531 Result += "\t ,{(SEL)\"";
2532 Result += (*MethodBegin)->getSelector().getName().c_str();
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002533 std::string MethodTypeString;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002534 Context->getObjCEncodingForMethodDecl(*MethodBegin, MethodTypeString);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002535 Result += "\", \"";
2536 Result += MethodTypeString;
Steve Naroff946a6932008-03-11 00:12:29 +00002537 Result += "\", (void *)";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002538 Result += MethodInternalNames[*MethodBegin];
Fariborz Jahanianb7908b52007-11-13 21:02:00 +00002539 Result += "}\n";
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002540 }
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002541 Result += "\t }\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002542}
2543
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002544/// RewriteObjCProtocolsMetaData - Rewrite protocols meta-data.
Chris Lattner780f3292008-07-21 21:32:27 +00002545void RewriteObjC::
2546RewriteObjCProtocolsMetaData(const ObjCList<ObjCProtocolDecl> &Protocols,
2547 const char *prefix,
2548 const char *ClassName,
2549 std::string &Result) {
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002550 static bool objc_protocol_methods = false;
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002551 if (Protocols.empty()) return;
2552
2553 for (unsigned i = 0; i != Protocols.size(); i++) {
2554 ObjCProtocolDecl *PDecl = Protocols[i];
2555 // Output struct protocol_methods holder of method selector and type.
2556 if (!objc_protocol_methods && !PDecl->isForwardDecl()) {
2557 /* struct protocol_methods {
2558 SEL _cmd;
2559 char *method_types;
2560 }
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002561 */
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002562 Result += "\nstruct protocol_methods {\n";
2563 Result += "\tSEL _cmd;\n";
2564 Result += "\tchar *method_types;\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002565 Result += "};\n";
Steve Narofffbfe8252008-05-06 18:26:51 +00002566
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002567 objc_protocol_methods = true;
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002568 }
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002569 // Do not synthesize the protocol more than once.
2570 if (ObjCSynthesizedProtocols.count(PDecl))
2571 continue;
2572
2573 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) {
2574 unsigned NumMethods = PDecl->getNumInstanceMethods();
2575 /* struct _objc_protocol_method_list {
2576 int protocol_method_count;
2577 struct protocol_methods protocols[];
2578 }
2579 */
2580 Result += "\nstatic struct {\n";
2581 Result += "\tint protocol_method_count;\n";
2582 Result += "\tstruct protocol_methods protocols[";
2583 Result += utostr(NumMethods);
2584 Result += "];\n} _OBJC_PROTOCOL_INSTANCE_METHODS_";
2585 Result += PDecl->getName();
2586 Result += " __attribute__ ((used, section (\"__OBJC, __cat_inst_meth\")))= "
2587 "{\n\t" + utostr(NumMethods) + "\n";
2588
2589 // Output instance methods declared in this protocol.
2590 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
2591 E = PDecl->instmeth_end(); I != E; ++I) {
2592 if (I == PDecl->instmeth_begin())
2593 Result += "\t ,{{(SEL)\"";
2594 else
2595 Result += "\t ,{(SEL)\"";
2596 Result += (*I)->getSelector().getName().c_str();
2597 std::string MethodTypeString;
2598 Context->getObjCEncodingForMethodDecl((*I), MethodTypeString);
2599 Result += "\", \"";
2600 Result += MethodTypeString;
2601 Result += "\"}\n";
2602 }
2603 Result += "\t }\n};\n";
2604 }
2605
2606 // Output class methods declared in this protocol.
2607 int NumMethods = PDecl->getNumClassMethods();
2608 if (NumMethods > 0) {
2609 /* struct _objc_protocol_method_list {
2610 int protocol_method_count;
2611 struct protocol_methods protocols[];
2612 }
2613 */
2614 Result += "\nstatic struct {\n";
2615 Result += "\tint protocol_method_count;\n";
2616 Result += "\tstruct protocol_methods protocols[";
2617 Result += utostr(NumMethods);
2618 Result += "];\n} _OBJC_PROTOCOL_CLASS_METHODS_";
2619 Result += PDecl->getName();
2620 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= "
2621 "{\n\t";
2622 Result += utostr(NumMethods);
2623 Result += "\n";
2624
2625 // Output instance methods declared in this protocol.
2626 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(),
2627 E = PDecl->classmeth_end(); I != E; ++I) {
2628 if (I == PDecl->classmeth_begin())
2629 Result += "\t ,{{(SEL)\"";
2630 else
2631 Result += "\t ,{(SEL)\"";
2632 Result += (*I)->getSelector().getName().c_str();
2633 std::string MethodTypeString;
2634 Context->getObjCEncodingForMethodDecl((*I), MethodTypeString);
2635 Result += "\", \"";
2636 Result += MethodTypeString;
2637 Result += "\"}\n";
2638 }
2639 Result += "\t }\n};\n";
2640 }
2641
2642 // Output:
2643 /* struct _objc_protocol {
2644 // Objective-C 1.0 extensions
2645 struct _objc_protocol_extension *isa;
2646 char *protocol_name;
2647 struct _objc_protocol **protocol_list;
2648 struct _objc_protocol_method_list *instance_methods;
2649 struct _objc_protocol_method_list *class_methods;
2650 };
Steve Naroff8eb4a5e2008-03-12 01:06:30 +00002651 */
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002652 static bool objc_protocol = false;
2653 if (!objc_protocol) {
2654 Result += "\nstruct _objc_protocol {\n";
2655 Result += "\tstruct _objc_protocol_extension *isa;\n";
2656 Result += "\tchar *protocol_name;\n";
2657 Result += "\tstruct _objc_protocol **protocol_list;\n";
2658 Result += "\tstruct _objc_protocol_method_list *instance_methods;\n";
2659 Result += "\tstruct _objc_protocol_method_list *class_methods;\n";
2660 Result += "};\n";
2661
2662 objc_protocol = true;
2663 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002664
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002665 Result += "\nstatic struct _objc_protocol _OBJC_PROTOCOL_";
2666 Result += PDecl->getName();
2667 Result += " __attribute__ ((used, section (\"__OBJC, __protocol\")))= "
2668 "{\n\t0, \"";
2669 Result += PDecl->getName();
2670 Result += "\", 0, ";
2671 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) {
2672 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_INSTANCE_METHODS_";
2673 Result += PDecl->getName();
2674 Result += ", ";
2675 }
2676 else
2677 Result += "0, ";
2678 if (PDecl->getNumClassMethods() > 0) {
2679 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_CLASS_METHODS_";
2680 Result += PDecl->getName();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002681 Result += "\n";
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002682 }
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002683 else
2684 Result += "0\n";
2685 Result += "};\n";
2686
2687 // Mark this protocol as having been generated.
2688 if (!ObjCSynthesizedProtocols.insert(PDecl))
2689 assert(false && "protocol already synthesized");
2690 }
2691 // Output the top lovel protocol meta-data for the class.
2692 /* struct _objc_protocol_list {
2693 struct _objc_protocol_list *next;
2694 int protocol_count;
2695 struct _objc_protocol *class_protocols[];
2696 }
2697 */
2698 Result += "\nstatic struct {\n";
2699 Result += "\tstruct _objc_protocol_list *next;\n";
2700 Result += "\tint protocol_count;\n";
2701 Result += "\tstruct _objc_protocol *class_protocols[";
2702 Result += utostr(Protocols.size());
2703 Result += "];\n} _OBJC_";
2704 Result += prefix;
2705 Result += "_PROTOCOLS_";
2706 Result += ClassName;
2707 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= "
2708 "{\n\t0, ";
2709 Result += utostr(Protocols.size());
2710 Result += "\n";
2711
2712 Result += "\t,{&_OBJC_PROTOCOL_";
2713 Result += Protocols[0]->getName();
2714 Result += " \n";
2715
2716 for (unsigned i = 1; i != Protocols.size(); i++) {
2717 Result += "\t ,&_OBJC_PROTOCOL_";
2718 Result += Protocols[i]->getName();
2719 Result += "\n";
2720 }
2721 Result += "\t }\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002722}
2723
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002724/// RewriteObjCCategoryImplDecl - Rewrite metadata for each category
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002725/// implementation.
Steve Naroffb29b4272008-04-14 22:03:09 +00002726void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002727 std::string &Result) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002728 ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface();
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002729 // Find category declaration for this implementation.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002730 ObjCCategoryDecl *CDecl;
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002731 for (CDecl = ClassDecl->getCategoryList(); CDecl;
2732 CDecl = CDecl->getNextClassCategory())
2733 if (CDecl->getIdentifier() == IDecl->getIdentifier())
2734 break;
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002735
Chris Lattnereb44eee2007-12-23 01:40:15 +00002736 std::string FullCategoryName = ClassDecl->getName();
2737 FullCategoryName += '_';
2738 FullCategoryName += IDecl->getName();
2739
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002740 // Build _objc_method_list for class's instance methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002741 RewriteObjCMethodsMetaData(IDecl->instmeth_begin(), IDecl->instmeth_end(),
Chris Lattnereb44eee2007-12-23 01:40:15 +00002742 true, "CATEGORY_", FullCategoryName.c_str(),
2743 Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002744
2745 // Build _objc_method_list for class's class methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002746 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(),
Chris Lattnereb44eee2007-12-23 01:40:15 +00002747 false, "CATEGORY_", FullCategoryName.c_str(),
2748 Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002749
2750 // Protocols referenced in class declaration?
Fariborz Jahanianbac97d42007-11-13 22:09:49 +00002751 // Null CDecl is case of a category implementation with no category interface
2752 if (CDecl)
Chris Lattner780f3292008-07-21 21:32:27 +00002753 RewriteObjCProtocolsMetaData(CDecl->getReferencedProtocols(), "CATEGORY",
Chris Lattnereb44eee2007-12-23 01:40:15 +00002754 FullCategoryName.c_str(), Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002755
2756 /* struct _objc_category {
2757 char *category_name;
2758 char *class_name;
2759 struct _objc_method_list *instance_methods;
2760 struct _objc_method_list *class_methods;
2761 struct _objc_protocol_list *protocols;
2762 // Objective-C 1.0 extensions
2763 uint32_t size; // sizeof (struct _objc_category)
2764 struct _objc_property_list *instance_properties; // category's own
2765 // @property decl.
2766 };
2767 */
2768
2769 static bool objc_category = false;
2770 if (!objc_category) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002771 Result += "\nstruct _objc_category {\n";
2772 Result += "\tchar *category_name;\n";
2773 Result += "\tchar *class_name;\n";
2774 Result += "\tstruct _objc_method_list *instance_methods;\n";
2775 Result += "\tstruct _objc_method_list *class_methods;\n";
2776 Result += "\tstruct _objc_protocol_list *protocols;\n";
2777 Result += "\tunsigned int size;\n";
2778 Result += "\tstruct _objc_property_list *instance_properties;\n";
2779 Result += "};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002780 objc_category = true;
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002781 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002782 Result += "\nstatic struct _objc_category _OBJC_CATEGORY_";
2783 Result += FullCategoryName;
Steve Naroffdbb65432008-03-12 17:18:30 +00002784 Result += " __attribute__ ((used, section (\"__OBJC, __category\")))= {\n\t\"";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002785 Result += IDecl->getName();
2786 Result += "\"\n\t, \"";
2787 Result += ClassDecl->getName();
2788 Result += "\"\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002789
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002790 if (IDecl->getNumInstanceMethods() > 0) {
2791 Result += "\t, (struct _objc_method_list *)"
2792 "&_OBJC_CATEGORY_INSTANCE_METHODS_";
2793 Result += FullCategoryName;
2794 Result += "\n";
2795 }
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002796 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002797 Result += "\t, 0\n";
2798 if (IDecl->getNumClassMethods() > 0) {
2799 Result += "\t, (struct _objc_method_list *)"
2800 "&_OBJC_CATEGORY_CLASS_METHODS_";
2801 Result += FullCategoryName;
2802 Result += "\n";
2803 }
2804 else
2805 Result += "\t, 0\n";
2806
Chris Lattner780f3292008-07-21 21:32:27 +00002807 if (CDecl && !CDecl->getReferencedProtocols().empty()) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002808 Result += "\t, (struct _objc_protocol_list *)&_OBJC_CATEGORY_PROTOCOLS_";
2809 Result += FullCategoryName;
2810 Result += "\n";
2811 }
2812 else
2813 Result += "\t, 0\n";
2814 Result += "\t, sizeof(struct _objc_category), 0\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002815}
2816
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002817/// SynthesizeIvarOffsetComputation - This rutine synthesizes computation of
2818/// ivar offset.
Steve Naroffb29b4272008-04-14 22:03:09 +00002819void RewriteObjC::SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002820 ObjCIvarDecl *ivar,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002821 std::string &Result) {
Steve Naroff8f3b2652008-07-16 18:22:22 +00002822 if (ivar->isBitField()) {
2823 // FIXME: The hack below doesn't work for bitfields. For now, we simply
2824 // place all bitfields at offset 0.
2825 Result += "0";
2826 } else {
2827 Result += "__OFFSETOFIVAR__(struct ";
2828 Result += IDecl->getName();
2829 if (LangOpts.Microsoft)
2830 Result += "_IMPL";
2831 Result += ", ";
2832 Result += ivar->getName();
2833 Result += ")";
2834 }
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002835}
2836
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002837//===----------------------------------------------------------------------===//
2838// Meta Data Emission
2839//===----------------------------------------------------------------------===//
2840
Steve Naroffb29b4272008-04-14 22:03:09 +00002841void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002842 std::string &Result) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002843 ObjCInterfaceDecl *CDecl = IDecl->getClassInterface();
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002844
Fariborz Jahanianebe668f2007-11-26 20:59:57 +00002845 // Explictly declared @interface's are already synthesized.
2846 if (CDecl->ImplicitInterfaceDecl()) {
2847 // FIXME: Implementation of a class with no @interface (legacy) doese not
2848 // produce correct synthesis as yet.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002849 SynthesizeObjCInternalStruct(CDecl, Result);
Fariborz Jahanianebe668f2007-11-26 20:59:57 +00002850 }
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00002851
Chris Lattnerbe6df082007-12-12 07:56:42 +00002852 // Build _objc_ivar_list metadata for classes ivars if needed
Chris Lattnerf3a7af92008-03-16 21:08:55 +00002853 unsigned NumIvars = !IDecl->ivar_empty()
2854 ? IDecl->ivar_size()
2855 : (CDecl ? CDecl->ivar_size() : 0);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002856 if (NumIvars > 0) {
2857 static bool objc_ivar = false;
2858 if (!objc_ivar) {
2859 /* struct _objc_ivar {
2860 char *ivar_name;
2861 char *ivar_type;
2862 int ivar_offset;
2863 };
2864 */
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002865 Result += "\nstruct _objc_ivar {\n";
2866 Result += "\tchar *ivar_name;\n";
2867 Result += "\tchar *ivar_type;\n";
2868 Result += "\tint ivar_offset;\n";
2869 Result += "};\n";
2870
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002871 objc_ivar = true;
2872 }
2873
Steve Naroff946a6932008-03-11 00:12:29 +00002874 /* struct {
2875 int ivar_count;
2876 struct _objc_ivar ivar_list[nIvars];
2877 };
2878 */
2879 Result += "\nstatic struct {\n";
2880 Result += "\tint ivar_count;\n";
2881 Result += "\tstruct _objc_ivar ivar_list[";
2882 Result += utostr(NumIvars);
2883 Result += "];\n} _OBJC_INSTANCE_VARIABLES_";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002884 Result += IDecl->getName();
Steve Naroffdbb65432008-03-12 17:18:30 +00002885 Result += " __attribute__ ((used, section (\"__OBJC, __instance_vars\")))= "
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002886 "{\n\t";
2887 Result += utostr(NumIvars);
2888 Result += "\n";
Chris Lattnerbe6df082007-12-12 07:56:42 +00002889
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002890 ObjCInterfaceDecl::ivar_iterator IVI, IVE;
Chris Lattnerf3a7af92008-03-16 21:08:55 +00002891 if (!IDecl->ivar_empty()) {
Chris Lattnerbe6df082007-12-12 07:56:42 +00002892 IVI = IDecl->ivar_begin();
2893 IVE = IDecl->ivar_end();
2894 } else {
2895 IVI = CDecl->ivar_begin();
2896 IVE = CDecl->ivar_end();
2897 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002898 Result += "\t,{{\"";
Chris Lattnerbe6df082007-12-12 07:56:42 +00002899 Result += (*IVI)->getName();
Fariborz Jahanian160eb652007-10-29 17:16:25 +00002900 Result += "\", \"";
2901 std::string StrEncoding;
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002902 Context->getObjCEncodingForType((*IVI)->getType(), StrEncoding);
Fariborz Jahanian160eb652007-10-29 17:16:25 +00002903 Result += StrEncoding;
2904 Result += "\", ";
Chris Lattnerbe6df082007-12-12 07:56:42 +00002905 SynthesizeIvarOffsetComputation(IDecl, *IVI, Result);
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002906 Result += "}\n";
Chris Lattnerbe6df082007-12-12 07:56:42 +00002907 for (++IVI; IVI != IVE; ++IVI) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002908 Result += "\t ,{\"";
Chris Lattnerbe6df082007-12-12 07:56:42 +00002909 Result += (*IVI)->getName();
Fariborz Jahanian160eb652007-10-29 17:16:25 +00002910 Result += "\", \"";
2911 std::string StrEncoding;
Daniel Dunbar0d504c12008-10-17 20:21:44 +00002912 Context->getObjCEncodingForType((*IVI)->getType(), StrEncoding);
Fariborz Jahanian160eb652007-10-29 17:16:25 +00002913 Result += StrEncoding;
2914 Result += "\", ";
Chris Lattnerbe6df082007-12-12 07:56:42 +00002915 SynthesizeIvarOffsetComputation(IDecl, (*IVI), Result);
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002916 Result += "}\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002917 }
2918
2919 Result += "\t }\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002920 }
2921
2922 // Build _objc_method_list for class's instance methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002923 RewriteObjCMethodsMetaData(IDecl->instmeth_begin(), IDecl->instmeth_end(),
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002924 true, "", IDecl->getName(), Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002925
2926 // Build _objc_method_list for class's class methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002927 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(),
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002928 false, "", IDecl->getName(), Result);
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002929
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002930 // Protocols referenced in class declaration?
Chris Lattner780f3292008-07-21 21:32:27 +00002931 RewriteObjCProtocolsMetaData(CDecl->getReferencedProtocols(),
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002932 "CLASS", CDecl->getName(), Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002933
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00002934
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00002935 // Declaration of class/meta-class metadata
2936 /* struct _objc_class {
2937 struct _objc_class *isa; // or const char *root_class_name when metadata
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00002938 const char *super_class_name;
2939 char *name;
2940 long version;
2941 long info;
2942 long instance_size;
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00002943 struct _objc_ivar_list *ivars;
2944 struct _objc_method_list *methods;
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00002945 struct objc_cache *cache;
2946 struct objc_protocol_list *protocols;
2947 const char *ivar_layout;
2948 struct _objc_class_ext *ext;
2949 };
2950 */
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00002951 static bool objc_class = false;
2952 if (!objc_class) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002953 Result += "\nstruct _objc_class {\n";
2954 Result += "\tstruct _objc_class *isa;\n";
2955 Result += "\tconst char *super_class_name;\n";
2956 Result += "\tchar *name;\n";
2957 Result += "\tlong version;\n";
2958 Result += "\tlong info;\n";
2959 Result += "\tlong instance_size;\n";
2960 Result += "\tstruct _objc_ivar_list *ivars;\n";
2961 Result += "\tstruct _objc_method_list *methods;\n";
2962 Result += "\tstruct objc_cache *cache;\n";
2963 Result += "\tstruct _objc_protocol_list *protocols;\n";
2964 Result += "\tconst char *ivar_layout;\n";
2965 Result += "\tstruct _objc_class_ext *ext;\n";
2966 Result += "};\n";
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00002967 objc_class = true;
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00002968 }
2969
2970 // Meta-class metadata generation.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002971 ObjCInterfaceDecl *RootClass = 0;
2972 ObjCInterfaceDecl *SuperClass = CDecl->getSuperClass();
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00002973 while (SuperClass) {
2974 RootClass = SuperClass;
2975 SuperClass = SuperClass->getSuperClass();
2976 }
2977 SuperClass = CDecl->getSuperClass();
2978
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002979 Result += "\nstatic struct _objc_class _OBJC_METACLASS_";
2980 Result += CDecl->getName();
Steve Naroffdbb65432008-03-12 17:18:30 +00002981 Result += " __attribute__ ((used, section (\"__OBJC, __meta_class\")))= "
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002982 "{\n\t(struct _objc_class *)\"";
2983 Result += (RootClass ? RootClass->getName() : CDecl->getName());
2984 Result += "\"";
2985
2986 if (SuperClass) {
2987 Result += ", \"";
2988 Result += SuperClass->getName();
2989 Result += "\", \"";
2990 Result += CDecl->getName();
2991 Result += "\"";
2992 }
2993 else {
2994 Result += ", 0, \"";
2995 Result += CDecl->getName();
2996 Result += "\"";
2997 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002998 // Set 'ivars' field for root class to 0. ObjC1 runtime does not use it.
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00002999 // 'info' field is initialized to CLS_META(2) for metaclass
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003000 Result += ", 0,2, sizeof(struct _objc_class), 0";
Steve Naroffb26d7132007-12-05 21:49:40 +00003001 if (IDecl->getNumClassMethods() > 0) {
Steve Naroff23f41272008-03-11 18:14:26 +00003002 Result += "\n\t, (struct _objc_method_list *)&_OBJC_CLASS_METHODS_";
Steve Naroffb26d7132007-12-05 21:49:40 +00003003 Result += IDecl->getName();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003004 Result += "\n";
3005 }
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003006 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003007 Result += ", 0\n";
Chris Lattner3db6cae2008-07-21 18:19:38 +00003008 if (!CDecl->getReferencedProtocols().empty()) {
Steve Naroff8eb4a5e2008-03-12 01:06:30 +00003009 Result += "\t,0, (struct _objc_protocol_list *)&_OBJC_CLASS_PROTOCOLS_";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003010 Result += CDecl->getName();
3011 Result += ",0,0\n";
3012 }
Fariborz Jahanian454cb012007-10-24 20:54:23 +00003013 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003014 Result += "\t,0,0,0,0\n";
3015 Result += "};\n";
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003016
3017 // class metadata generation.
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003018 Result += "\nstatic struct _objc_class _OBJC_CLASS_";
3019 Result += CDecl->getName();
Steve Naroffdbb65432008-03-12 17:18:30 +00003020 Result += " __attribute__ ((used, section (\"__OBJC, __class\")))= "
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003021 "{\n\t&_OBJC_METACLASS_";
3022 Result += CDecl->getName();
3023 if (SuperClass) {
3024 Result += ", \"";
3025 Result += SuperClass->getName();
3026 Result += "\", \"";
3027 Result += CDecl->getName();
3028 Result += "\"";
3029 }
3030 else {
3031 Result += ", 0, \"";
3032 Result += CDecl->getName();
3033 Result += "\"";
3034 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003035 // 'info' field is initialized to CLS_CLASS(1) for class
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003036 Result += ", 0,1";
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003037 if (!ObjCSynthesizedStructs.count(CDecl))
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003038 Result += ",0";
3039 else {
3040 // class has size. Must synthesize its size.
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00003041 Result += ",sizeof(struct ";
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003042 Result += CDecl->getName();
Steve Naroffba9ac4e2008-03-10 23:33:22 +00003043 if (LangOpts.Microsoft)
3044 Result += "_IMPL";
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003045 Result += ")";
3046 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003047 if (NumIvars > 0) {
Steve Naroffc0a123c2008-03-11 17:37:02 +00003048 Result += ", (struct _objc_ivar_list *)&_OBJC_INSTANCE_VARIABLES_";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003049 Result += CDecl->getName();
3050 Result += "\n\t";
3051 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003052 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003053 Result += ",0";
3054 if (IDecl->getNumInstanceMethods() > 0) {
Steve Naroff946a6932008-03-11 00:12:29 +00003055 Result += ", (struct _objc_method_list *)&_OBJC_INSTANCE_METHODS_";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003056 Result += CDecl->getName();
3057 Result += ", 0\n\t";
3058 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003059 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003060 Result += ",0,0";
Chris Lattner3db6cae2008-07-21 18:19:38 +00003061 if (!CDecl->getReferencedProtocols().empty()) {
Steve Naroff8eb4a5e2008-03-12 01:06:30 +00003062 Result += ", (struct _objc_protocol_list*)&_OBJC_CLASS_PROTOCOLS_";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003063 Result += CDecl->getName();
3064 Result += ", 0,0\n";
3065 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003066 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003067 Result += ",0,0,0\n";
3068 Result += "};\n";
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003069}
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003070
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +00003071/// RewriteImplementations - This routine rewrites all method implementations
3072/// and emits meta-data.
3073
Steve Naroffb29b4272008-04-14 22:03:09 +00003074void RewriteObjC::RewriteImplementations(std::string &Result) {
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003075 int ClsDefCount = ClassImplementation.size();
3076 int CatDefCount = CategoryImplementation.size();
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +00003077
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003078 if (ClsDefCount == 0 && CatDefCount == 0)
3079 return;
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +00003080 // Rewrite implemented methods
3081 for (int i = 0; i < ClsDefCount; i++)
3082 RewriteImplementationDecl(ClassImplementation[i]);
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003083
Fariborz Jahanian66d6b292007-11-13 20:04:28 +00003084 for (int i = 0; i < CatDefCount; i++)
3085 RewriteImplementationDecl(CategoryImplementation[i]);
3086
Steve Naroff5df5b762008-05-07 21:23:49 +00003087 // This is needed for determining instance variable offsets.
Steve Naroffa11440b2008-08-05 18:47:23 +00003088 Result += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003089 // For each implemented class, write out all its meta data.
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003090 for (int i = 0; i < ClsDefCount; i++)
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003091 RewriteObjCClassMetaData(ClassImplementation[i], Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003092
3093 // For each implemented category, write out all its meta data.
3094 for (int i = 0; i < CatDefCount; i++)
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003095 RewriteObjCCategoryImplDecl(CategoryImplementation[i], Result);
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003096
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003097 // Write objc_symtab metadata
3098 /*
3099 struct _objc_symtab
3100 {
3101 long sel_ref_cnt;
3102 SEL *refs;
3103 short cls_def_cnt;
3104 short cat_def_cnt;
3105 void *defs[cls_def_cnt + cat_def_cnt];
3106 };
3107 */
3108
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003109 Result += "\nstruct _objc_symtab {\n";
3110 Result += "\tlong sel_ref_cnt;\n";
3111 Result += "\tSEL *refs;\n";
3112 Result += "\tshort cls_def_cnt;\n";
3113 Result += "\tshort cat_def_cnt;\n";
3114 Result += "\tvoid *defs[" + utostr(ClsDefCount + CatDefCount)+ "];\n";
3115 Result += "};\n\n";
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003116
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003117 Result += "static struct _objc_symtab "
Steve Naroffdbb65432008-03-12 17:18:30 +00003118 "_OBJC_SYMBOLS __attribute__((used, section (\"__OBJC, __symbols\")))= {\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003119 Result += "\t0, 0, " + utostr(ClsDefCount)
3120 + ", " + utostr(CatDefCount) + "\n";
3121 for (int i = 0; i < ClsDefCount; i++) {
3122 Result += "\t,&_OBJC_CLASS_";
3123 Result += ClassImplementation[i]->getName();
3124 Result += "\n";
3125 }
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003126
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003127 for (int i = 0; i < CatDefCount; i++) {
3128 Result += "\t,&_OBJC_CATEGORY_";
3129 Result += CategoryImplementation[i]->getClassInterface()->getName();
3130 Result += "_";
3131 Result += CategoryImplementation[i]->getName();
3132 Result += "\n";
3133 }
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003134
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003135 Result += "};\n\n";
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003136
3137 // Write objc_module metadata
3138
3139 /*
3140 struct _objc_module {
3141 long version;
3142 long size;
3143 const char *name;
3144 struct _objc_symtab *symtab;
3145 }
3146 */
3147
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003148 Result += "\nstruct _objc_module {\n";
3149 Result += "\tlong version;\n";
3150 Result += "\tlong size;\n";
3151 Result += "\tconst char *name;\n";
3152 Result += "\tstruct _objc_symtab *symtab;\n";
3153 Result += "};\n\n";
3154 Result += "static struct _objc_module "
Steve Naroffdbb65432008-03-12 17:18:30 +00003155 "_OBJC_MODULES __attribute__ ((used, section (\"__OBJC, __module_info\")))= {\n";
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003156 Result += "\t" + utostr(OBJC_ABI_VERSION) +
3157 ", sizeof(struct _objc_module), \"\", &_OBJC_SYMBOLS\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003158 Result += "};\n\n";
Steve Naroff4f943c22008-03-10 20:43:59 +00003159
3160 if (LangOpts.Microsoft) {
3161 Result += "#pragma section(\".objc_module_info$B\",long,read,write)\n";
Steve Naroff19190322008-05-07 00:06:16 +00003162 Result += "#pragma data_seg(push, \".objc_module_info$B\")\n";
Steve Naroff4f943c22008-03-10 20:43:59 +00003163 Result += "static struct _objc_module *_POINTER_OBJC_MODULES = ";
3164 Result += "&_OBJC_MODULES;\n";
3165 Result += "#pragma data_seg(pop)\n\n";
3166 }
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003167}
Chris Lattner311ff022007-10-16 22:36:42 +00003168
Steve Naroff54055232008-10-27 17:20:55 +00003169std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i,
3170 const char *funcName,
3171 std::string Tag) {
3172 const FunctionType *AFT = CE->getFunctionType();
3173 QualType RT = AFT->getResultType();
3174 std::string StructRef = "struct " + Tag;
3175 std::string S = "static " + RT.getAsString() + " __" +
3176 funcName + "_" + "block_func_" + utostr(i);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00003177
Steve Naroff54055232008-10-27 17:20:55 +00003178 BlockDecl *BD = CE->getBlockDecl();
3179
3180 if (isa<FunctionTypeNoProto>(AFT)) {
3181 S += "()";
3182 } else if (BD->param_empty()) {
3183 S += "(" + StructRef + " *__cself)";
3184 } else {
3185 const FunctionTypeProto *FT = cast<FunctionTypeProto>(AFT);
3186 assert(FT && "SynthesizeBlockFunc: No function proto");
3187 S += '(';
3188 // first add the implicit argument.
3189 S += StructRef + " *__cself, ";
3190 std::string ParamStr;
3191 for (BlockDecl::param_iterator AI = BD->param_begin(),
3192 E = BD->param_end(); AI != E; ++AI) {
3193 if (AI != BD->param_begin()) S += ", ";
3194 ParamStr = (*AI)->getName();
3195 (*AI)->getType().getAsStringInternal(ParamStr);
3196 S += ParamStr;
3197 }
3198 if (FT->isVariadic()) {
3199 if (!BD->param_empty()) S += ", ";
3200 S += "...";
3201 }
3202 S += ')';
3203 }
3204 S += " {\n";
3205
3206 // Create local declarations to avoid rewriting all closure decl ref exprs.
3207 // First, emit a declaration for all "by ref" decls.
3208 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3209 E = BlockByRefDecls.end(); I != E; ++I) {
3210 S += " ";
3211 std::string Name = (*I)->getName();
3212 Context->getPointerType((*I)->getType()).getAsStringInternal(Name);
3213 S += Name + " = __cself->" + (*I)->getName() + "; // bound by ref\n";
3214 }
3215 // Next, emit a declaration for all "by copy" declarations.
3216 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3217 E = BlockByCopyDecls.end(); I != E; ++I) {
3218 S += " ";
3219 std::string Name = (*I)->getName();
3220 // Handle nested closure invocation. For example:
3221 //
3222 // void (^myImportedClosure)(void);
3223 // myImportedClosure = ^(void) { setGlobalInt(x + y); };
3224 //
3225 // void (^anotherClosure)(void);
3226 // anotherClosure = ^(void) {
3227 // myImportedClosure(); // import and invoke the closure
3228 // };
3229 //
3230 if (isBlockPointerType((*I)->getType()))
3231 S += "struct __block_impl *";
3232 else
3233 (*I)->getType().getAsStringInternal(Name);
3234 S += Name + " = __cself->" + (*I)->getName() + "; // bound by copy\n";
3235 }
3236 std::string RewrittenStr = RewrittenBlockExprs[CE];
3237 const char *cstr = RewrittenStr.c_str();
3238 while (*cstr++ != '{') ;
3239 S += cstr;
3240 S += "\n";
3241 return S;
3242}
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00003243
Steve Naroff54055232008-10-27 17:20:55 +00003244std::string RewriteObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
3245 const char *funcName,
3246 std::string Tag) {
3247 std::string StructRef = "struct " + Tag;
3248 std::string S = "static void __";
3249
3250 S += funcName;
3251 S += "_block_copy_" + utostr(i);
3252 S += "(" + StructRef;
3253 S += "*dst, " + StructRef;
3254 S += "*src) {";
3255 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(),
3256 E = ImportedBlockDecls.end(); I != E; ++I) {
3257 S += "_Block_copy_assign(&dst->";
3258 S += (*I)->getName();
3259 S += ", src->";
3260 S += (*I)->getName();
3261 S += ");}";
3262 }
3263 S += "\nstatic void __";
3264 S += funcName;
3265 S += "_block_dispose_" + utostr(i);
3266 S += "(" + StructRef;
3267 S += "*src) {";
3268 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(),
3269 E = ImportedBlockDecls.end(); I != E; ++I) {
3270 S += "_Block_destroy(src->";
3271 S += (*I)->getName();
3272 S += ");";
3273 }
3274 S += "}\n";
3275 return S;
3276}
3277
3278std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag,
3279 bool hasCopyDisposeHelpers) {
Steve Naroffced80a82008-10-30 12:09:33 +00003280 std::string S = "\nstruct " + Tag;
Steve Naroff54055232008-10-27 17:20:55 +00003281 std::string Constructor = " " + Tag;
3282
3283 S += " {\n struct __block_impl impl;\n";
3284
3285 if (hasCopyDisposeHelpers)
3286 S += " void *copy;\n void *dispose;\n";
3287
3288 Constructor += "(void *fp";
3289
3290 if (hasCopyDisposeHelpers)
3291 Constructor += ", void *copyHelp, void *disposeHelp";
3292
3293 if (BlockDeclRefs.size()) {
3294 // Output all "by copy" declarations.
3295 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3296 E = BlockByCopyDecls.end(); I != E; ++I) {
3297 S += " ";
3298 std::string FieldName = (*I)->getName();
3299 std::string ArgName = "_" + FieldName;
3300 // Handle nested closure invocation. For example:
3301 //
3302 // void (^myImportedBlock)(void);
3303 // myImportedBlock = ^(void) { setGlobalInt(x + y); };
3304 //
3305 // void (^anotherBlock)(void);
3306 // anotherBlock = ^(void) {
3307 // myImportedBlock(); // import and invoke the closure
3308 // };
3309 //
3310 if (isBlockPointerType((*I)->getType())) {
3311 S += "struct __block_impl *";
3312 Constructor += ", void *" + ArgName;
3313 } else {
3314 (*I)->getType().getAsStringInternal(FieldName);
3315 (*I)->getType().getAsStringInternal(ArgName);
3316 Constructor += ", " + ArgName;
3317 }
3318 S += FieldName + ";\n";
3319 }
3320 // Output all "by ref" declarations.
3321 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3322 E = BlockByRefDecls.end(); I != E; ++I) {
3323 S += " ";
3324 std::string FieldName = (*I)->getName();
3325 std::string ArgName = "_" + FieldName;
3326 // Handle nested closure invocation. For example:
3327 //
3328 // void (^myImportedBlock)(void);
3329 // myImportedBlock = ^(void) { setGlobalInt(x + y); };
3330 //
3331 // void (^anotherBlock)(void);
3332 // anotherBlock = ^(void) {
3333 // myImportedBlock(); // import and invoke the closure
3334 // };
3335 //
3336 if (isBlockPointerType((*I)->getType())) {
3337 S += "struct __block_impl *";
3338 Constructor += ", void *" + ArgName;
3339 } else {
3340 Context->getPointerType((*I)->getType()).getAsStringInternal(FieldName);
3341 Context->getPointerType((*I)->getType()).getAsStringInternal(ArgName);
3342 Constructor += ", " + ArgName;
3343 }
3344 S += FieldName + "; // by ref\n";
3345 }
3346 // Finish writing the constructor.
3347 // FIXME: handle NSConcreteGlobalBlock.
3348 Constructor += ", int flags=0) {\n";
3349 Constructor += " impl.isa = 0/*&_NSConcreteStackBlock*/;\n impl.Size = sizeof(";
3350 Constructor += Tag + ");\n impl.Flags = flags;\n impl.FuncPtr = fp;\n";
3351
3352 if (hasCopyDisposeHelpers)
3353 Constructor += " copy = copyHelp;\n dispose = disposeHelp;\n";
3354
3355 // Initialize all "by copy" arguments.
3356 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3357 E = BlockByCopyDecls.end(); I != E; ++I) {
3358 std::string Name = (*I)->getName();
3359 Constructor += " ";
3360 if (isBlockPointerType((*I)->getType()))
3361 Constructor += Name + " = (struct __block_impl *)_";
3362 else
3363 Constructor += Name + " = _";
3364 Constructor += Name + ";\n";
3365 }
3366 // Initialize all "by ref" arguments.
3367 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3368 E = BlockByRefDecls.end(); I != E; ++I) {
3369 std::string Name = (*I)->getName();
3370 Constructor += " ";
3371 if (isBlockPointerType((*I)->getType()))
3372 Constructor += Name + " = (struct __block_impl *)_";
3373 else
3374 Constructor += Name + " = _";
3375 Constructor += Name + ";\n";
3376 }
3377 } else {
3378 // Finish writing the constructor.
3379 // FIXME: handle NSConcreteGlobalBlock.
3380 Constructor += ", int flags=0) {\n";
3381 Constructor += " impl.isa = 0/*&_NSConcreteStackBlock*/;\n impl.Size = sizeof(";
3382 Constructor += Tag + ");\n impl.Flags = flags;\n impl.FuncPtr = fp;\n";
3383 if (hasCopyDisposeHelpers)
3384 Constructor += " copy = copyHelp;\n dispose = disposeHelp;\n";
3385 }
3386 Constructor += " ";
3387 Constructor += "}\n";
3388 S += Constructor;
3389 S += "};\n";
3390 return S;
3391}
3392
3393void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart,
3394 const char *FunName) {
3395 // Insert closures that were part of the function.
3396 for (unsigned i = 0; i < Blocks.size(); i++) {
3397
3398 CollectBlockDeclRefInfo(Blocks[i]);
3399
3400 std::string Tag = "__" + std::string(FunName) + "_block_impl_" + utostr(i);
3401
3402 std::string CI = SynthesizeBlockImpl(Blocks[i], Tag,
3403 ImportedBlockDecls.size() > 0);
3404
3405 InsertText(FunLocStart, CI.c_str(), CI.size());
3406
3407 std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, Tag);
3408
3409 InsertText(FunLocStart, CF.c_str(), CF.size());
3410
3411 if (ImportedBlockDecls.size()) {
3412 std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, Tag);
3413 InsertText(FunLocStart, HF.c_str(), HF.size());
3414 }
3415
3416 BlockDeclRefs.clear();
3417 BlockByRefDecls.clear();
3418 BlockByCopyDecls.clear();
3419 BlockCallExprs.clear();
3420 ImportedBlockDecls.clear();
3421 }
3422 Blocks.clear();
3423 RewrittenBlockExprs.clear();
3424}
3425
3426void RewriteObjC::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) {
3427 SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
3428 const char *FuncName = FD->getName();
3429
3430 SynthesizeBlockLiterals(FunLocStart, FuncName);
3431}
3432
3433void RewriteObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) {
Steve Naroffced80a82008-10-30 12:09:33 +00003434 //fprintf(stderr,"In InsertBlockLiteralsWitinMethod\n");
3435 //SourceLocation FunLocStart = MD->getLocStart();
3436 // FIXME: This hack works around a bug in Rewrite.InsertText().
3437 SourceLocation FunLocStart = MD->getLocStart().getFileLocWithOffset(-1);
Steve Naroff54055232008-10-27 17:20:55 +00003438 std::string FuncName = std::string(MD->getSelector().getName());
3439 // Convert colons to underscores.
3440 std::string::size_type loc = 0;
3441 while ((loc = FuncName.find(":", loc)) != std::string::npos)
3442 FuncName.replace(loc, 1, "_");
3443
3444 SynthesizeBlockLiterals(FunLocStart, FuncName.c_str());
3445}
3446
3447void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) {
3448 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
3449 CI != E; ++CI)
3450 if (*CI) {
3451 if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI))
3452 GetBlockDeclRefExprs(CBE->getBody());
3453 else
3454 GetBlockDeclRefExprs(*CI);
3455 }
3456 // Handle specific things.
3457 if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(S))
3458 // FIXME: Handle enums.
3459 if (!isa<FunctionDecl>(CDRE->getDecl()))
3460 BlockDeclRefs.push_back(CDRE);
3461 return;
3462}
3463
3464void RewriteObjC::GetBlockCallExprs(Stmt *S) {
3465 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
3466 CI != E; ++CI)
3467 if (*CI) {
3468 if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI))
3469 GetBlockCallExprs(CBE->getBody());
3470 else
3471 GetBlockCallExprs(*CI);
3472 }
3473
3474 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
3475 if (CE->getCallee()->getType()->isBlockPointerType()) {
3476 BlockCallExprs[dyn_cast<BlockDeclRefExpr>(CE->getCallee())] = CE;
3477 }
3478 }
3479 return;
3480}
3481
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003482Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) {
Steve Naroff54055232008-10-27 17:20:55 +00003483 // Navigate to relevant type information.
3484 const char *closureName = 0;
3485 const BlockPointerType *CPT = 0;
3486
3487 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp->getCallee())) {
3488 closureName = DRE->getDecl()->getName();
3489 CPT = DRE->getType()->getAsBlockPointerType();
3490 } else if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(Exp->getCallee())) {
3491 closureName = CDRE->getDecl()->getName();
3492 CPT = CDRE->getType()->getAsBlockPointerType();
3493 } else if (MemberExpr *MExpr = dyn_cast<MemberExpr>(Exp->getCallee())) {
3494 closureName = MExpr->getMemberDecl()->getName();
3495 CPT = MExpr->getType()->getAsBlockPointerType();
3496 } else {
3497 assert(1 && "RewriteBlockClass: Bad type");
3498 }
3499 assert(CPT && "RewriteBlockClass: Bad type");
3500 const FunctionType *FT = CPT->getPointeeType()->getAsFunctionType();
3501 assert(FT && "RewriteBlockClass: Bad type");
3502 const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(FT);
3503 // FTP will be null for closures that don't take arguments.
3504
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003505 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
3506 SourceLocation(),
3507 &Context->Idents.get("__block_impl"));
3508 QualType PtrBlock = Context->getPointerType(Context->getTagDeclType(RD));
Steve Naroff54055232008-10-27 17:20:55 +00003509
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003510 // Generate a funky cast.
3511 llvm::SmallVector<QualType, 8> ArgTypes;
3512
3513 // Push the block argument type.
3514 ArgTypes.push_back(PtrBlock);
Steve Naroff54055232008-10-27 17:20:55 +00003515 if (FTP) {
3516 for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003517 E = FTP->arg_type_end(); I && (I != E); ++I) {
3518 QualType t = *I;
3519 // Make sure we convert "t (^)(...)" to "t (*)(...)".
3520 if (isBlockPointerType(t)) {
3521 const BlockPointerType *BPT = t->getAsBlockPointerType();
3522 t = Context->getPointerType(BPT->getPointeeType());
3523 }
3524 ArgTypes.push_back(t);
3525 }
Steve Naroff54055232008-10-27 17:20:55 +00003526 }
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003527 // Now do the pointer to function cast.
3528 QualType PtrToFuncCastType = Context->getFunctionType(Exp->getType(),
3529 &ArgTypes[0], ArgTypes.size(), false/*no variadic*/, 0);
3530
3531 PtrToFuncCastType = Context->getPointerType(PtrToFuncCastType);
Steve Naroff54055232008-10-27 17:20:55 +00003532
Steve Naroffb2f9e512008-11-03 23:29:32 +00003533 CastExpr *BlkCast = new CStyleCastExpr(PtrBlock, Exp->getCallee(), PtrBlock, SourceLocation(), SourceLocation());
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003534 // Don't forget the parens to enforce the proper binding.
3535 ParenExpr *PE = new ParenExpr(SourceLocation(), SourceLocation(), BlkCast);
3536 //PE->dump();
Steve Naroff54055232008-10-27 17:20:55 +00003537
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003538 FieldDecl *FD = FieldDecl::Create(*Context, SourceLocation(),
3539 &Context->Idents.get("FuncPtr"), Context->VoidPtrTy);
3540 MemberExpr *ME = new MemberExpr(PE, true, FD, SourceLocation(), FD->getType());
3541
Steve Naroffb2f9e512008-11-03 23:29:32 +00003542 CastExpr *FunkCast = new CStyleCastExpr(PtrToFuncCastType, ME, PtrToFuncCastType, SourceLocation(), SourceLocation());
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003543 PE = new ParenExpr(SourceLocation(), SourceLocation(), FunkCast);
3544
3545 llvm::SmallVector<Expr*, 8> BlkExprs;
3546 // Add the implicit argument.
3547 BlkExprs.push_back(BlkCast);
3548 // Add the user arguments.
Steve Naroff54055232008-10-27 17:20:55 +00003549 for (CallExpr::arg_iterator I = Exp->arg_begin(),
3550 E = Exp->arg_end(); I != E; ++I) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003551 BlkExprs.push_back(*I);
Steve Naroff54055232008-10-27 17:20:55 +00003552 }
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003553 CallExpr *CE = new CallExpr(PE, &BlkExprs[0], BlkExprs.size(), Exp->getType(), SourceLocation());
3554 return CE;
Steve Naroff54055232008-10-27 17:20:55 +00003555}
3556
3557void RewriteObjC::RewriteBlockCall(CallExpr *Exp) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003558 Stmt *BlockCall = SynthesizeBlockCall(Exp);
3559 ReplaceStmt(Exp, BlockCall);
Steve Naroff54055232008-10-27 17:20:55 +00003560}
3561
3562void RewriteObjC::RewriteBlockDeclRefExpr(BlockDeclRefExpr *BDRE) {
3563 // FIXME: Add more elaborate code generation required by the ABI.
3564 InsertText(BDRE->getLocStart(), "*", 1);
3565}
3566
Steve Naroffb2f9e512008-11-03 23:29:32 +00003567void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) {
3568 SourceLocation LocStart = CE->getLParenLoc();
3569 SourceLocation LocEnd = CE->getRParenLoc();
Steve Narofffa15fd92008-10-28 20:29:00 +00003570
3571 // Need to avoid trying to rewrite synthesized casts.
3572 if (LocStart.isInvalid())
3573 return;
Steve Naroff8f6ce572008-11-03 11:20:24 +00003574 // Need to avoid trying to rewrite casts contained in macros.
3575 if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd))
3576 return;
Steve Narofffa15fd92008-10-28 20:29:00 +00003577
Steve Naroff54055232008-10-27 17:20:55 +00003578 const char *startBuf = SM->getCharacterData(LocStart);
3579 const char *endBuf = SM->getCharacterData(LocEnd);
3580
3581 // advance the location to startArgList.
3582 const char *argPtr = startBuf;
3583
3584 while (*argPtr++ && (argPtr < endBuf)) {
3585 switch (*argPtr) {
3586 case '^':
3587 // Replace the '^' with '*'.
3588 LocStart = LocStart.getFileLocWithOffset(argPtr-startBuf);
3589 ReplaceText(LocStart, 1, "*", 1);
3590 break;
3591 }
3592 }
3593 return;
3594}
3595
3596void RewriteObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) {
3597 SourceLocation DeclLoc = FD->getLocation();
3598 unsigned parenCount = 0;
3599
3600 // We have 1 or more arguments that have closure pointers.
3601 const char *startBuf = SM->getCharacterData(DeclLoc);
3602 const char *startArgList = strchr(startBuf, '(');
3603
3604 assert((*startArgList == '(') && "Rewriter fuzzy parser confused");
3605
3606 parenCount++;
3607 // advance the location to startArgList.
3608 DeclLoc = DeclLoc.getFileLocWithOffset(startArgList-startBuf);
3609 assert((DeclLoc.isValid()) && "Invalid DeclLoc");
3610
3611 const char *argPtr = startArgList;
3612
3613 while (*argPtr++ && parenCount) {
3614 switch (*argPtr) {
3615 case '^':
3616 // Replace the '^' with '*'.
3617 DeclLoc = DeclLoc.getFileLocWithOffset(argPtr-startArgList);
3618 ReplaceText(DeclLoc, 1, "*", 1);
3619 break;
3620 case '(':
3621 parenCount++;
3622 break;
3623 case ')':
3624 parenCount--;
3625 break;
3626 }
3627 }
3628 return;
3629}
3630
3631bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) {
3632 const FunctionTypeProto *FTP;
3633 const PointerType *PT = QT->getAsPointerType();
3634 if (PT) {
3635 FTP = PT->getPointeeType()->getAsFunctionTypeProto();
3636 } else {
3637 const BlockPointerType *BPT = QT->getAsBlockPointerType();
3638 assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type");
3639 FTP = BPT->getPointeeType()->getAsFunctionTypeProto();
3640 }
3641 if (FTP) {
3642 for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
3643 E = FTP->arg_type_end(); I != E; ++I)
3644 if (isBlockPointerType(*I))
3645 return true;
3646 }
3647 return false;
3648}
3649
3650void RewriteObjC::GetExtentOfArgList(const char *Name,
3651 const char *&LParen, const char *&RParen) {
3652 const char *argPtr = strchr(Name, '(');
3653 assert((*argPtr == '(') && "Rewriter fuzzy parser confused");
3654
3655 LParen = argPtr; // output the start.
3656 argPtr++; // skip past the left paren.
3657 unsigned parenCount = 1;
3658
3659 while (*argPtr && parenCount) {
3660 switch (*argPtr) {
3661 case '(': parenCount++; break;
3662 case ')': parenCount--; break;
3663 default: break;
3664 }
3665 if (parenCount) argPtr++;
3666 }
3667 assert((*argPtr == ')') && "Rewriter fuzzy parser confused");
3668 RParen = argPtr; // output the end
3669}
3670
3671void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) {
3672 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
3673 RewriteBlockPointerFunctionArgs(FD);
3674 return;
3675 }
3676 // Handle Variables and Typedefs.
3677 SourceLocation DeclLoc = ND->getLocation();
3678 QualType DeclT;
3679 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
3680 DeclT = VD->getType();
3681 else if (TypedefDecl *TDD = dyn_cast<TypedefDecl>(ND))
3682 DeclT = TDD->getUnderlyingType();
3683 else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND))
3684 DeclT = FD->getType();
3685 else
3686 assert(0 && "RewriteBlockPointerDecl(): Decl type not yet handled");
3687
3688 const char *startBuf = SM->getCharacterData(DeclLoc);
3689 const char *endBuf = startBuf;
3690 // scan backward (from the decl location) for the end of the previous decl.
3691 while (*startBuf != '^' && *startBuf != ';' && startBuf != MainFileStart)
3692 startBuf--;
3693
3694 // *startBuf != '^' if we are dealing with a pointer to function that
3695 // may take block argument types (which will be handled below).
3696 if (*startBuf == '^') {
3697 // Replace the '^' with '*', computing a negative offset.
3698 DeclLoc = DeclLoc.getFileLocWithOffset(startBuf-endBuf);
3699 ReplaceText(DeclLoc, 1, "*", 1);
3700 }
3701 if (PointerTypeTakesAnyBlockArguments(DeclT)) {
3702 // Replace the '^' with '*' for arguments.
3703 DeclLoc = ND->getLocation();
3704 startBuf = SM->getCharacterData(DeclLoc);
3705 const char *argListBegin, *argListEnd;
3706 GetExtentOfArgList(startBuf, argListBegin, argListEnd);
3707 while (argListBegin < argListEnd) {
3708 if (*argListBegin == '^') {
3709 SourceLocation CaretLoc = DeclLoc.getFileLocWithOffset(argListBegin-startBuf);
3710 ReplaceText(CaretLoc, 1, "*", 1);
3711 }
3712 argListBegin++;
3713 }
3714 }
3715 return;
3716}
3717
3718void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) {
3719 // Add initializers for any closure decl refs.
3720 GetBlockDeclRefExprs(Exp->getBody());
3721 if (BlockDeclRefs.size()) {
3722 // Unique all "by copy" declarations.
3723 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
3724 if (!BlockDeclRefs[i]->isByRef())
3725 BlockByCopyDecls.insert(BlockDeclRefs[i]->getDecl());
3726 // Unique all "by ref" declarations.
3727 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
3728 if (BlockDeclRefs[i]->isByRef()) {
3729 BlockByRefDecls.insert(BlockDeclRefs[i]->getDecl());
3730 }
3731 // Find any imported blocks...they will need special attention.
3732 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
3733 if (isBlockPointerType(BlockDeclRefs[i]->getType())) {
3734 GetBlockCallExprs(Blocks[i]);
3735 ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
3736 }
3737 }
3738}
3739
Steve Narofffa15fd92008-10-28 20:29:00 +00003740FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(const char *name) {
3741 IdentifierInfo *ID = &Context->Idents.get(name);
3742 QualType FType = Context->getFunctionTypeNoProto(Context->VoidPtrTy);
3743 return FunctionDecl::Create(*Context, TUDecl,SourceLocation(),
3744 ID, FType, FunctionDecl::Extern, false, 0);
3745}
3746
Steve Naroff8e2f57a2008-10-29 18:15:37 +00003747Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp) {
Steve Narofffa15fd92008-10-28 20:29:00 +00003748 Blocks.push_back(Exp);
3749
3750 CollectBlockDeclRefInfo(Exp);
3751 std::string FuncName;
3752
3753 if (CurFunctionDef)
3754 FuncName = std::string(CurFunctionDef->getName());
3755 else if (CurMethodDef) {
3756 FuncName = std::string(CurMethodDef->getSelector().getName());
3757 // Convert colons to underscores.
3758 std::string::size_type loc = 0;
3759 while ((loc = FuncName.find(":", loc)) != std::string::npos)
3760 FuncName.replace(loc, 1, "_");
Steve Naroff8e2f57a2008-10-29 18:15:37 +00003761 } else if (GlobalVarDecl)
3762 FuncName = std::string(GlobalVarDecl->getName());
Steve Narofffa15fd92008-10-28 20:29:00 +00003763
3764 std::string BlockNumber = utostr(Blocks.size()-1);
3765
3766 std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber;
3767 std::string Func = "__" + FuncName + "_block_func_" + BlockNumber;
3768
3769 // Get a pointer to the function type so we can cast appropriately.
3770 QualType FType = Context->getPointerType(QualType(Exp->getFunctionType(),0));
3771
3772 FunctionDecl *FD;
3773 Expr *NewRep;
3774
3775 // Simulate a contructor call...
3776 FD = SynthBlockInitFunctionDecl(Tag.c_str());
3777 DeclRefExpr *DRE = new DeclRefExpr(FD, FType, SourceLocation());
3778
3779 llvm::SmallVector<Expr*, 4> InitExprs;
3780
Steve Narofffdc03722008-10-29 21:23:59 +00003781 // Initialize the block function.
Steve Narofffa15fd92008-10-28 20:29:00 +00003782 FD = SynthBlockInitFunctionDecl(Func.c_str());
3783 DeclRefExpr *Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
3784 CastExpr *castExpr = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00003785 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00003786 InitExprs.push_back(castExpr);
Steve Narofffa15fd92008-10-28 20:29:00 +00003787
3788 if (ImportedBlockDecls.size()) {
3789 std::string Buf = "__" + FuncName + "_block_copy_" + BlockNumber;
Steve Narofffdc03722008-10-29 21:23:59 +00003790 FD = SynthBlockInitFunctionDecl(Buf.c_str());
3791 Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
3792 castExpr = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00003793 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffdc03722008-10-29 21:23:59 +00003794 InitExprs.push_back(castExpr);
3795
Steve Narofffa15fd92008-10-28 20:29:00 +00003796 Buf = "__" + FuncName + "_block_dispose_" + BlockNumber;
Steve Narofffdc03722008-10-29 21:23:59 +00003797 FD = SynthBlockInitFunctionDecl(Buf.c_str());
3798 Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
3799 castExpr = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00003800 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffdc03722008-10-29 21:23:59 +00003801 InitExprs.push_back(castExpr);
Steve Narofffa15fd92008-10-28 20:29:00 +00003802 }
3803 // Add initializers for any closure decl refs.
3804 if (BlockDeclRefs.size()) {
Steve Narofffdc03722008-10-29 21:23:59 +00003805 Expr *Exp;
Steve Narofffa15fd92008-10-28 20:29:00 +00003806 // Output all "by copy" declarations.
3807 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3808 E = BlockByCopyDecls.end(); I != E; ++I) {
Steve Narofffa15fd92008-10-28 20:29:00 +00003809 if (isObjCType((*I)->getType())) {
Steve Narofffdc03722008-10-29 21:23:59 +00003810 // FIXME: Conform to ABI ([[obj retain] autorelease]).
3811 FD = SynthBlockInitFunctionDecl((*I)->getName());
3812 Exp = new DeclRefExpr(FD, FD->getType(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00003813 } else if (isBlockPointerType((*I)->getType())) {
Steve Narofffdc03722008-10-29 21:23:59 +00003814 FD = SynthBlockInitFunctionDecl((*I)->getName());
3815 Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
3816 Exp = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00003817 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00003818 } else {
Steve Narofffdc03722008-10-29 21:23:59 +00003819 FD = SynthBlockInitFunctionDecl((*I)->getName());
3820 Exp = new DeclRefExpr(FD, FD->getType(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00003821 }
Steve Narofffdc03722008-10-29 21:23:59 +00003822 InitExprs.push_back(Exp);
Steve Narofffa15fd92008-10-28 20:29:00 +00003823 }
3824 // Output all "by ref" declarations.
3825 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3826 E = BlockByRefDecls.end(); I != E; ++I) {
Steve Narofffdc03722008-10-29 21:23:59 +00003827 FD = SynthBlockInitFunctionDecl((*I)->getName());
3828 Exp = new DeclRefExpr(FD, FD->getType(), SourceLocation());
3829 Exp = new UnaryOperator(Exp, UnaryOperator::AddrOf,
3830 Context->getPointerType(Exp->getType()),
3831 SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00003832 }
3833 }
Steve Narofffa15fd92008-10-28 20:29:00 +00003834 NewRep = new CallExpr(DRE, &InitExprs[0], InitExprs.size(),
3835 FType, SourceLocation());
3836 NewRep = new UnaryOperator(NewRep, UnaryOperator::AddrOf,
3837 Context->getPointerType(NewRep->getType()),
3838 SourceLocation());
Steve Naroffb2f9e512008-11-03 23:29:32 +00003839 NewRep = new CStyleCastExpr(FType, NewRep, FType, SourceLocation(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00003840 BlockDeclRefs.clear();
3841 BlockByRefDecls.clear();
3842 BlockByCopyDecls.clear();
3843 ImportedBlockDecls.clear();
3844 return NewRep;
3845}
3846
3847//===----------------------------------------------------------------------===//
3848// Function Body / Expression rewriting
3849//===----------------------------------------------------------------------===//
3850
3851Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
3852 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
3853 isa<DoStmt>(S) || isa<ForStmt>(S))
3854 Stmts.push_back(S);
3855 else if (isa<ObjCForCollectionStmt>(S)) {
3856 Stmts.push_back(S);
3857 ObjCBcLabelNo.push_back(++BcLabelCount);
3858 }
3859
3860 SourceRange OrigStmtRange = S->getSourceRange();
3861
3862 // Perform a bottom up rewrite of all children.
3863 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
3864 CI != E; ++CI)
3865 if (*CI) {
3866 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(*CI);
3867 if (newStmt)
3868 *CI = newStmt;
3869 }
3870
3871 if (BlockExpr *BE = dyn_cast<BlockExpr>(S)) {
3872 // Rewrite the block body in place.
3873 RewriteFunctionBodyOrGlobalInitializer(BE->getBody());
3874
3875 // Now we snarf the rewritten text and stash it away for later use.
Steve Naroff8e2f57a2008-10-29 18:15:37 +00003876 std::string Str = Rewrite.getRewritenText(BE->getSourceRange());
3877 RewrittenBlockExprs[BE] = Str;
Steve Narofffa15fd92008-10-28 20:29:00 +00003878
3879 Stmt *blockTranscribed = SynthBlockInitExpr(BE);
3880 //blockTranscribed->dump();
Steve Naroff8e2f57a2008-10-29 18:15:37 +00003881 ReplaceStmt(S, blockTranscribed);
Steve Narofffa15fd92008-10-28 20:29:00 +00003882 return blockTranscribed;
3883 }
3884 // Handle specific things.
3885 if (ObjCEncodeExpr *AtEncode = dyn_cast<ObjCEncodeExpr>(S))
3886 return RewriteAtEncode(AtEncode);
3887
3888 if (ObjCIvarRefExpr *IvarRefExpr = dyn_cast<ObjCIvarRefExpr>(S))
3889 return RewriteObjCIvarRefExpr(IvarRefExpr, OrigStmtRange.getBegin());
3890
3891 if (ObjCSelectorExpr *AtSelector = dyn_cast<ObjCSelectorExpr>(S))
3892 return RewriteAtSelector(AtSelector);
3893
3894 if (ObjCStringLiteral *AtString = dyn_cast<ObjCStringLiteral>(S))
3895 return RewriteObjCStringLiteral(AtString);
3896
3897 if (ObjCMessageExpr *MessExpr = dyn_cast<ObjCMessageExpr>(S)) {
3898 // Before we rewrite it, put the original message expression in a comment.
3899 SourceLocation startLoc = MessExpr->getLocStart();
3900 SourceLocation endLoc = MessExpr->getLocEnd();
3901
3902 const char *startBuf = SM->getCharacterData(startLoc);
3903 const char *endBuf = SM->getCharacterData(endLoc);
3904
3905 std::string messString;
3906 messString += "// ";
3907 messString.append(startBuf, endBuf-startBuf+1);
3908 messString += "\n";
3909
3910 // FIXME: Missing definition of
3911 // InsertText(clang::SourceLocation, char const*, unsigned int).
3912 // InsertText(startLoc, messString.c_str(), messString.size());
3913 // Tried this, but it didn't work either...
3914 // ReplaceText(startLoc, 0, messString.c_str(), messString.size());
3915 return RewriteMessageExpr(MessExpr);
3916 }
3917
3918 if (ObjCAtTryStmt *StmtTry = dyn_cast<ObjCAtTryStmt>(S))
3919 return RewriteObjCTryStmt(StmtTry);
3920
3921 if (ObjCAtSynchronizedStmt *StmtTry = dyn_cast<ObjCAtSynchronizedStmt>(S))
3922 return RewriteObjCSynchronizedStmt(StmtTry);
3923
3924 if (ObjCAtThrowStmt *StmtThrow = dyn_cast<ObjCAtThrowStmt>(S))
3925 return RewriteObjCThrowStmt(StmtThrow);
3926
3927 if (ObjCProtocolExpr *ProtocolExp = dyn_cast<ObjCProtocolExpr>(S))
3928 return RewriteObjCProtocolExpr(ProtocolExp);
3929
3930 if (ObjCForCollectionStmt *StmtForCollection =
3931 dyn_cast<ObjCForCollectionStmt>(S))
3932 return RewriteObjCForCollectionStmt(StmtForCollection,
3933 OrigStmtRange.getEnd());
3934 if (BreakStmt *StmtBreakStmt =
3935 dyn_cast<BreakStmt>(S))
3936 return RewriteBreakStmt(StmtBreakStmt);
3937 if (ContinueStmt *StmtContinueStmt =
3938 dyn_cast<ContinueStmt>(S))
3939 return RewriteContinueStmt(StmtContinueStmt);
3940
3941 // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls
3942 // and cast exprs.
3943 if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
3944 // FIXME: What we're doing here is modifying the type-specifier that
3945 // precedes the first Decl. In the future the DeclGroup should have
3946 // a separate type-specifier that we can rewrite.
3947 RewriteObjCQualifiedInterfaceTypes(*DS->decl_begin());
3948
3949 // Blocks rewrite rules.
3950 for (DeclStmt::decl_iterator DI = DS->decl_begin(), DE = DS->decl_end();
3951 DI != DE; ++DI) {
Steve Narofffa15fd92008-10-28 20:29:00 +00003952 ScopedDecl *SD = *DI;
3953 if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) {
3954 if (isBlockPointerType(ND->getType()))
3955 RewriteBlockPointerDecl(ND);
3956 else if (ND->getType()->isFunctionPointerType())
3957 CheckFunctionPointerDecl(ND->getType(), ND);
3958 }
3959 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) {
3960 if (isBlockPointerType(TD->getUnderlyingType()))
3961 RewriteBlockPointerDecl(TD);
3962 else if (TD->getUnderlyingType()->isFunctionPointerType())
3963 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
3964 }
3965 }
3966 }
3967
3968 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S))
3969 RewriteObjCQualifiedInterfaceTypes(CE);
3970
3971 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
3972 isa<DoStmt>(S) || isa<ForStmt>(S)) {
3973 assert(!Stmts.empty() && "Statement stack is empty");
3974 assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) ||
3975 isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back()))
3976 && "Statement stack mismatch");
3977 Stmts.pop_back();
3978 }
3979 // Handle blocks rewriting.
3980 if (BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(S)) {
3981 if (BDRE->isByRef())
3982 RewriteBlockDeclRefExpr(BDRE);
3983 }
3984 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003985 if (CE->getCallee()->getType()->isBlockPointerType()) {
3986 Stmt *BlockCall = SynthesizeBlockCall(CE);
3987 ReplaceStmt(S, BlockCall);
3988 return BlockCall;
3989 }
Steve Narofffa15fd92008-10-28 20:29:00 +00003990 }
Steve Naroffb2f9e512008-11-03 23:29:32 +00003991 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) {
Steve Narofffa15fd92008-10-28 20:29:00 +00003992 RewriteCastExpr(CE);
3993 }
3994#if 0
3995 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) {
3996 CastExpr *Replacement = new CastExpr(ICE->getType(), ICE->getSubExpr(), SourceLocation());
3997 // Get the new text.
3998 std::string SStr;
3999 llvm::raw_string_ostream Buf(SStr);
4000 Replacement->printPretty(Buf);
4001 const std::string &Str = Buf.str();
4002
4003 printf("CAST = %s\n", &Str[0]);
4004 InsertText(ICE->getSubExpr()->getLocStart(), &Str[0], Str.size());
4005 delete S;
4006 return Replacement;
4007 }
4008#endif
4009 // Return this stmt unmodified.
4010 return S;
4011}
4012
4013/// HandleDeclInMainFile - This is called for each top-level decl defined in the
4014/// main file of the input.
4015void RewriteObjC::HandleDeclInMainFile(Decl *D) {
4016 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
4017 // Since function prototypes don't have ParmDecl's, we check the function
4018 // prototype. This enables us to rewrite function declarations and
4019 // definitions using the same code.
4020 RewriteBlocksInFunctionTypeProto(FD->getType(), FD);
4021
4022 if (Stmt *Body = FD->getBody()) {
4023 CurFunctionDef = FD;
4024 FD->setBody(RewriteFunctionBodyOrGlobalInitializer(Body));
4025 // This synthesizes and inserts the block "impl" struct, invoke function,
4026 // and any copy/dispose helper functions.
4027 InsertBlockLiteralsWithinFunction(FD);
4028 CurFunctionDef = 0;
4029 }
4030 return;
4031 }
4032 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
4033 if (Stmt *Body = MD->getBody()) {
4034 //Body->dump();
4035 CurMethodDef = MD;
4036 MD->setBody(RewriteFunctionBodyOrGlobalInitializer(Body));
4037 InsertBlockLiteralsWithinMethod(MD);
4038 CurMethodDef = 0;
4039 }
4040 }
4041 if (ObjCImplementationDecl *CI = dyn_cast<ObjCImplementationDecl>(D))
4042 ClassImplementation.push_back(CI);
4043 else if (ObjCCategoryImplDecl *CI = dyn_cast<ObjCCategoryImplDecl>(D))
4044 CategoryImplementation.push_back(CI);
4045 else if (ObjCClassDecl *CD = dyn_cast<ObjCClassDecl>(D))
4046 RewriteForwardClassDecl(CD);
4047 else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
4048 RewriteObjCQualifiedInterfaceTypes(VD);
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004049 if (isBlockPointerType(VD->getType()))
Steve Narofffa15fd92008-10-28 20:29:00 +00004050 RewriteBlockPointerDecl(VD);
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004051 else if (VD->getType()->isFunctionPointerType()) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004052 CheckFunctionPointerDecl(VD->getType(), VD);
4053 if (VD->getInit()) {
Steve Naroffb2f9e512008-11-03 23:29:32 +00004054 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004055 RewriteCastExpr(CE);
4056 }
4057 }
4058 }
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004059 if (VD->getInit()) {
4060 GlobalVarDecl = VD;
4061 RewriteFunctionBodyOrGlobalInitializer(VD->getInit());
4062 SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(), VD->getName());
4063 GlobalVarDecl = 0;
4064
4065 // This is needed for blocks.
Steve Naroffb2f9e512008-11-03 23:29:32 +00004066 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) {
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004067 RewriteCastExpr(CE);
4068 }
4069 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004070 return;
4071 }
4072 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
4073 if (isBlockPointerType(TD->getUnderlyingType()))
4074 RewriteBlockPointerDecl(TD);
4075 else if (TD->getUnderlyingType()->isFunctionPointerType())
4076 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
4077 return;
4078 }
4079 if (RecordDecl *RD = dyn_cast<RecordDecl>(D)) {
4080 if (RD->isDefinition()) {
4081 for (RecordDecl::field_const_iterator i = RD->field_begin(),
4082 e = RD->field_end(); i != e; ++i) {
4083 FieldDecl *FD = *i;
4084 if (isBlockPointerType(FD->getType()))
4085 RewriteBlockPointerDecl(FD);
4086 }
4087 }
4088 return;
4089 }
4090 // Nothing yet.
4091}
4092
4093void RewriteObjC::HandleTranslationUnit(TranslationUnit& TU) {
4094 // Get the top-level buffer that this corresponds to.
4095
4096 // Rewrite tabs if we care.
4097 //RewriteTabs();
4098
4099 if (Diags.hasErrorOccurred())
4100 return;
4101
4102 // Create the output file.
4103
4104 llvm::OwningPtr<llvm::raw_ostream> OwnedStream;
4105 llvm::raw_ostream *OutFile;
4106 if (OutFileName == "-") {
4107 OutFile = &llvm::outs();
4108 } else if (!OutFileName.empty()) {
4109 std::string Err;
4110 OutFile = new llvm::raw_fd_ostream(OutFileName.c_str(), Err);
4111 OwnedStream.reset(OutFile);
4112 } else if (InFileName == "-") {
4113 OutFile = &llvm::outs();
4114 } else {
4115 llvm::sys::Path Path(InFileName);
4116 Path.eraseSuffix();
4117 Path.appendSuffix("cpp");
4118 std::string Err;
4119 OutFile = new llvm::raw_fd_ostream(Path.toString().c_str(), Err);
4120 OwnedStream.reset(OutFile);
4121 }
4122
4123 RewriteInclude();
4124
4125 InsertText(SourceLocation::getFileLoc(MainFileID, 0),
4126 Preamble.c_str(), Preamble.size(), false);
4127
4128 // Rewrite Objective-c meta data*
4129 std::string ResultStr;
4130 RewriteImplementations(ResultStr);
4131
4132 // Get the buffer corresponding to MainFileID. If we haven't changed it, then
4133 // we are done.
4134 if (const RewriteBuffer *RewriteBuf =
4135 Rewrite.getRewriteBufferFor(MainFileID)) {
4136 //printf("Changed:\n");
4137 *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end());
4138 } else {
4139 fprintf(stderr, "No changes\n");
4140 }
4141 // Emit metadata.
4142 *OutFile << ResultStr;
4143 OutFile->flush();
4144}
4145