blob: 8828c1c2d352d59686d9d887e3edf86f9436ae8c [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"
Steve Naroff8599e7a2008-12-08 16:43:47 +000019#include "clang/AST/ParentMap.h"
Chris Lattner8a12c272007-10-11 18:38:32 +000020#include "clang/Basic/SourceManager.h"
Steve Naroffebf2b562007-10-23 23:50:29 +000021#include "clang/Basic/IdentifierTable.h"
Chris Lattner07506182007-11-30 22:53:43 +000022#include "clang/Basic/Diagnostic.h"
Chris Lattner26de4652007-12-02 01:13:47 +000023#include "clang/Lex/Lexer.h"
Chris Lattner158ecb92007-10-25 17:07:24 +000024#include "llvm/ADT/StringExtras.h"
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +000025#include "llvm/ADT/SmallPtrSet.h"
Ted Kremeneka95d3752008-09-13 05:16:45 +000026#include "llvm/ADT/OwningPtr.h"
Chris Lattner26de4652007-12-02 01:13:47 +000027#include "llvm/Support/MemoryBuffer.h"
Steve Naroff0113c9d2008-01-28 21:34:52 +000028#include "llvm/Support/CommandLine.h"
Dan Gohman63e2dcc2008-05-21 20:19:16 +000029#include "llvm/Support/Streams.h"
Ted Kremeneka95d3752008-09-13 05:16:45 +000030#include "llvm/Support/raw_ostream.h"
Chris Lattnerc68ab772008-03-22 00:08:40 +000031#include "llvm/System/Path.h"
Chris Lattner77cd2a02007-10-11 00:43:27 +000032using namespace clang;
Chris Lattner158ecb92007-10-25 17:07:24 +000033using llvm::utostr;
Chris Lattner77cd2a02007-10-11 00:43:27 +000034
Steve Naroff0113c9d2008-01-28 21:34:52 +000035static llvm::cl::opt<bool>
36SilenceRewriteMacroWarning("Wno-rewrite-macros", llvm::cl::init(false),
37 llvm::cl::desc("Silence ObjC rewriting warnings"));
38
Chris Lattner77cd2a02007-10-11 00:43:27 +000039namespace {
Steve Naroffb29b4272008-04-14 22:03:09 +000040 class RewriteObjC : public ASTConsumer {
Chris Lattner2c64b7b2007-10-16 21:07:07 +000041 Rewriter Rewrite;
Chris Lattnere365c502007-11-30 22:25:36 +000042 Diagnostic &Diags;
Steve Naroff4f943c22008-03-10 20:43:59 +000043 const LangOptions &LangOpts;
Steve Narofff69cc5d2008-01-30 19:17:43 +000044 unsigned RewriteFailedDiag;
Steve Naroff8c565152008-12-05 17:03:39 +000045 unsigned TryFinallyContainsReturnDiag;
46
Chris Lattner01c57482007-10-17 22:35:30 +000047 ASTContext *Context;
Chris Lattner77cd2a02007-10-11 00:43:27 +000048 SourceManager *SM;
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +000049 TranslationUnitDecl *TUDecl;
Chris Lattner8a12c272007-10-11 18:38:32 +000050 unsigned MainFileID;
Chris Lattner26de4652007-12-02 01:13:47 +000051 const char *MainFileStart, *MainFileEnd;
Chris Lattner2c64b7b2007-10-16 21:07:07 +000052 SourceLocation LastIncLoc;
Steve Naroffba92b2e2008-03-27 22:29:16 +000053
Ted Kremeneka526c5c2008-01-07 19:49:32 +000054 llvm::SmallVector<ObjCImplementationDecl *, 8> ClassImplementation;
55 llvm::SmallVector<ObjCCategoryImplDecl *, 8> CategoryImplementation;
56 llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCSynthesizedStructs;
Steve Narofffbfe8252008-05-06 18:26:51 +000057 llvm::SmallPtrSet<ObjCProtocolDecl*, 8> ObjCSynthesizedProtocols;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000058 llvm::SmallPtrSet<ObjCInterfaceDecl*, 8> ObjCForwardDecls;
59 llvm::DenseMap<ObjCMethodDecl*, std::string> MethodInternalNames;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +000060 llvm::SmallVector<Stmt *, 32> Stmts;
61 llvm::SmallVector<int, 8> ObjCBcLabelNo;
Steve Naroffebf2b562007-10-23 23:50:29 +000062
Steve Naroffd82a9ab2008-03-15 00:55:56 +000063 unsigned NumObjCStringLiterals;
64
Steve Naroffebf2b562007-10-23 23:50:29 +000065 FunctionDecl *MsgSendFunctionDecl;
Steve Naroff874e2322007-11-15 10:28:18 +000066 FunctionDecl *MsgSendSuperFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +000067 FunctionDecl *MsgSendStretFunctionDecl;
68 FunctionDecl *MsgSendSuperStretFunctionDecl;
Fariborz Jahanianacb49772007-12-03 21:26:48 +000069 FunctionDecl *MsgSendFpretFunctionDecl;
Steve Naroffebf2b562007-10-23 23:50:29 +000070 FunctionDecl *GetClassFunctionDecl;
Steve Naroff9bcb5fc2007-12-07 03:50:46 +000071 FunctionDecl *GetMetaClassFunctionDecl;
Steve Naroff934f2762007-10-24 22:48:43 +000072 FunctionDecl *SelGetUidFunctionDecl;
Steve Naroff96984642007-11-08 14:30:50 +000073 FunctionDecl *CFStringFunctionDecl;
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +000074 FunctionDecl *GetProtocolFunctionDecl;
Steve Naroffc0a123c2008-03-11 17:37:02 +000075 FunctionDecl *SuperContructorFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +000076
Steve Naroffbeaf2992007-11-03 11:27:19 +000077 // ObjC string constant support.
Steve Naroff248a7532008-04-15 22:42:06 +000078 VarDecl *ConstantStringClassReference;
Steve Naroffbeaf2992007-11-03 11:27:19 +000079 RecordDecl *NSStringRecord;
Steve Naroffab972d32007-11-04 22:37:50 +000080
Fariborz Jahanianb586cce2008-01-16 00:09:11 +000081 // ObjC foreach break/continue generation support.
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +000082 int BcLabelCount;
83
Steve Naroff874e2322007-11-15 10:28:18 +000084 // Needed for super.
Steve Naroff54055232008-10-27 17:20:55 +000085 ObjCMethodDecl *CurMethodDef;
Steve Naroff874e2322007-11-15 10:28:18 +000086 RecordDecl *SuperStructDecl;
Steve Naroffd82a9ab2008-03-15 00:55:56 +000087 RecordDecl *ConstantStringDecl;
Steve Naroff874e2322007-11-15 10:28:18 +000088
Fariborz Jahanianb4b2f0c2008-01-18 01:15:54 +000089 // Needed for header files being rewritten
90 bool IsHeader;
91
Steve Naroffa7b402d2008-03-28 22:26:09 +000092 std::string InFileName;
93 std::string OutFileName;
94
Steve Naroffba92b2e2008-03-27 22:29:16 +000095 std::string Preamble;
Steve Naroff54055232008-10-27 17:20:55 +000096
97 // Block expressions.
98 llvm::SmallVector<BlockExpr *, 32> Blocks;
99 llvm::SmallVector<BlockDeclRefExpr *, 32> BlockDeclRefs;
100 llvm::DenseMap<BlockDeclRefExpr *, CallExpr *> BlockCallExprs;
Steve Naroffba92b2e2008-03-27 22:29:16 +0000101
Steve Naroff54055232008-10-27 17:20:55 +0000102 // Block related declarations.
103 llvm::SmallPtrSet<ValueDecl *, 8> BlockByCopyDecls;
104 llvm::SmallPtrSet<ValueDecl *, 8> BlockByRefDecls;
105 llvm::SmallPtrSet<ValueDecl *, 8> ImportedBlockDecls;
106
107 llvm::DenseMap<BlockExpr *, std::string> RewrittenBlockExprs;
108
Steve Naroffc77a6362008-12-04 16:24:46 +0000109 // This maps a property to it's assignment statement.
110 llvm::DenseMap<ObjCPropertyRefExpr *, BinaryOperator *> PropSetters;
Steve Naroff8599e7a2008-12-08 16:43:47 +0000111 // This maps a property to it's synthesied message expression.
112 // This allows us to rewrite chained getters (e.g. o.a.b.c).
113 llvm::DenseMap<ObjCPropertyRefExpr *, Stmt *> PropGetters;
114
Steve Naroff4c3580e2008-12-04 23:50:32 +0000115 // This maps an original source AST to it's rewritten form. This allows
116 // us to avoid rewriting the same node twice (which is very uncommon).
117 // This is needed to support some of the exotic property rewriting.
118 llvm::DenseMap<Stmt *, Stmt *> ReplacedNodes;
Steve Naroff15f081d2008-12-03 00:56:33 +0000119
Steve Naroff54055232008-10-27 17:20:55 +0000120 FunctionDecl *CurFunctionDef;
Steve Naroff8e2f57a2008-10-29 18:15:37 +0000121 VarDecl *GlobalVarDecl;
122
Steve Naroffb619d952008-12-09 12:56:34 +0000123 bool DisableReplaceStmt;
124
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +0000125 static const int OBJC_ABI_VERSION =7 ;
Chris Lattner77cd2a02007-10-11 00:43:27 +0000126 public:
Ted Kremeneke3a61982008-05-31 20:11:04 +0000127 virtual void Initialize(ASTContext &context);
128
129 virtual void InitializeTU(TranslationUnit &TU) {
130 TU.SetOwnsDecls(false);
131 Initialize(TU.getContext());
132 }
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000133
Chris Lattner8a12c272007-10-11 18:38:32 +0000134
Chris Lattnerf04da132007-10-24 17:06:59 +0000135 // Top Level Driver code.
136 virtual void HandleTopLevelDecl(Decl *D);
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000137 void HandleDeclInMainFile(Decl *D);
Steve Naroffb29b4272008-04-14 22:03:09 +0000138 RewriteObjC(std::string inFile, std::string outFile,
Steve Naroffa7b402d2008-03-28 22:26:09 +0000139 Diagnostic &D, const LangOptions &LOpts);
Ted Kremeneke452e0f2008-08-08 04:15:52 +0000140
141 ~RewriteObjC() {}
142
143 virtual void HandleTranslationUnit(TranslationUnit& TU);
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000144
145 void ReplaceStmt(Stmt *Old, Stmt *New) {
Steve Naroff4c3580e2008-12-04 23:50:32 +0000146 Stmt *ReplacingStmt = ReplacedNodes[Old];
147
148 if (ReplacingStmt)
149 return; // We can't rewrite the same node twice.
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000150
Steve Naroffb619d952008-12-09 12:56:34 +0000151 if (DisableReplaceStmt)
152 return; // Used when rewriting the assignment of a property setter.
153
Steve Naroff4c3580e2008-12-04 23:50:32 +0000154 // If replacement succeeded or warning disabled return with no warning.
155 if (!Rewrite.ReplaceStmt(Old, New)) {
156 ReplacedNodes[Old] = New;
157 return;
158 }
159 if (SilenceRewriteMacroWarning)
160 return;
Chris Lattner0a14eee2008-11-18 07:04:44 +0000161 Diags.Report(Context->getFullLoc(Old->getLocStart()), RewriteFailedDiag)
162 << Old->getSourceRange();
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000163 }
Steve Naroffb619d952008-12-09 12:56:34 +0000164
165 void ReplaceStmtWithRange(Stmt *Old, Stmt *New, SourceRange SrcRange) {
166 // Measaure the old text.
167 int Size = Rewrite.getRangeSize(SrcRange);
168 if (Size == -1) {
169 Diags.Report(Context->getFullLoc(Old->getLocStart()), RewriteFailedDiag)
170 << Old->getSourceRange();
171 return;
172 }
173 // Get the new text.
174 std::string SStr;
175 llvm::raw_string_ostream S(SStr);
176 New->printPretty(S);
177 const std::string &Str = S.str();
178
179 // If replacement succeeded or warning disabled return with no warning.
180 if (!Rewrite.ReplaceText(SrcRange.getBegin(), Size, &Str[0], Str.size())) {
181 ReplacedNodes[Old] = New;
182 return;
183 }
184 if (SilenceRewriteMacroWarning)
185 return;
186 Diags.Report(Context->getFullLoc(Old->getLocStart()), RewriteFailedDiag)
187 << Old->getSourceRange();
188 }
189
Steve Naroffba92b2e2008-03-27 22:29:16 +0000190 void InsertText(SourceLocation Loc, const char *StrData, unsigned StrLen,
191 bool InsertAfter = true) {
Chris Lattneraadaf782008-01-31 19:51:04 +0000192 // If insertion succeeded or warning disabled return with no warning.
Steve Naroffba92b2e2008-03-27 22:29:16 +0000193 if (!Rewrite.InsertText(Loc, StrData, StrLen, InsertAfter) ||
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000194 SilenceRewriteMacroWarning)
195 return;
196
197 Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
198 }
Chris Lattnerdcbc5b02008-01-31 19:37:57 +0000199
Chris Lattneraadaf782008-01-31 19:51:04 +0000200 void RemoveText(SourceLocation Loc, unsigned StrLen) {
201 // If removal succeeded or warning disabled return with no warning.
202 if (!Rewrite.RemoveText(Loc, StrLen) || SilenceRewriteMacroWarning)
203 return;
204
205 Diags.Report(Context->getFullLoc(Loc), RewriteFailedDiag);
206 }
Chris Lattnerf04da132007-10-24 17:06:59 +0000207
Chris Lattneraadaf782008-01-31 19:51:04 +0000208 void ReplaceText(SourceLocation Start, unsigned OrigLength,
209 const char *NewStr, unsigned NewLength) {
210 // If removal succeeded or warning disabled return with no warning.
211 if (!Rewrite.ReplaceText(Start, OrigLength, NewStr, NewLength) ||
212 SilenceRewriteMacroWarning)
213 return;
214
215 Diags.Report(Context->getFullLoc(Start), RewriteFailedDiag);
216 }
217
Chris Lattnerf04da132007-10-24 17:06:59 +0000218 // Syntactic Rewriting.
Steve Naroffab972d32007-11-04 22:37:50 +0000219 void RewritePrologue(SourceLocation Loc);
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000220 void RewriteInclude();
Chris Lattnerf04da132007-10-24 17:06:59 +0000221 void RewriteTabs();
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000222 void RewriteForwardClassDecl(ObjCClassDecl *Dcl);
Steve Naroffa0876e82008-12-02 17:36:43 +0000223 void RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
224 ObjCImplementationDecl *IMD,
225 ObjCCategoryImplDecl *CID);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000226 void RewriteInterfaceDecl(ObjCInterfaceDecl *Dcl);
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000227 void RewriteImplementationDecl(NamedDecl *Dcl);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000228 void RewriteObjCMethodDecl(ObjCMethodDecl *MDecl, std::string &ResultStr);
229 void RewriteCategoryDecl(ObjCCategoryDecl *Dcl);
230 void RewriteProtocolDecl(ObjCProtocolDecl *Dcl);
231 void RewriteForwardProtocolDecl(ObjCForwardProtocolDecl *Dcl);
232 void RewriteMethodDeclaration(ObjCMethodDecl *Method);
Chris Lattner55d13b42008-03-16 21:23:50 +0000233 void RewriteProperties(unsigned nProperties, ObjCPropertyDecl **Properties);
Steve Naroff09b266e2007-10-30 23:14:51 +0000234 void RewriteFunctionDecl(FunctionDecl *FD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000235 void RewriteObjCQualifiedInterfaceTypes(Decl *Dcl);
Steve Naroff4f95b752008-07-29 18:15:38 +0000236 void RewriteObjCQualifiedInterfaceTypes(Expr *E);
Steve Naroffd5255f52007-11-01 13:24:47 +0000237 bool needToScanForQualifiers(QualType T);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000238 ObjCInterfaceDecl *isSuperReceiver(Expr *recExpr);
Steve Naroff874e2322007-11-15 10:28:18 +0000239 QualType getSuperStructType();
Steve Naroffd82a9ab2008-03-15 00:55:56 +0000240 QualType getConstantStringStructType();
Steve Naroffbaf58c32008-05-31 14:15:04 +0000241 bool BufferContainsPPDirectives(const char *startBuf, const char *endBuf);
Chris Lattner311ff022007-10-16 22:36:42 +0000242
Chris Lattnerf04da132007-10-24 17:06:59 +0000243 // Expression Rewriting.
Steve Narofff3473a72007-11-09 15:20:18 +0000244 Stmt *RewriteFunctionBodyOrGlobalInitializer(Stmt *S);
Steve Naroffc77a6362008-12-04 16:24:46 +0000245 void CollectPropertySetters(Stmt *S);
246
Steve Naroff8599e7a2008-12-08 16:43:47 +0000247 Stmt *CurrentBody;
248 ParentMap *PropParentMap; // created lazily.
249
Chris Lattnere64b7772007-10-24 16:57:36 +0000250 Stmt *RewriteAtEncode(ObjCEncodeExpr *Exp);
Chris Lattner3b2c58c2008-05-23 20:40:52 +0000251 Stmt *RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV, SourceLocation OrigStart);
Steve Naroffc77a6362008-12-04 16:24:46 +0000252 Stmt *RewritePropertyGetter(ObjCPropertyRefExpr *PropRefExpr);
Steve Naroffb619d952008-12-09 12:56:34 +0000253 Stmt *RewritePropertySetter(BinaryOperator *BinOp, Expr *newStmt,
254 SourceRange SrcRange);
Steve Naroffb42f8412007-11-05 14:50:49 +0000255 Stmt *RewriteAtSelector(ObjCSelectorExpr *Exp);
Chris Lattnere64b7772007-10-24 16:57:36 +0000256 Stmt *RewriteMessageExpr(ObjCMessageExpr *Exp);
Steve Naroffbeaf2992007-11-03 11:27:19 +0000257 Stmt *RewriteObjCStringLiteral(ObjCStringLiteral *Exp);
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +0000258 Stmt *RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp);
Steve Naroff8c565152008-12-05 17:03:39 +0000259 void WarnAboutReturnGotoContinueOrBreakStmts(Stmt *S);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000260 Stmt *RewriteObjCTryStmt(ObjCAtTryStmt *S);
Fariborz Jahaniana0f55792008-01-29 22:59:37 +0000261 Stmt *RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000262 Stmt *RewriteObjCCatchStmt(ObjCAtCatchStmt *S);
263 Stmt *RewriteObjCFinallyStmt(ObjCAtFinallyStmt *S);
264 Stmt *RewriteObjCThrowStmt(ObjCAtThrowStmt *S);
Chris Lattner338d1e22008-01-31 05:10:40 +0000265 Stmt *RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
266 SourceLocation OrigEnd);
Steve Naroff934f2762007-10-24 22:48:43 +0000267 CallExpr *SynthesizeCallToFunctionDecl(FunctionDecl *FD,
268 Expr **args, unsigned nargs);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +0000269 Stmt *SynthMessageExpr(ObjCMessageExpr *Exp);
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +0000270 Stmt *RewriteBreakStmt(BreakStmt *S);
271 Stmt *RewriteContinueStmt(ContinueStmt *S);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +0000272 void SynthCountByEnumWithState(std::string &buf);
273
Steve Naroff09b266e2007-10-30 23:14:51 +0000274 void SynthMsgSendFunctionDecl();
Steve Naroff874e2322007-11-15 10:28:18 +0000275 void SynthMsgSendSuperFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +0000276 void SynthMsgSendStretFunctionDecl();
Fariborz Jahanianacb49772007-12-03 21:26:48 +0000277 void SynthMsgSendFpretFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +0000278 void SynthMsgSendSuperStretFunctionDecl();
Steve Naroff09b266e2007-10-30 23:14:51 +0000279 void SynthGetClassFunctionDecl();
Steve Naroff9bcb5fc2007-12-07 03:50:46 +0000280 void SynthGetMetaClassFunctionDecl();
Fariborz Jahaniana70711b2007-12-04 21:47:40 +0000281 void SynthSelGetUidFunctionDecl();
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +0000282 void SynthGetProtocolFunctionDecl();
Steve Naroffc0a123c2008-03-11 17:37:02 +0000283 void SynthSuperContructorFunctionDecl();
Steve Naroff96984642007-11-08 14:30:50 +0000284
Chris Lattnerf04da132007-10-24 17:06:59 +0000285 // Metadata emission.
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000286 void RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +0000287 std::string &Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000288
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000289 void RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *CDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +0000290 std::string &Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000291
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000292 typedef ObjCCategoryImplDecl::instmeth_iterator instmeth_iterator;
293 void RewriteObjCMethodsMetaData(instmeth_iterator MethodBegin,
Chris Lattnerab4c4d52007-12-12 07:46:12 +0000294 instmeth_iterator MethodEnd,
Fariborz Jahanian8e991ba2007-10-25 00:14:44 +0000295 bool IsInstanceMethod,
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000296 const char *prefix,
Chris Lattner158ecb92007-10-25 17:07:24 +0000297 const char *ClassName,
298 std::string &Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000299
Chris Lattner780f3292008-07-21 21:32:27 +0000300 void RewriteObjCProtocolsMetaData(const ObjCList<ObjCProtocolDecl>
301 &Protocols,
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +0000302 const char *prefix,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +0000303 const char *ClassName,
304 std::string &Result);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000305 void SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +0000306 std::string &Result);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000307 void SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl,
308 ObjCIvarDecl *ivar,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +0000309 std::string &Result);
Steve Narofface66252008-11-13 20:07:04 +0000310 void RewriteImplementations();
311 void SynthesizeMetaDataIntoBuffer(std::string &Result);
Steve Naroff54055232008-10-27 17:20:55 +0000312
313 // Block rewriting.
314 void RewriteBlocksInFunctionTypeProto(QualType funcType, NamedDecl *D);
315 void CheckFunctionPointerDecl(QualType dType, NamedDecl *ND);
316
317 void InsertBlockLiteralsWithinFunction(FunctionDecl *FD);
318 void InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD);
319
Steve Naroff8e2f57a2008-10-29 18:15:37 +0000320 // Block specific rewrite rules.
Steve Naroff54055232008-10-27 17:20:55 +0000321 void RewriteBlockCall(CallExpr *Exp);
322 void RewriteBlockPointerDecl(NamedDecl *VD);
323 void RewriteBlockDeclRefExpr(BlockDeclRefExpr *VD);
324 void RewriteBlockPointerFunctionArgs(FunctionDecl *FD);
325
326 std::string SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
327 const char *funcName, std::string Tag);
328 std::string SynthesizeBlockFunc(BlockExpr *CE, int i,
329 const char *funcName, std::string Tag);
330 std::string SynthesizeBlockImpl(BlockExpr *CE, std::string Tag,
331 bool hasCopyDisposeHelpers);
Steve Naroffaa4d5ae2008-10-30 10:07:53 +0000332 Stmt *SynthesizeBlockCall(CallExpr *Exp);
Steve Naroff54055232008-10-27 17:20:55 +0000333 void SynthesizeBlockLiterals(SourceLocation FunLocStart,
334 const char *FunName);
335
336 void CollectBlockDeclRefInfo(BlockExpr *Exp);
337 void GetBlockCallExprs(Stmt *S);
338 void GetBlockDeclRefExprs(Stmt *S);
339
340 // We avoid calling Type::isBlockPointerType(), since it operates on the
341 // canonical type. We only care if the top-level type is a closure pointer.
Steve Naroff01f2ffa2008-12-11 21:05:33 +0000342 bool isTopLevelBlockPointerType(QualType T) { return isa<BlockPointerType>(T); }
Steve Naroff54055232008-10-27 17:20:55 +0000343
344 // FIXME: This predicate seems like it would be useful to add to ASTContext.
345 bool isObjCType(QualType T) {
346 if (!LangOpts.ObjC1 && !LangOpts.ObjC2)
347 return false;
348
349 QualType OCT = Context->getCanonicalType(T).getUnqualifiedType();
350
351 if (OCT == Context->getCanonicalType(Context->getObjCIdType()) ||
352 OCT == Context->getCanonicalType(Context->getObjCClassType()))
353 return true;
354
355 if (const PointerType *PT = OCT->getAsPointerType()) {
356 if (isa<ObjCInterfaceType>(PT->getPointeeType()) ||
357 isa<ObjCQualifiedIdType>(PT->getPointeeType()))
358 return true;
359 }
360 return false;
361 }
362 bool PointerTypeTakesAnyBlockArguments(QualType QT);
363 void GetExtentOfArgList(const char *Name, const char *&LParen, const char *&RParen);
Steve Naroffb2f9e512008-11-03 23:29:32 +0000364 void RewriteCastExpr(CStyleCastExpr *CE);
Steve Narofffa15fd92008-10-28 20:29:00 +0000365
366 FunctionDecl *SynthBlockInitFunctionDecl(const char *name);
Steve Naroff8e2f57a2008-10-29 18:15:37 +0000367 Stmt *SynthBlockInitExpr(BlockExpr *Exp);
Chris Lattner77cd2a02007-10-11 00:43:27 +0000368 };
369}
370
Steve Naroff54055232008-10-27 17:20:55 +0000371void RewriteObjC::RewriteBlocksInFunctionTypeProto(QualType funcType,
372 NamedDecl *D) {
373 if (FunctionTypeProto *fproto = dyn_cast<FunctionTypeProto>(funcType)) {
374 for (FunctionTypeProto::arg_type_iterator I = fproto->arg_type_begin(),
375 E = fproto->arg_type_end(); I && (I != E); ++I)
Steve Naroff01f2ffa2008-12-11 21:05:33 +0000376 if (isTopLevelBlockPointerType(*I)) {
Steve Naroff54055232008-10-27 17:20:55 +0000377 // All the args are checked/rewritten. Don't call twice!
378 RewriteBlockPointerDecl(D);
379 break;
380 }
381 }
382}
383
384void RewriteObjC::CheckFunctionPointerDecl(QualType funcType, NamedDecl *ND) {
385 const PointerType *PT = funcType->getAsPointerType();
386 if (PT && PointerTypeTakesAnyBlockArguments(funcType))
387 RewriteBlocksInFunctionTypeProto(PT->getPointeeType(), ND);
388}
389
Fariborz Jahanianb4b2f0c2008-01-18 01:15:54 +0000390static bool IsHeaderFile(const std::string &Filename) {
391 std::string::size_type DotPos = Filename.rfind('.');
392
393 if (DotPos == std::string::npos) {
394 // no file extension
395 return false;
396 }
397
398 std::string Ext = std::string(Filename.begin()+DotPos+1, Filename.end());
399 // C header: .h
400 // C++ header: .hh or .H;
401 return Ext == "h" || Ext == "hh" || Ext == "H";
402}
403
Steve Naroffb29b4272008-04-14 22:03:09 +0000404RewriteObjC::RewriteObjC(std::string inFile, std::string outFile,
Steve Naroffa7b402d2008-03-28 22:26:09 +0000405 Diagnostic &D, const LangOptions &LOpts)
406 : Diags(D), LangOpts(LOpts) {
407 IsHeader = IsHeaderFile(inFile);
408 InFileName = inFile;
409 OutFileName = outFile;
410 RewriteFailedDiag = Diags.getCustomDiagID(Diagnostic::Warning,
411 "rewriting sub-expression within a macro (may not be correct)");
Steve Naroff8c565152008-12-05 17:03:39 +0000412 TryFinallyContainsReturnDiag = Diags.getCustomDiagID(Diagnostic::Warning,
413 "rewriter doesn't support user-specified control flow semantics for @try/@finally (code may not execute properly)");
Steve Naroffa7b402d2008-03-28 22:26:09 +0000414}
415
Fariborz Jahanianb4b2f0c2008-01-18 01:15:54 +0000416ASTConsumer *clang::CreateCodeRewriterTest(const std::string& InFile,
Chris Lattnerc68ab772008-03-22 00:08:40 +0000417 const std::string& OutFile,
Steve Naroff4f943c22008-03-10 20:43:59 +0000418 Diagnostic &Diags,
419 const LangOptions &LOpts) {
Steve Naroffb29b4272008-04-14 22:03:09 +0000420 return new RewriteObjC(InFile, OutFile, Diags, LOpts);
Chris Lattnere365c502007-11-30 22:25:36 +0000421}
Chris Lattner77cd2a02007-10-11 00:43:27 +0000422
Steve Naroffb29b4272008-04-14 22:03:09 +0000423void RewriteObjC::Initialize(ASTContext &context) {
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000424 Context = &context;
425 SM = &Context->getSourceManager();
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +0000426 TUDecl = Context->getTranslationUnitDecl();
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000427 MsgSendFunctionDecl = 0;
428 MsgSendSuperFunctionDecl = 0;
429 MsgSendStretFunctionDecl = 0;
430 MsgSendSuperStretFunctionDecl = 0;
431 MsgSendFpretFunctionDecl = 0;
432 GetClassFunctionDecl = 0;
433 GetMetaClassFunctionDecl = 0;
434 SelGetUidFunctionDecl = 0;
435 CFStringFunctionDecl = 0;
436 GetProtocolFunctionDecl = 0;
437 ConstantStringClassReference = 0;
438 NSStringRecord = 0;
Steve Naroff54055232008-10-27 17:20:55 +0000439 CurMethodDef = 0;
440 CurFunctionDef = 0;
Steve Naroffb619d952008-12-09 12:56:34 +0000441 GlobalVarDecl = 0;
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000442 SuperStructDecl = 0;
Steve Naroff9630ec52008-03-27 22:59:54 +0000443 ConstantStringDecl = 0;
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000444 BcLabelCount = 0;
Steve Naroffc0a123c2008-03-11 17:37:02 +0000445 SuperContructorFunctionDecl = 0;
Steve Naroffd82a9ab2008-03-15 00:55:56 +0000446 NumObjCStringLiterals = 0;
Steve Naroff68272b82008-12-08 20:01:41 +0000447 PropParentMap = 0;
448 CurrentBody = 0;
Steve Naroffb619d952008-12-09 12:56:34 +0000449 DisableReplaceStmt = false;
450
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000451 // Get the ID and start/end of the main file.
452 MainFileID = SM->getMainFileID();
453 const llvm::MemoryBuffer *MainBuf = SM->getBuffer(MainFileID);
454 MainFileStart = MainBuf->getBufferStart();
455 MainFileEnd = MainBuf->getBufferEnd();
Steve Naroffba92b2e2008-03-27 22:29:16 +0000456
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000457 Rewrite.setSourceMgr(Context->getSourceManager());
Steve Naroff61ed9ca2008-03-10 23:16:54 +0000458
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000459 // declaring objc_selector outside the parameter list removes a silly
460 // scope related warning...
Steve Naroffba92b2e2008-03-27 22:29:16 +0000461 if (IsHeader)
462 Preamble = "#pragma once\n";
463 Preamble += "struct objc_selector; struct objc_class;\n";
464 Preamble += "#ifndef OBJC_SUPER\n";
465 Preamble += "struct objc_super { struct objc_object *object; ";
466 Preamble += "struct objc_object *superClass; ";
Steve Naroffc0a123c2008-03-11 17:37:02 +0000467 if (LangOpts.Microsoft) {
468 // Add a constructor for creating temporary objects.
Steve Naroffba92b2e2008-03-27 22:29:16 +0000469 Preamble += "objc_super(struct objc_object *o, struct objc_object *s) : ";
470 Preamble += "object(o), superClass(s) {} ";
Steve Naroffc0a123c2008-03-11 17:37:02 +0000471 }
Steve Naroffba92b2e2008-03-27 22:29:16 +0000472 Preamble += "};\n";
473 Preamble += "#define OBJC_SUPER\n";
474 Preamble += "#endif\n";
475 Preamble += "#ifndef _REWRITER_typedef_Protocol\n";
476 Preamble += "typedef struct objc_object Protocol;\n";
477 Preamble += "#define _REWRITER_typedef_Protocol\n";
478 Preamble += "#endif\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000479 if (LangOpts.Microsoft) {
480 Preamble += "#define __OBJC_RW_DLLIMPORT extern \"C\" __declspec(dllimport)\n";
481 Preamble += "#define __OBJC_RW_STATICIMPORT extern \"C\"\n";
482 } else
483 Preamble += "#define __OBJC_RW_DLLIMPORT extern\n";
484 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSend";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000485 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000486 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSendSuper";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000487 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000488 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSend_stret";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000489 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000490 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_msgSendSuper_stret";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000491 Preamble += "(struct objc_super *, struct objc_selector *, ...);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000492 Preamble += "__OBJC_RW_DLLIMPORT double objc_msgSend_fpret";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000493 Preamble += "(struct objc_object *, struct objc_selector *, ...);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000494 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_getClass";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000495 Preamble += "(const char *);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000496 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_getMetaClass";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000497 Preamble += "(const char *);\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000498 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_throw(struct objc_object *);\n";
499 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_try_enter(void *);\n";
500 Preamble += "__OBJC_RW_DLLIMPORT void objc_exception_try_exit(void *);\n";
501 Preamble += "__OBJC_RW_DLLIMPORT struct objc_object *objc_exception_extract(void *);\n";
502 Preamble += "__OBJC_RW_DLLIMPORT int objc_exception_match";
Steve Naroff580ca782008-05-09 21:17:56 +0000503 Preamble += "(struct objc_class *, struct objc_object *);\n";
Steve Naroff59f05a42008-07-16 18:58:11 +0000504 // @synchronized hooks.
Steve Naroff4ebd7162008-12-08 17:30:33 +0000505 Preamble += "__OBJC_RW_DLLIMPORT void objc_sync_enter(struct objc_object *);\n";
506 Preamble += "__OBJC_RW_DLLIMPORT void objc_sync_exit(struct objc_object *);\n";
507 Preamble += "__OBJC_RW_DLLIMPORT Protocol *objc_getProtocol(const char *);\n";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000508 Preamble += "#ifndef __FASTENUMERATIONSTATE\n";
509 Preamble += "struct __objcFastEnumerationState {\n\t";
510 Preamble += "unsigned long state;\n\t";
Steve Naroffb10f2732008-04-04 22:58:22 +0000511 Preamble += "void **itemsPtr;\n\t";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000512 Preamble += "unsigned long *mutationsPtr;\n\t";
513 Preamble += "unsigned long extra[5];\n};\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000514 Preamble += "__OBJC_RW_DLLIMPORT void objc_enumerationMutation(struct objc_object *);\n";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000515 Preamble += "#define __FASTENUMERATIONSTATE\n";
516 Preamble += "#endif\n";
517 Preamble += "#ifndef __NSCONSTANTSTRINGIMPL\n";
518 Preamble += "struct __NSConstantStringImpl {\n";
519 Preamble += " int *isa;\n";
520 Preamble += " int flags;\n";
521 Preamble += " char *str;\n";
522 Preamble += " long length;\n";
523 Preamble += "};\n";
Steve Naroff88bee742008-08-05 20:04:48 +0000524 Preamble += "#ifdef CF_EXPORT_CONSTANT_STRING\n";
525 Preamble += "extern \"C\" __declspec(dllexport) int __CFConstantStringClassReference[];\n";
526 Preamble += "#else\n";
Steve Naroff4ebd7162008-12-08 17:30:33 +0000527 Preamble += "__OBJC_RW_DLLIMPORT int __CFConstantStringClassReference[];\n";
Steve Naroff88bee742008-08-05 20:04:48 +0000528 Preamble += "#endif\n";
Steve Naroffba92b2e2008-03-27 22:29:16 +0000529 Preamble += "#define __NSCONSTANTSTRINGIMPL\n";
530 Preamble += "#endif\n";
Steve Naroff54055232008-10-27 17:20:55 +0000531 // Blocks preamble.
532 Preamble += "#ifndef BLOCK_IMPL\n";
533 Preamble += "#define BLOCK_IMPL\n";
534 Preamble += "struct __block_impl {\n";
535 Preamble += " void *isa;\n";
536 Preamble += " int Flags;\n";
537 Preamble += " int Size;\n";
538 Preamble += " void *FuncPtr;\n";
539 Preamble += "};\n";
Steve Naroff5bc60d02008-12-16 15:50:30 +0000540 Preamble += "// Runtime copy/destroy helper functions (from Block_private.h)\n";
541 Preamble += "__OBJC_RW_STATICIMPORT void _Block_object_assign(void *, const void *, const int);\n";
542 Preamble += "__OBJC_RW_STATICIMPORT void _Block_object_dispose(const void *, const int);\n";
543 Preamble += "__OBJC_RW_STATICIMPORT void *_NSConcreteGlobalBlock[32];\n";
544 Preamble += "__OBJC_RW_STATICIMPORT void *_NSConcreteStackBlock[32];\n";
Steve Naroff54055232008-10-27 17:20:55 +0000545 Preamble += "#endif\n";
Steve Naroffa48396e2008-10-27 18:50:14 +0000546 if (LangOpts.Microsoft) {
Steve Naroff4ebd7162008-12-08 17:30:33 +0000547 Preamble += "#undef __OBJC_RW_DLLIMPORT\n";
548 Preamble += "#undef __OBJC_RW_STATICIMPORT\n";
Steve Naroffa48396e2008-10-27 18:50:14 +0000549 Preamble += "#define __attribute__(X)\n";
550 }
Chris Lattner9e13c2e2008-01-31 19:38:44 +0000551}
552
553
Chris Lattnerf04da132007-10-24 17:06:59 +0000554//===----------------------------------------------------------------------===//
555// Top Level Driver Code
556//===----------------------------------------------------------------------===//
557
Steve Naroffb29b4272008-04-14 22:03:09 +0000558void RewriteObjC::HandleTopLevelDecl(Decl *D) {
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000559 // Two cases: either the decl could be in the main file, or it could be in a
560 // #included file. If the former, rewrite it now. If the later, check to see
561 // if we rewrote the #include/#import.
562 SourceLocation Loc = D->getLocation();
563 Loc = SM->getLogicalLoc(Loc);
564
565 // If this is for a builtin, ignore it.
566 if (Loc.isInvalid()) return;
567
Steve Naroffebf2b562007-10-23 23:50:29 +0000568 // Look for built-in declarations that we need to refer during the rewrite.
569 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Steve Naroff09b266e2007-10-30 23:14:51 +0000570 RewriteFunctionDecl(FD);
Steve Naroff248a7532008-04-15 22:42:06 +0000571 } else if (VarDecl *FVD = dyn_cast<VarDecl>(D)) {
Steve Naroffbeaf2992007-11-03 11:27:19 +0000572 // declared in <Foundation/NSString.h>
Chris Lattner8ec03f52008-11-24 03:54:41 +0000573 if (strcmp(FVD->getNameAsCString(), "_NSConstantStringClassReference") == 0) {
Steve Naroffbeaf2992007-11-03 11:27:19 +0000574 ConstantStringClassReference = FVD;
575 return;
576 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000577 } else if (ObjCInterfaceDecl *MD = dyn_cast<ObjCInterfaceDecl>(D)) {
Steve Naroffbef11852007-10-26 20:53:56 +0000578 RewriteInterfaceDecl(MD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000579 } else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(D)) {
Steve Naroff423cb562007-10-30 13:30:57 +0000580 RewriteCategoryDecl(CD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000581 } else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
Steve Naroff752d6ef2007-10-30 16:42:30 +0000582 RewriteProtocolDecl(PD);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000583 } else if (ObjCForwardProtocolDecl *FP =
584 dyn_cast<ObjCForwardProtocolDecl>(D)){
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000585 RewriteForwardProtocolDecl(FP);
Steve Naroffebf2b562007-10-23 23:50:29 +0000586 }
Chris Lattnerf04da132007-10-24 17:06:59 +0000587 // If we have a decl in the main file, see if we should rewrite it.
Ted Kremenekcf7e9582008-04-14 21:24:13 +0000588 if (SM->isFromMainFile(Loc))
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000589 return HandleDeclInMainFile(D);
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000590}
591
Chris Lattnerf04da132007-10-24 17:06:59 +0000592//===----------------------------------------------------------------------===//
593// Syntactic (non-AST) Rewriting Code
594//===----------------------------------------------------------------------===//
595
Steve Naroffb29b4272008-04-14 22:03:09 +0000596void RewriteObjC::RewriteInclude() {
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000597 SourceLocation LocStart = SourceLocation::getFileLoc(MainFileID, 0);
598 std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID);
599 const char *MainBufStart = MainBuf.first;
600 const char *MainBufEnd = MainBuf.second;
601 size_t ImportLen = strlen("import");
602 size_t IncludeLen = strlen("include");
603
Fariborz Jahanianaf57b462008-01-19 01:03:17 +0000604 // Loop over the whole file, looking for includes.
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000605 for (const char *BufPtr = MainBufStart; BufPtr < MainBufEnd; ++BufPtr) {
606 if (*BufPtr == '#') {
607 if (++BufPtr == MainBufEnd)
608 return;
609 while (*BufPtr == ' ' || *BufPtr == '\t')
610 if (++BufPtr == MainBufEnd)
611 return;
612 if (!strncmp(BufPtr, "import", ImportLen)) {
613 // replace import with include
614 SourceLocation ImportLoc =
615 LocStart.getFileLocWithOffset(BufPtr-MainBufStart);
Chris Lattneraadaf782008-01-31 19:51:04 +0000616 ReplaceText(ImportLoc, ImportLen, "include", IncludeLen);
Fariborz Jahanian452b8992008-01-19 00:30:35 +0000617 BufPtr += ImportLen;
618 }
619 }
620 }
Chris Lattner2c64b7b2007-10-16 21:07:07 +0000621}
622
Steve Naroffb29b4272008-04-14 22:03:09 +0000623void RewriteObjC::RewriteTabs() {
Chris Lattnerf04da132007-10-24 17:06:59 +0000624 std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID);
625 const char *MainBufStart = MainBuf.first;
626 const char *MainBufEnd = MainBuf.second;
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +0000627
Chris Lattnerf04da132007-10-24 17:06:59 +0000628 // Loop over the whole file, looking for tabs.
629 for (const char *BufPtr = MainBufStart; BufPtr != MainBufEnd; ++BufPtr) {
630 if (*BufPtr != '\t')
631 continue;
632
633 // Okay, we found a tab. This tab will turn into at least one character,
634 // but it depends on which 'virtual column' it is in. Compute that now.
635 unsigned VCol = 0;
636 while (BufPtr-VCol != MainBufStart && BufPtr[-VCol-1] != '\t' &&
637 BufPtr[-VCol-1] != '\n' && BufPtr[-VCol-1] != '\r')
638 ++VCol;
639
640 // Okay, now that we know the virtual column, we know how many spaces to
641 // insert. We assume 8-character tab-stops.
642 unsigned Spaces = 8-(VCol & 7);
643
644 // Get the location of the tab.
645 SourceLocation TabLoc =
646 SourceLocation::getFileLoc(MainFileID, BufPtr-MainBufStart);
647
648 // Rewrite the single tab character into a sequence of spaces.
Chris Lattneraadaf782008-01-31 19:51:04 +0000649 ReplaceText(TabLoc, 1, " ", Spaces);
Chris Lattnerf04da132007-10-24 17:06:59 +0000650 }
Chris Lattner8a12c272007-10-11 18:38:32 +0000651}
652
Steve Naroffeb0646c2008-12-02 15:48:25 +0000653static std::string getIvarAccessString(ObjCInterfaceDecl *ClassDecl,
654 ObjCIvarDecl *OID) {
655 std::string S;
656 S = "((struct ";
657 S += ClassDecl->getIdentifier()->getName();
658 S += "_IMPL *)self)->";
659 S += OID->getNameAsCString();
660 return S;
661}
662
Steve Naroffa0876e82008-12-02 17:36:43 +0000663void RewriteObjC::RewritePropertyImplDecl(ObjCPropertyImplDecl *PID,
664 ObjCImplementationDecl *IMD,
665 ObjCCategoryImplDecl *CID) {
Steve Naroffd40910b2008-12-01 20:33:01 +0000666 SourceLocation startLoc = PID->getLocStart();
667 InsertText(startLoc, "// ", 3);
Steve Naroffeb0646c2008-12-02 15:48:25 +0000668 const char *startBuf = SM->getCharacterData(startLoc);
669 assert((*startBuf == '@') && "bogus @synthesize location");
670 const char *semiBuf = strchr(startBuf, ';');
671 assert((*semiBuf == ';') && "@synthesize: can't find ';'");
672 SourceLocation onePastSemiLoc = startLoc.getFileLocWithOffset(semiBuf-startBuf+1);
673
674 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Dynamic)
675 return; // FIXME: is this correct?
676
677 // Generate the 'getter' function.
Steve Naroffeb0646c2008-12-02 15:48:25 +0000678 ObjCPropertyDecl *PD = PID->getPropertyDecl();
Steve Naroffeb0646c2008-12-02 15:48:25 +0000679 ObjCInterfaceDecl *ClassDecl = PD->getGetterMethodDecl()->getClassInterface();
Steve Naroffeb0646c2008-12-02 15:48:25 +0000680 ObjCIvarDecl *OID = PID->getPropertyIvarDecl();
Steve Naroffdd2fdf12008-12-02 16:05:55 +0000681
682 if (!OID)
683 return;
684
685 std::string Getr;
686 RewriteObjCMethodDecl(PD->getGetterMethodDecl(), Getr);
687 Getr += "{ ";
688 // Synthesize an explicit cast to gain access to the ivar.
Steve Naroff3539cdb2008-12-02 17:54:50 +0000689 // FIXME: deal with code generation implications for various property
690 // attributes (copy, retain, nonatomic).
691 // See objc-act.c:objc_synthesize_new_getter() for details.
Steve Naroffdd2fdf12008-12-02 16:05:55 +0000692 Getr += "return " + getIvarAccessString(ClassDecl, OID);
693 Getr += "; }";
Steve Naroffeb0646c2008-12-02 15:48:25 +0000694 InsertText(onePastSemiLoc, Getr.c_str(), Getr.size());
Steve Naroffa0876e82008-12-02 17:36:43 +0000695
696 // Add the rewritten getter to trigger meta data generation. An alternate, and
697 // possibly cleaner approach is to hack RewriteObjCMethodsMetaData() to deal
698 // with properties explicitly. The following addInstanceMethod() required far
699 // less code change (and actually models what the rewriter is doing).
700 if (IMD)
701 IMD->addInstanceMethod(PD->getGetterMethodDecl());
702 else
703 CID->addInstanceMethod(PD->getGetterMethodDecl());
Steve Naroffeb0646c2008-12-02 15:48:25 +0000704
705 if (PD->isReadOnly())
706 return;
707
708 // Generate the 'setter' function.
709 std::string Setr;
710 RewriteObjCMethodDecl(PD->getSetterMethodDecl(), Setr);
Steve Naroffeb0646c2008-12-02 15:48:25 +0000711 Setr += "{ ";
Steve Naroffdd2fdf12008-12-02 16:05:55 +0000712 // Synthesize an explicit cast to initialize the ivar.
Steve Naroff3539cdb2008-12-02 17:54:50 +0000713 // FIXME: deal with code generation implications for various property
714 // attributes (copy, retain, nonatomic).
Steve Naroff15f081d2008-12-03 00:56:33 +0000715 // See objc-act.c:objc_synthesize_new_setter() for details.
Steve Naroffdd2fdf12008-12-02 16:05:55 +0000716 Setr += getIvarAccessString(ClassDecl, OID) + " = ";
Steve Narofff4312dc2008-12-11 19:29:16 +0000717 Setr += PD->getNameAsCString();
Steve Naroffdd2fdf12008-12-02 16:05:55 +0000718 Setr += "; }";
Steve Naroffeb0646c2008-12-02 15:48:25 +0000719 InsertText(onePastSemiLoc, Setr.c_str(), Setr.size());
Steve Naroffa0876e82008-12-02 17:36:43 +0000720
721 // Add the rewritten setter to trigger meta data generation.
722 if (IMD)
723 IMD->addInstanceMethod(PD->getSetterMethodDecl());
724 else
725 CID->addInstanceMethod(PD->getSetterMethodDecl());
Steve Naroffd40910b2008-12-01 20:33:01 +0000726}
Chris Lattner8a12c272007-10-11 18:38:32 +0000727
Steve Naroffb29b4272008-04-14 22:03:09 +0000728void RewriteObjC::RewriteForwardClassDecl(ObjCClassDecl *ClassDecl) {
Chris Lattnerf04da132007-10-24 17:06:59 +0000729 int numDecls = ClassDecl->getNumForwardDecls();
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000730 ObjCInterfaceDecl **ForwardDecls = ClassDecl->getForwardDecls();
Chris Lattnerf04da132007-10-24 17:06:59 +0000731
732 // Get the start location and compute the semi location.
733 SourceLocation startLoc = ClassDecl->getLocation();
734 const char *startBuf = SM->getCharacterData(startLoc);
735 const char *semiPtr = strchr(startBuf, ';');
736
737 // Translate to typedef's that forward reference structs with the same name
738 // as the class. As a convenience, we include the original declaration
739 // as a comment.
740 std::string typedefString;
741 typedefString += "// ";
Steve Naroff934f2762007-10-24 22:48:43 +0000742 typedefString.append(startBuf, semiPtr-startBuf+1);
743 typedefString += "\n";
744 for (int i = 0; i < numDecls; i++) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000745 ObjCInterfaceDecl *ForwardDecl = ForwardDecls[i];
Steve Naroff32174822007-11-09 12:50:28 +0000746 typedefString += "#ifndef _REWRITER_typedef_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000747 typedefString += ForwardDecl->getNameAsString();
Steve Naroff32174822007-11-09 12:50:28 +0000748 typedefString += "\n";
749 typedefString += "#define _REWRITER_typedef_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000750 typedefString += ForwardDecl->getNameAsString();
Steve Naroff32174822007-11-09 12:50:28 +0000751 typedefString += "\n";
Steve Naroff352336b2007-11-05 14:36:37 +0000752 typedefString += "typedef struct objc_object ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000753 typedefString += ForwardDecl->getNameAsString();
Steve Naroff32174822007-11-09 12:50:28 +0000754 typedefString += ";\n#endif\n";
Steve Naroff934f2762007-10-24 22:48:43 +0000755 }
756
757 // Replace the @class with typedefs corresponding to the classes.
Chris Lattneraadaf782008-01-31 19:51:04 +0000758 ReplaceText(startLoc, semiPtr-startBuf+1,
759 typedefString.c_str(), typedefString.size());
Chris Lattnerf04da132007-10-24 17:06:59 +0000760}
761
Steve Naroffb29b4272008-04-14 22:03:09 +0000762void RewriteObjC::RewriteMethodDeclaration(ObjCMethodDecl *Method) {
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000763 SourceLocation LocStart = Method->getLocStart();
764 SourceLocation LocEnd = Method->getLocEnd();
Steve Naroff423cb562007-10-30 13:30:57 +0000765
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000766 if (SM->getLineNumber(LocEnd) > SM->getLineNumber(LocStart)) {
Steve Naroff94ac21e2008-10-21 13:37:27 +0000767 InsertText(LocStart, "#if 0\n", 6);
768 ReplaceText(LocEnd, 1, ";\n#endif\n", 9);
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000769 } else {
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000770 InsertText(LocStart, "// ", 3);
Steve Naroff423cb562007-10-30 13:30:57 +0000771 }
772}
773
Steve Naroffb29b4272008-04-14 22:03:09 +0000774void RewriteObjC::RewriteProperties(unsigned nProperties, ObjCPropertyDecl **Properties)
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000775{
Chris Lattner55d13b42008-03-16 21:23:50 +0000776 for (unsigned i = 0; i < nProperties; i++) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000777 ObjCPropertyDecl *Property = Properties[i];
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000778 SourceLocation Loc = Property->getLocation();
779
Chris Lattneraadaf782008-01-31 19:51:04 +0000780 ReplaceText(Loc, 0, "// ", 3);
Fariborz Jahanian957cf652007-11-07 00:09:37 +0000781
782 // FIXME: handle properties that are declared across multiple lines.
783 }
784}
785
Steve Naroffb29b4272008-04-14 22:03:09 +0000786void RewriteObjC::RewriteCategoryDecl(ObjCCategoryDecl *CatDecl) {
Steve Naroff423cb562007-10-30 13:30:57 +0000787 SourceLocation LocStart = CatDecl->getLocStart();
788
789 // FIXME: handle category headers that are declared across multiple lines.
Chris Lattneraadaf782008-01-31 19:51:04 +0000790 ReplaceText(LocStart, 0, "// ", 3);
Steve Naroff423cb562007-10-30 13:30:57 +0000791
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000792 for (ObjCCategoryDecl::instmeth_iterator I = CatDecl->instmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000793 E = CatDecl->instmeth_end(); I != E; ++I)
794 RewriteMethodDeclaration(*I);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000795 for (ObjCCategoryDecl::classmeth_iterator I = CatDecl->classmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000796 E = CatDecl->classmeth_end(); I != E; ++I)
797 RewriteMethodDeclaration(*I);
798
Steve Naroff423cb562007-10-30 13:30:57 +0000799 // Lastly, comment out the @end.
Chris Lattneraadaf782008-01-31 19:51:04 +0000800 ReplaceText(CatDecl->getAtEndLoc(), 0, "// ", 3);
Steve Naroff423cb562007-10-30 13:30:57 +0000801}
802
Steve Naroffb29b4272008-04-14 22:03:09 +0000803void RewriteObjC::RewriteProtocolDecl(ObjCProtocolDecl *PDecl) {
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000804 std::pair<const char*, const char*> MainBuf = SM->getBufferData(MainFileID);
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000805
Steve Naroff752d6ef2007-10-30 16:42:30 +0000806 SourceLocation LocStart = PDecl->getLocStart();
807
808 // FIXME: handle protocol headers that are declared across multiple lines.
Chris Lattneraadaf782008-01-31 19:51:04 +0000809 ReplaceText(LocStart, 0, "// ", 3);
Steve Naroff752d6ef2007-10-30 16:42:30 +0000810
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000811 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000812 E = PDecl->instmeth_end(); I != E; ++I)
813 RewriteMethodDeclaration(*I);
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000814 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +0000815 E = PDecl->classmeth_end(); I != E; ++I)
816 RewriteMethodDeclaration(*I);
817
Steve Naroff752d6ef2007-10-30 16:42:30 +0000818 // Lastly, comment out the @end.
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000819 SourceLocation LocEnd = PDecl->getAtEndLoc();
Chris Lattneraadaf782008-01-31 19:51:04 +0000820 ReplaceText(LocEnd, 0, "// ", 3);
Steve Naroff8cc764c2007-11-14 15:03:57 +0000821
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000822 // Must comment out @optional/@required
823 const char *startBuf = SM->getCharacterData(LocStart);
824 const char *endBuf = SM->getCharacterData(LocEnd);
825 for (const char *p = startBuf; p < endBuf; p++) {
826 if (*p == '@' && !strncmp(p+1, "optional", strlen("optional"))) {
827 std::string CommentedOptional = "/* @optional */";
Steve Naroff8cc764c2007-11-14 15:03:57 +0000828 SourceLocation OptionalLoc = LocStart.getFileLocWithOffset(p-startBuf);
Chris Lattneraadaf782008-01-31 19:51:04 +0000829 ReplaceText(OptionalLoc, strlen("@optional"),
830 CommentedOptional.c_str(), CommentedOptional.size());
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000831
832 }
833 else if (*p == '@' && !strncmp(p+1, "required", strlen("required"))) {
834 std::string CommentedRequired = "/* @required */";
Steve Naroff8cc764c2007-11-14 15:03:57 +0000835 SourceLocation OptionalLoc = LocStart.getFileLocWithOffset(p-startBuf);
Chris Lattneraadaf782008-01-31 19:51:04 +0000836 ReplaceText(OptionalLoc, strlen("@required"),
837 CommentedRequired.c_str(), CommentedRequired.size());
Fariborz Jahanianb82b3ea2007-11-14 01:37:46 +0000838
839 }
840 }
Steve Naroff752d6ef2007-10-30 16:42:30 +0000841}
842
Steve Naroffb29b4272008-04-14 22:03:09 +0000843void RewriteObjC::RewriteForwardProtocolDecl(ObjCForwardProtocolDecl *PDecl) {
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000844 SourceLocation LocStart = PDecl->getLocation();
Steve Naroffb7fa9922007-11-14 03:37:28 +0000845 if (LocStart.isInvalid())
846 assert(false && "Invalid SourceLocation");
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000847 // FIXME: handle forward protocol that are declared across multiple lines.
Chris Lattneraadaf782008-01-31 19:51:04 +0000848 ReplaceText(LocStart, 0, "// ", 3);
Fariborz Jahaniand175ddf2007-11-14 00:42:16 +0000849}
850
Steve Naroffb29b4272008-04-14 22:03:09 +0000851void RewriteObjC::RewriteObjCMethodDecl(ObjCMethodDecl *OMD,
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000852 std::string &ResultStr) {
Steve Naroffced80a82008-10-30 12:09:33 +0000853 //fprintf(stderr,"In RewriteObjCMethodDecl\n");
Steve Naroff76e429d2008-07-16 14:40:40 +0000854 const FunctionType *FPRetType = 0;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000855 ResultStr += "\nstatic ";
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000856 if (OMD->getResultType()->isObjCQualifiedIdType())
Fariborz Jahanianc5692492007-12-17 21:03:50 +0000857 ResultStr += "id";
Steve Narofff4312dc2008-12-11 19:29:16 +0000858 else if (OMD->getResultType()->isFunctionPointerType() ||
859 OMD->getResultType()->isBlockPointerType()) {
Steve Naroff76e429d2008-07-16 14:40:40 +0000860 // needs special handling, since pointer-to-functions have special
861 // syntax (where a decaration models use).
862 QualType retType = OMD->getResultType();
Steve Narofff4312dc2008-12-11 19:29:16 +0000863 QualType PointeeTy;
864 if (const PointerType* PT = retType->getAsPointerType())
865 PointeeTy = PT->getPointeeType();
866 else if (const BlockPointerType *BPT = retType->getAsBlockPointerType())
867 PointeeTy = BPT->getPointeeType();
868 if ((FPRetType = PointeeTy->getAsFunctionType())) {
869 ResultStr += FPRetType->getResultType().getAsString();
870 ResultStr += "(*";
Steve Naroff76e429d2008-07-16 14:40:40 +0000871 }
872 } else
Fariborz Jahanianc5692492007-12-17 21:03:50 +0000873 ResultStr += OMD->getResultType().getAsString();
Fariborz Jahanian531a1ea2008-01-10 01:39:52 +0000874 ResultStr += " ";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000875
876 // Unique method name
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000877 std::string NameStr;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000878
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000879 if (OMD->isInstance())
880 NameStr += "_I_";
881 else
882 NameStr += "_C_";
883
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000884 NameStr += OMD->getClassInterface()->getNameAsString();
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000885 NameStr += "_";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000886
887 NamedDecl *MethodContext = OMD->getMethodContext();
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000888 if (ObjCCategoryImplDecl *CID =
889 dyn_cast<ObjCCategoryImplDecl>(MethodContext)) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000890 NameStr += CID->getNameAsString();
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000891 NameStr += "_";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000892 }
Steve Naroff563b8282008-04-04 22:23:44 +0000893 // Append selector names, replacing ':' with '_'
Chris Lattner077bf5e2008-11-24 03:33:13 +0000894 {
895 std::string selString = OMD->getSelector().getAsString();
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000896 int len = selString.size();
897 for (int i = 0; i < len; i++)
898 if (selString[i] == ':')
899 selString[i] = '_';
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000900 NameStr += selString;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000901 }
Fariborz Jahanianb7908b52007-11-13 21:02:00 +0000902 // Remember this name for metadata emission
903 MethodInternalNames[OMD] = NameStr;
904 ResultStr += NameStr;
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000905
906 // Rewrite arguments
907 ResultStr += "(";
908
909 // invisible arguments
910 if (OMD->isInstance()) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000911 QualType selfTy = Context->getObjCInterfaceType(OMD->getClassInterface());
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000912 selfTy = Context->getPointerType(selfTy);
Steve Naroff05b8c782008-03-12 00:25:36 +0000913 if (!LangOpts.Microsoft) {
914 if (ObjCSynthesizedStructs.count(OMD->getClassInterface()))
915 ResultStr += "struct ";
916 }
917 // When rewriting for Microsoft, explicitly omit the structure name.
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000918 ResultStr += OMD->getClassInterface()->getNameAsString();
Steve Naroff61ed9ca2008-03-10 23:16:54 +0000919 ResultStr += " *";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000920 }
921 else
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000922 ResultStr += Context->getObjCIdType().getAsString();
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000923
924 ResultStr += " self, ";
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000925 ResultStr += Context->getObjCSelType().getAsString();
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000926 ResultStr += " _cmd";
927
928 // Method arguments.
Chris Lattner58cce3b2008-03-16 01:07:14 +0000929 for (unsigned i = 0; i < OMD->getNumParams(); i++) {
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000930 ParmVarDecl *PDecl = OMD->getParamDecl(i);
931 ResultStr += ", ";
Steve Naroff543409e2008-04-18 21:13:19 +0000932 if (PDecl->getType()->isObjCQualifiedIdType()) {
933 ResultStr += "id ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000934 ResultStr += PDecl->getNameAsString();
Steve Naroff543409e2008-04-18 21:13:19 +0000935 } else {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +0000936 std::string Name = PDecl->getNameAsString();
Steve Naroff01f2ffa2008-12-11 21:05:33 +0000937 if (isTopLevelBlockPointerType(PDecl->getType())) {
Steve Naroffc8ad87b2008-10-30 14:45:29 +0000938 // Make sure we convert "t (^)(...)" to "t (*)(...)".
939 const BlockPointerType *BPT = PDecl->getType()->getAsBlockPointerType();
940 Context->getPointerType(BPT->getPointeeType()).getAsStringInternal(Name);
941 } else
942 PDecl->getType().getAsStringInternal(Name);
Steve Naroff543409e2008-04-18 21:13:19 +0000943 ResultStr += Name;
944 }
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000945 }
Fariborz Jahanian7c39ff72008-01-21 20:14:23 +0000946 if (OMD->isVariadic())
947 ResultStr += ", ...";
Fariborz Jahanian531a1ea2008-01-10 01:39:52 +0000948 ResultStr += ") ";
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000949
Steve Naroff76e429d2008-07-16 14:40:40 +0000950 if (FPRetType) {
951 ResultStr += ")"; // close the precedence "scope" for "*".
952
953 // Now, emit the argument types (if any).
954 if (const FunctionTypeProto *FT = dyn_cast<FunctionTypeProto>(FPRetType)) {
955 ResultStr += "(";
956 for (unsigned i = 0, e = FT->getNumArgs(); i != e; ++i) {
957 if (i) ResultStr += ", ";
958 std::string ParamStr = FT->getArgType(i).getAsString();
959 ResultStr += ParamStr;
960 }
961 if (FT->isVariadic()) {
962 if (FT->getNumArgs()) ResultStr += ", ";
963 ResultStr += "...";
964 }
965 ResultStr += ")";
966 } else {
967 ResultStr += "()";
968 }
969 }
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000970}
Steve Naroffb29b4272008-04-14 22:03:09 +0000971void RewriteObjC::RewriteImplementationDecl(NamedDecl *OID) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000972 ObjCImplementationDecl *IMD = dyn_cast<ObjCImplementationDecl>(OID);
973 ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(OID);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000974
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000975 if (IMD)
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000976 InsertText(IMD->getLocStart(), "// ", 3);
Fariborz Jahanian66d6b292007-11-13 20:04:28 +0000977 else
Chris Lattnerf3dd57e2008-01-31 19:42:41 +0000978 InsertText(CID->getLocStart(), "// ", 3);
Steve Narofface66252008-11-13 20:07:04 +0000979
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000980 for (ObjCCategoryImplDecl::instmeth_iterator
Chris Lattnerab4c4d52007-12-12 07:46:12 +0000981 I = IMD ? IMD->instmeth_begin() : CID->instmeth_begin(),
982 E = IMD ? IMD->instmeth_end() : CID->instmeth_end(); I != E; ++I) {
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000983 std::string ResultStr;
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000984 ObjCMethodDecl *OMD = *I;
985 RewriteObjCMethodDecl(OMD, ResultStr);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000986 SourceLocation LocStart = OMD->getLocStart();
987 SourceLocation LocEnd = OMD->getBody()->getLocStart();
988
989 const char *startBuf = SM->getCharacterData(LocStart);
990 const char *endBuf = SM->getCharacterData(LocEnd);
Chris Lattneraadaf782008-01-31 19:51:04 +0000991 ReplaceText(LocStart, endBuf-startBuf,
992 ResultStr.c_str(), ResultStr.size());
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000993 }
994
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000995 for (ObjCCategoryImplDecl::classmeth_iterator
Chris Lattnerab4c4d52007-12-12 07:46:12 +0000996 I = IMD ? IMD->classmeth_begin() : CID->classmeth_begin(),
997 E = IMD ? IMD->classmeth_end() : CID->classmeth_end(); I != E; ++I) {
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +0000998 std::string ResultStr;
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000999 ObjCMethodDecl *OMD = *I;
1000 RewriteObjCMethodDecl(OMD, ResultStr);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +00001001 SourceLocation LocStart = OMD->getLocStart();
1002 SourceLocation LocEnd = OMD->getBody()->getLocStart();
1003
1004 const char *startBuf = SM->getCharacterData(LocStart);
1005 const char *endBuf = SM->getCharacterData(LocEnd);
Chris Lattneraadaf782008-01-31 19:51:04 +00001006 ReplaceText(LocStart, endBuf-startBuf,
1007 ResultStr.c_str(), ResultStr.size());
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +00001008 }
Steve Naroffd40910b2008-12-01 20:33:01 +00001009 for (ObjCCategoryImplDecl::propimpl_iterator
1010 I = IMD ? IMD->propimpl_begin() : CID->propimpl_begin(),
1011 E = IMD ? IMD->propimpl_end() : CID->propimpl_end(); I != E; ++I) {
Steve Naroffa0876e82008-12-02 17:36:43 +00001012 RewritePropertyImplDecl(*I, IMD, CID);
Steve Naroffd40910b2008-12-01 20:33:01 +00001013 }
1014
Fariborz Jahanian66d6b292007-11-13 20:04:28 +00001015 if (IMD)
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001016 InsertText(IMD->getLocEnd(), "// ", 3);
Fariborz Jahanian66d6b292007-11-13 20:04:28 +00001017 else
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001018 InsertText(CID->getLocEnd(), "// ", 3);
Fariborz Jahanian48a0b6a2007-11-13 18:44:14 +00001019}
1020
Steve Naroffb29b4272008-04-14 22:03:09 +00001021void RewriteObjC::RewriteInterfaceDecl(ObjCInterfaceDecl *ClassDecl) {
Steve Narofff908a872007-10-30 02:23:23 +00001022 std::string ResultStr;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001023 if (!ObjCForwardDecls.count(ClassDecl)) {
Steve Naroff6c6a2db2007-11-01 03:35:41 +00001024 // we haven't seen a forward decl - generate a typedef.
Steve Naroff5086a8d2007-11-14 23:02:56 +00001025 ResultStr = "#ifndef _REWRITER_typedef_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001026 ResultStr += ClassDecl->getNameAsString();
Steve Naroff32174822007-11-09 12:50:28 +00001027 ResultStr += "\n";
1028 ResultStr += "#define _REWRITER_typedef_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001029 ResultStr += ClassDecl->getNameAsString();
Steve Naroff32174822007-11-09 12:50:28 +00001030 ResultStr += "\n";
Steve Naroff61ed9ca2008-03-10 23:16:54 +00001031 ResultStr += "typedef struct objc_object ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001032 ResultStr += ClassDecl->getNameAsString();
Steve Naroff32174822007-11-09 12:50:28 +00001033 ResultStr += ";\n#endif\n";
Steve Naroff6c6a2db2007-11-01 03:35:41 +00001034 // Mark this typedef as having been generated.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001035 ObjCForwardDecls.insert(ClassDecl);
Steve Naroff6c6a2db2007-11-01 03:35:41 +00001036 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001037 SynthesizeObjCInternalStruct(ClassDecl, ResultStr);
Steve Narofff908a872007-10-30 02:23:23 +00001038
Fariborz Jahanian957cf652007-11-07 00:09:37 +00001039 RewriteProperties(ClassDecl->getNumPropertyDecl(),
1040 ClassDecl->getPropertyDecl());
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001041 for (ObjCInterfaceDecl::instmeth_iterator I = ClassDecl->instmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +00001042 E = ClassDecl->instmeth_end(); I != E; ++I)
1043 RewriteMethodDeclaration(*I);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001044 for (ObjCInterfaceDecl::classmeth_iterator I = ClassDecl->classmeth_begin(),
Steve Naroff58dbdeb2007-12-14 23:37:57 +00001045 E = ClassDecl->classmeth_end(); I != E; ++I)
1046 RewriteMethodDeclaration(*I);
1047
Steve Naroff2feac5e2007-10-30 03:43:13 +00001048 // Lastly, comment out the @end.
Chris Lattneraadaf782008-01-31 19:51:04 +00001049 ReplaceText(ClassDecl->getAtEndLoc(), 0, "// ", 3);
Steve Naroffbef11852007-10-26 20:53:56 +00001050}
1051
Steve Naroffb619d952008-12-09 12:56:34 +00001052Stmt *RewriteObjC::RewritePropertySetter(BinaryOperator *BinOp, Expr *newStmt,
1053 SourceRange SrcRange) {
Steve Naroffc77a6362008-12-04 16:24:46 +00001054 // Synthesize a ObjCMessageExpr from a ObjCPropertyRefExpr.
1055 // This allows us to reuse all the fun and games in SynthMessageExpr().
1056 ObjCPropertyRefExpr *PropRefExpr = dyn_cast<ObjCPropertyRefExpr>(BinOp->getLHS());
1057 ObjCMessageExpr *MsgExpr;
1058 ObjCPropertyDecl *PDecl = PropRefExpr->getProperty();
1059 llvm::SmallVector<Expr *, 1> ExprVec;
1060 ExprVec.push_back(newStmt);
1061
Steve Naroff8599e7a2008-12-08 16:43:47 +00001062 Stmt *Receiver = PropRefExpr->getBase();
1063 ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(Receiver);
1064 if (PRE && PropGetters[PRE]) {
1065 // This allows us to handle chain/nested property getters.
1066 Receiver = PropGetters[PRE];
1067 }
1068 MsgExpr = new ObjCMessageExpr(dyn_cast<Expr>(Receiver),
Steve Naroffc77a6362008-12-04 16:24:46 +00001069 PDecl->getSetterName(), PDecl->getType(),
1070 PDecl->getSetterMethodDecl(),
1071 SourceLocation(), SourceLocation(),
1072 &ExprVec[0], 1);
1073 Stmt *ReplacingStmt = SynthMessageExpr(MsgExpr);
1074
1075 // Now do the actual rewrite.
Steve Naroffb619d952008-12-09 12:56:34 +00001076 ReplaceStmtWithRange(BinOp, ReplacingStmt, SrcRange);
Steve Naroffe58ee0c2008-12-10 14:53:27 +00001077 //delete BinOp;
Steve Naroffc77a6362008-12-04 16:24:46 +00001078 delete MsgExpr;
1079 return ReplacingStmt;
Steve Naroff15f081d2008-12-03 00:56:33 +00001080}
1081
Steve Naroffc77a6362008-12-04 16:24:46 +00001082Stmt *RewriteObjC::RewritePropertyGetter(ObjCPropertyRefExpr *PropRefExpr) {
Steve Naroff15f081d2008-12-03 00:56:33 +00001083 // Synthesize a ObjCMessageExpr from a ObjCPropertyRefExpr.
1084 // This allows us to reuse all the fun and games in SynthMessageExpr().
1085 ObjCMessageExpr *MsgExpr;
1086 ObjCPropertyDecl *PDecl = PropRefExpr->getProperty();
1087
Steve Naroff8599e7a2008-12-08 16:43:47 +00001088 Stmt *Receiver = PropRefExpr->getBase();
1089
1090 ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(Receiver);
1091 if (PRE && PropGetters[PRE]) {
1092 // This allows us to handle chain/nested property getters.
1093 Receiver = PropGetters[PRE];
1094 }
1095 MsgExpr = new ObjCMessageExpr(dyn_cast<Expr>(Receiver),
Steve Naroff15f081d2008-12-03 00:56:33 +00001096 PDecl->getGetterName(), PDecl->getType(),
1097 PDecl->getGetterMethodDecl(),
1098 SourceLocation(), SourceLocation(),
1099 0, 0);
1100
Steve Naroff4c3580e2008-12-04 23:50:32 +00001101 Stmt *ReplacingStmt = SynthMessageExpr(MsgExpr);
Steve Naroff8599e7a2008-12-08 16:43:47 +00001102
1103 if (!PropParentMap)
1104 PropParentMap = new ParentMap(CurrentBody);
1105
1106 Stmt *Parent = PropParentMap->getParent(PropRefExpr);
1107 if (Parent && isa<ObjCPropertyRefExpr>(Parent)) {
1108 // We stash away the ReplacingStmt since actually doing the
1109 // replacement/rewrite won't work for nested getters (e.g. obj.p.i)
1110 PropGetters[PropRefExpr] = ReplacingStmt;
1111 delete MsgExpr;
1112 return PropRefExpr; // return the original...
1113 } else {
1114 ReplaceStmt(PropRefExpr, ReplacingStmt);
1115 // delete PropRefExpr; elsewhere...
1116 delete MsgExpr;
1117 return ReplacingStmt;
1118 }
Steve Naroff15f081d2008-12-03 00:56:33 +00001119}
1120
Chris Lattner3b2c58c2008-05-23 20:40:52 +00001121Stmt *RewriteObjC::RewriteObjCIvarRefExpr(ObjCIvarRefExpr *IV,
1122 SourceLocation OrigStart) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001123 ObjCIvarDecl *D = IV->getDecl();
Steve Naroff54055232008-10-27 17:20:55 +00001124 if (CurMethodDef) {
Steve Naroff05b8c782008-03-12 00:25:36 +00001125 if (const PointerType *pType = IV->getBase()->getType()->getAsPointerType()) {
Steve Narofff0757612008-05-08 17:52:16 +00001126 ObjCInterfaceType *iFaceDecl = dyn_cast<ObjCInterfaceType>(pType->getPointeeType());
1127 // lookup which class implements the instance variable.
1128 ObjCInterfaceDecl *clsDeclared = 0;
1129 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), clsDeclared);
1130 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class");
1131
1132 // Synthesize an explicit cast to gain access to the ivar.
1133 std::string RecName = clsDeclared->getIdentifier()->getName();
1134 RecName += "_IMPL";
1135 IdentifierInfo *II = &Context->Idents.get(RecName.c_str());
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001136 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Ted Kremenekdf042e62008-09-05 01:34:33 +00001137 SourceLocation(), II);
Steve Narofff0757612008-05-08 17:52:16 +00001138 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
1139 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001140 CastExpr *castExpr = new CStyleCastExpr(castT, IV->getBase(), castT,
Steve Naroffb2f9e512008-11-03 23:29:32 +00001141 SourceLocation(), SourceLocation());
Steve Narofff0757612008-05-08 17:52:16 +00001142 // Don't forget the parens to enforce the proper binding.
Chris Lattner3b2c58c2008-05-23 20:40:52 +00001143 ParenExpr *PE = new ParenExpr(IV->getBase()->getLocStart(),
1144 IV->getBase()->getLocEnd(),
1145 castExpr);
Steve Narofff0757612008-05-08 17:52:16 +00001146 if (IV->isFreeIvar() &&
Steve Naroff54055232008-10-27 17:20:55 +00001147 CurMethodDef->getClassInterface() == iFaceDecl->getDecl()) {
Chris Lattner3b2c58c2008-05-23 20:40:52 +00001148 MemberExpr *ME = new MemberExpr(PE, true, D, IV->getLocation(),
1149 D->getType());
Steve Narofff0757612008-05-08 17:52:16 +00001150 ReplaceStmt(IV, ME);
Steve Naroff4c3580e2008-12-04 23:50:32 +00001151 // delete IV; leak for now, see RewritePropertySetter() usage for more info.
Steve Narofff0757612008-05-08 17:52:16 +00001152 return ME;
Steve Naroffc2a689b2007-11-15 11:33:00 +00001153 }
Chris Lattner3b2c58c2008-05-23 20:40:52 +00001154
1155 ReplaceStmt(IV->getBase(), PE);
1156 // Cannot delete IV->getBase(), since PE points to it.
1157 // Replace the old base with the cast. This is important when doing
1158 // embedded rewrites. For example, [newInv->_container addObject:0].
1159 IV->setBase(PE);
1160 return IV;
Steve Naroffc2a689b2007-11-15 11:33:00 +00001161 }
Steve Naroff84472a82008-04-18 21:55:08 +00001162 } else { // we are outside a method.
Steve Naroff9f525972008-05-06 23:20:07 +00001163 assert(!IV->isFreeIvar() && "Cannot have a free standing ivar outside a method");
1164
1165 // Explicit ivar refs need to have a cast inserted.
1166 // FIXME: consider sharing some of this code with the code above.
1167 if (const PointerType *pType = IV->getBase()->getType()->getAsPointerType()) {
Steve Narofff0757612008-05-08 17:52:16 +00001168 ObjCInterfaceType *iFaceDecl = dyn_cast<ObjCInterfaceType>(pType->getPointeeType());
Steve Naroff9f525972008-05-06 23:20:07 +00001169 // lookup which class implements the instance variable.
1170 ObjCInterfaceDecl *clsDeclared = 0;
Steve Narofff0757612008-05-08 17:52:16 +00001171 iFaceDecl->getDecl()->lookupInstanceVariable(D->getIdentifier(), clsDeclared);
Steve Naroff9f525972008-05-06 23:20:07 +00001172 assert(clsDeclared && "RewriteObjCIvarRefExpr(): Can't find class");
1173
1174 // Synthesize an explicit cast to gain access to the ivar.
1175 std::string RecName = clsDeclared->getIdentifier()->getName();
1176 RecName += "_IMPL";
1177 IdentifierInfo *II = &Context->Idents.get(RecName.c_str());
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001178 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Ted Kremenekdf042e62008-09-05 01:34:33 +00001179 SourceLocation(), II);
Steve Naroff9f525972008-05-06 23:20:07 +00001180 assert(RD && "RewriteObjCIvarRefExpr(): Can't find RecordDecl");
1181 QualType castT = Context->getPointerType(Context->getTagDeclType(RD));
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001182 CastExpr *castExpr = new CStyleCastExpr(castT, IV->getBase(), castT,
Steve Naroffb2f9e512008-11-03 23:29:32 +00001183 SourceLocation(), SourceLocation());
Steve Naroff9f525972008-05-06 23:20:07 +00001184 // Don't forget the parens to enforce the proper binding.
Chris Lattner8d366162008-05-28 16:38:23 +00001185 ParenExpr *PE = new ParenExpr(IV->getBase()->getLocStart(),
1186 IV->getBase()->getLocEnd(), castExpr);
Steve Naroff9f525972008-05-06 23:20:07 +00001187 ReplaceStmt(IV->getBase(), PE);
1188 // Cannot delete IV->getBase(), since PE points to it.
1189 // Replace the old base with the cast. This is important when doing
1190 // embedded rewrites. For example, [newInv->_container addObject:0].
1191 IV->setBase(PE);
1192 return IV;
1193 }
Steve Naroffc2a689b2007-11-15 11:33:00 +00001194 }
Steve Naroff84472a82008-04-18 21:55:08 +00001195 return IV;
Steve Naroff7e3411b2007-11-15 02:58:25 +00001196}
1197
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001198/// SynthCountByEnumWithState - To print:
1199/// ((unsigned int (*)
1200/// (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
1201/// (void *)objc_msgSend)((id)l_collection,
1202/// sel_registerName(
1203/// "countByEnumeratingWithState:objects:count:"),
1204/// &enumState,
1205/// (id *)items, (unsigned int)16)
1206///
Steve Naroffb29b4272008-04-14 22:03:09 +00001207void RewriteObjC::SynthCountByEnumWithState(std::string &buf) {
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001208 buf += "((unsigned int (*) (id, SEL, struct __objcFastEnumerationState *, "
1209 "id *, unsigned int))(void *)objc_msgSend)";
1210 buf += "\n\t\t";
1211 buf += "((id)l_collection,\n\t\t";
1212 buf += "sel_registerName(\"countByEnumeratingWithState:objects:count:\"),";
1213 buf += "\n\t\t";
1214 buf += "&enumState, "
1215 "(id *)items, (unsigned int)16)";
1216}
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001217
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001218/// RewriteBreakStmt - Rewrite for a break-stmt inside an ObjC2's foreach
1219/// statement to exit to its outer synthesized loop.
1220///
Steve Naroffb29b4272008-04-14 22:03:09 +00001221Stmt *RewriteObjC::RewriteBreakStmt(BreakStmt *S) {
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001222 if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1223 return S;
1224 // replace break with goto __break_label
1225 std::string buf;
1226
1227 SourceLocation startLoc = S->getLocStart();
1228 buf = "goto __break_label_";
1229 buf += utostr(ObjCBcLabelNo.back());
Chris Lattneraadaf782008-01-31 19:51:04 +00001230 ReplaceText(startLoc, strlen("break"), buf.c_str(), buf.size());
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001231
1232 return 0;
1233}
1234
1235/// RewriteContinueStmt - Rewrite for a continue-stmt inside an ObjC2's foreach
1236/// statement to continue with its inner synthesized loop.
1237///
Steve Naroffb29b4272008-04-14 22:03:09 +00001238Stmt *RewriteObjC::RewriteContinueStmt(ContinueStmt *S) {
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001239 if (Stmts.empty() || !isa<ObjCForCollectionStmt>(Stmts.back()))
1240 return S;
1241 // replace continue with goto __continue_label
1242 std::string buf;
1243
1244 SourceLocation startLoc = S->getLocStart();
1245 buf = "goto __continue_label_";
1246 buf += utostr(ObjCBcLabelNo.back());
Chris Lattneraadaf782008-01-31 19:51:04 +00001247 ReplaceText(startLoc, strlen("continue"), buf.c_str(), buf.size());
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001248
1249 return 0;
1250}
1251
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001252/// RewriteObjCForCollectionStmt - Rewriter for ObjC2's foreach statement.
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001253/// It rewrites:
1254/// for ( type elem in collection) { stmts; }
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00001255
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001256/// Into:
1257/// {
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001258/// type elem;
1259/// struct __objcFastEnumerationState enumState = { 0 };
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001260/// id items[16];
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001261/// id l_collection = (id)collection;
1262/// unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1263/// objects:items count:16];
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001264/// if (limit) {
1265/// unsigned long startMutations = *enumState.mutationsPtr;
1266/// do {
1267/// unsigned long counter = 0;
1268/// do {
1269/// if (startMutations != *enumState.mutationsPtr)
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001270/// objc_enumerationMutation(l_collection);
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001271/// elem = (type)enumState.itemsPtr[counter++];
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001272/// stmts;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001273/// __continue_label: ;
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001274/// } while (counter < limit);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001275/// } while (limit = [l_collection countByEnumeratingWithState:&enumState
1276/// objects:items count:16]);
1277/// elem = nil;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001278/// __break_label: ;
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001279/// }
1280/// else
1281/// elem = nil;
1282/// }
1283///
Steve Naroffb29b4272008-04-14 22:03:09 +00001284Stmt *RewriteObjC::RewriteObjCForCollectionStmt(ObjCForCollectionStmt *S,
Chris Lattner338d1e22008-01-31 05:10:40 +00001285 SourceLocation OrigEnd) {
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001286 assert(!Stmts.empty() && "ObjCForCollectionStmt - Statement stack empty");
1287 assert(isa<ObjCForCollectionStmt>(Stmts.back()) &&
1288 "ObjCForCollectionStmt Statement stack mismatch");
1289 assert(!ObjCBcLabelNo.empty() &&
1290 "ObjCForCollectionStmt - Label No stack empty");
1291
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001292 SourceLocation startLoc = S->getLocStart();
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001293 const char *startBuf = SM->getCharacterData(startLoc);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001294 const char *elementName;
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001295 std::string elementTypeAsString;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001296 std::string buf;
1297 buf = "\n{\n\t";
1298 if (DeclStmt *DS = dyn_cast<DeclStmt>(S->getElement())) {
1299 // type elem;
Ted Kremenek1ed8e2a2008-10-06 22:16:13 +00001300 ScopedDecl* D = DS->getSolitaryDecl();
1301 QualType ElementType = cast<ValueDecl>(D)->getType();
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001302 elementTypeAsString = ElementType.getAsString();
1303 buf += elementTypeAsString;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001304 buf += " ";
Chris Lattner8ec03f52008-11-24 03:54:41 +00001305 elementName = D->getNameAsCString();
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001306 buf += elementName;
1307 buf += ";\n\t";
1308 }
Chris Lattner06767512008-04-08 05:52:18 +00001309 else {
1310 DeclRefExpr *DR = cast<DeclRefExpr>(S->getElement());
Chris Lattner8ec03f52008-11-24 03:54:41 +00001311 elementName = DR->getDecl()->getNameAsCString();
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001312 elementTypeAsString
1313 = cast<ValueDecl>(DR->getDecl())->getType().getAsString();
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001314 }
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001315
1316 // struct __objcFastEnumerationState enumState = { 0 };
1317 buf += "struct __objcFastEnumerationState enumState = { 0 };\n\t";
1318 // id items[16];
1319 buf += "id items[16];\n\t";
1320 // id l_collection = (id)
1321 buf += "id l_collection = (id)";
Fariborz Jahanian75712282008-01-10 00:24:29 +00001322 // Find start location of 'collection' the hard way!
1323 const char *startCollectionBuf = startBuf;
1324 startCollectionBuf += 3; // skip 'for'
1325 startCollectionBuf = strchr(startCollectionBuf, '(');
1326 startCollectionBuf++; // skip '('
1327 // find 'in' and skip it.
1328 while (*startCollectionBuf != ' ' ||
1329 *(startCollectionBuf+1) != 'i' || *(startCollectionBuf+2) != 'n' ||
1330 (*(startCollectionBuf+3) != ' ' &&
1331 *(startCollectionBuf+3) != '[' && *(startCollectionBuf+3) != '('))
1332 startCollectionBuf++;
1333 startCollectionBuf += 3;
1334
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001335 // Replace: "for (type element in" with string constructed thus far.
Chris Lattneraadaf782008-01-31 19:51:04 +00001336 ReplaceText(startLoc, startCollectionBuf - startBuf,
1337 buf.c_str(), buf.size());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001338 // Replace ')' in for '(' type elem in collection ')' with ';'
Fariborz Jahanian75712282008-01-10 00:24:29 +00001339 SourceLocation rightParenLoc = S->getRParenLoc();
1340 const char *rparenBuf = SM->getCharacterData(rightParenLoc);
1341 SourceLocation lparenLoc = startLoc.getFileLocWithOffset(rparenBuf-startBuf);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001342 buf = ";\n\t";
1343
1344 // unsigned long limit = [l_collection countByEnumeratingWithState:&enumState
1345 // objects:items count:16];
1346 // which is synthesized into:
1347 // unsigned int limit =
1348 // ((unsigned int (*)
1349 // (id, SEL, struct __objcFastEnumerationState *, id *, unsigned int))
1350 // (void *)objc_msgSend)((id)l_collection,
1351 // sel_registerName(
1352 // "countByEnumeratingWithState:objects:count:"),
1353 // (struct __objcFastEnumerationState *)&state,
1354 // (id *)items, (unsigned int)16);
1355 buf += "unsigned long limit =\n\t\t";
1356 SynthCountByEnumWithState(buf);
1357 buf += ";\n\t";
1358 /// if (limit) {
1359 /// unsigned long startMutations = *enumState.mutationsPtr;
1360 /// do {
1361 /// unsigned long counter = 0;
1362 /// do {
1363 /// if (startMutations != *enumState.mutationsPtr)
1364 /// objc_enumerationMutation(l_collection);
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001365 /// elem = (type)enumState.itemsPtr[counter++];
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001366 buf += "if (limit) {\n\t";
1367 buf += "unsigned long startMutations = *enumState.mutationsPtr;\n\t";
1368 buf += "do {\n\t\t";
1369 buf += "unsigned long counter = 0;\n\t\t";
1370 buf += "do {\n\t\t\t";
1371 buf += "if (startMutations != *enumState.mutationsPtr)\n\t\t\t\t";
1372 buf += "objc_enumerationMutation(l_collection);\n\t\t\t";
1373 buf += elementName;
Fariborz Jahanian88f50f32008-01-09 18:15:42 +00001374 buf += " = (";
1375 buf += elementTypeAsString;
1376 buf += ")enumState.itemsPtr[counter++];";
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001377 // Replace ')' in for '(' type elem in collection ')' with all of these.
Chris Lattneraadaf782008-01-31 19:51:04 +00001378 ReplaceText(lparenLoc, 1, buf.c_str(), buf.size());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001379
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001380 /// __continue_label: ;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001381 /// } while (counter < limit);
1382 /// } while (limit = [l_collection countByEnumeratingWithState:&enumState
1383 /// objects:items count:16]);
1384 /// elem = nil;
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001385 /// __break_label: ;
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001386 /// }
1387 /// else
1388 /// elem = nil;
1389 /// }
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001390 ///
1391 buf = ";\n\t";
1392 buf += "__continue_label_";
1393 buf += utostr(ObjCBcLabelNo.back());
1394 buf += ": ;";
1395 buf += "\n\t\t";
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001396 buf += "} while (counter < limit);\n\t";
1397 buf += "} while (limit = ";
1398 SynthCountByEnumWithState(buf);
1399 buf += ");\n\t";
1400 buf += elementName;
1401 buf += " = nil;\n\t";
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001402 buf += "__break_label_";
1403 buf += utostr(ObjCBcLabelNo.back());
1404 buf += ": ;\n\t";
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001405 buf += "}\n\t";
1406 buf += "else\n\t\t";
1407 buf += elementName;
1408 buf += " = nil;\n";
1409 buf += "}\n";
Steve Naroff600e4e82008-07-21 18:26:02 +00001410
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001411 // Insert all these *after* the statement body.
Steve Naroff600e4e82008-07-21 18:26:02 +00001412 if (isa<CompoundStmt>(S->getBody())) {
1413 SourceLocation endBodyLoc = OrigEnd.getFileLocWithOffset(1);
1414 InsertText(endBodyLoc, buf.c_str(), buf.size());
1415 } else {
1416 /* Need to treat single statements specially. For example:
1417 *
1418 * for (A *a in b) if (stuff()) break;
1419 * for (A *a in b) xxxyy;
1420 *
1421 * The following code simply scans ahead to the semi to find the actual end.
1422 */
1423 const char *stmtBuf = SM->getCharacterData(OrigEnd);
1424 const char *semiBuf = strchr(stmtBuf, ';');
1425 assert(semiBuf && "Can't find ';'");
1426 SourceLocation endBodyLoc = OrigEnd.getFileLocWithOffset(semiBuf-stmtBuf+1);
1427 InsertText(endBodyLoc, buf.c_str(), buf.size());
1428 }
Fariborz Jahaniane8d1c052008-01-15 23:58:23 +00001429 Stmts.pop_back();
1430 ObjCBcLabelNo.pop_back();
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00001431 return 0;
Fariborz Jahanian10d24f02008-01-07 21:40:22 +00001432}
1433
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001434/// RewriteObjCSynchronizedStmt -
1435/// This routine rewrites @synchronized(expr) stmt;
1436/// into:
1437/// objc_sync_enter(expr);
1438/// @try stmt @finally { objc_sync_exit(expr); }
1439///
Steve Naroffb29b4272008-04-14 22:03:09 +00001440Stmt *RewriteObjC::RewriteObjCSynchronizedStmt(ObjCAtSynchronizedStmt *S) {
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001441 // Get the start location and compute the semi location.
1442 SourceLocation startLoc = S->getLocStart();
1443 const char *startBuf = SM->getCharacterData(startLoc);
1444
1445 assert((*startBuf == '@') && "bogus @synchronized location");
1446
1447 std::string buf;
Steve Naroff3498cc92008-08-21 13:03:03 +00001448 buf = "objc_sync_enter((id)";
1449 const char *lparenBuf = startBuf;
1450 while (*lparenBuf != '(') lparenBuf++;
1451 ReplaceText(startLoc, lparenBuf-startBuf+1, buf.c_str(), buf.size());
Steve Naroffc7089f12008-08-19 13:04:19 +00001452 // We can't use S->getSynchExpr()->getLocEnd() to find the end location, since
1453 // the sync expression is typically a message expression that's already
1454 // been rewritten! (which implies the SourceLocation's are invalid).
1455 SourceLocation endLoc = S->getSynchBody()->getLocStart();
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001456 const char *endBuf = SM->getCharacterData(endLoc);
Steve Naroffc7089f12008-08-19 13:04:19 +00001457 while (*endBuf != ')') endBuf--;
1458 SourceLocation rparenLoc = startLoc.getFileLocWithOffset(endBuf-startBuf);
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001459 buf = ");\n";
1460 // declare a new scope with two variables, _stack and _rethrow.
1461 buf += "/* @try scope begin */ \n{ struct _objc_exception_data {\n";
1462 buf += "int buf[18/*32-bit i386*/];\n";
1463 buf += "char *pointers[4];} _stack;\n";
1464 buf += "id volatile _rethrow = 0;\n";
1465 buf += "objc_exception_try_enter(&_stack);\n";
1466 buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
Chris Lattneraadaf782008-01-31 19:51:04 +00001467 ReplaceText(rparenLoc, 1, buf.c_str(), buf.size());
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001468 startLoc = S->getSynchBody()->getLocEnd();
1469 startBuf = SM->getCharacterData(startLoc);
1470
Steve Naroffc7089f12008-08-19 13:04:19 +00001471 assert((*startBuf == '}') && "bogus @synchronized block");
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001472 SourceLocation lastCurlyLoc = startLoc;
1473 buf = "}\nelse {\n";
1474 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1475 buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
Steve Naroffb2a39452008-07-16 19:47:39 +00001476 buf += " objc_sync_exit(";
Douglas Gregor6eec8e82008-10-28 15:36:24 +00001477 Expr *syncExpr = new CStyleCastExpr(Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00001478 S->getSynchExpr(),
1479 Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00001480 SourceLocation(), SourceLocation());
Ted Kremeneka95d3752008-09-13 05:16:45 +00001481 std::string syncExprBufS;
1482 llvm::raw_string_ostream syncExprBuf(syncExprBufS);
Steve Naroff3498cc92008-08-21 13:03:03 +00001483 syncExpr->printPretty(syncExprBuf);
Steve Naroffb2a39452008-07-16 19:47:39 +00001484 buf += syncExprBuf.str();
1485 buf += ");\n";
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001486 buf += " if (_rethrow) objc_exception_throw(_rethrow);\n";
1487 buf += "}\n";
1488 buf += "}";
1489
Chris Lattneraadaf782008-01-31 19:51:04 +00001490 ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size());
Fariborz Jahaniana0f55792008-01-29 22:59:37 +00001491 return 0;
1492}
1493
Steve Naroff8c565152008-12-05 17:03:39 +00001494void RewriteObjC::WarnAboutReturnGotoContinueOrBreakStmts(Stmt *S) {
1495 // Perform a bottom up traversal of all children.
1496 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
1497 CI != E; ++CI)
1498 if (*CI)
1499 WarnAboutReturnGotoContinueOrBreakStmts(*CI);
1500
1501 if (isa<ReturnStmt>(S) || isa<ContinueStmt>(S) ||
1502 isa<BreakStmt>(S) || isa<GotoStmt>(S)) {
1503 Diags.Report(Context->getFullLoc(S->getLocStart()),
1504 TryFinallyContainsReturnDiag);
1505 }
1506 return;
1507}
1508
Steve Naroffb29b4272008-04-14 22:03:09 +00001509Stmt *RewriteObjC::RewriteObjCTryStmt(ObjCAtTryStmt *S) {
Steve Naroff75730982007-11-07 04:08:17 +00001510 // Get the start location and compute the semi location.
1511 SourceLocation startLoc = S->getLocStart();
1512 const char *startBuf = SM->getCharacterData(startLoc);
1513
1514 assert((*startBuf == '@') && "bogus @try location");
1515
1516 std::string buf;
1517 // declare a new scope with two variables, _stack and _rethrow.
1518 buf = "/* @try scope begin */ { struct _objc_exception_data {\n";
1519 buf += "int buf[18/*32-bit i386*/];\n";
1520 buf += "char *pointers[4];} _stack;\n";
1521 buf += "id volatile _rethrow = 0;\n";
1522 buf += "objc_exception_try_enter(&_stack);\n";
Steve Naroff21867b12007-11-07 18:43:40 +00001523 buf += "if (!_setjmp(_stack.buf)) /* @try block continue */\n";
Steve Naroff75730982007-11-07 04:08:17 +00001524
Chris Lattneraadaf782008-01-31 19:51:04 +00001525 ReplaceText(startLoc, 4, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001526
1527 startLoc = S->getTryBody()->getLocEnd();
1528 startBuf = SM->getCharacterData(startLoc);
1529
1530 assert((*startBuf == '}') && "bogus @try block");
Steve Naroffc9ba1722008-07-16 15:31:30 +00001531
Steve Naroff75730982007-11-07 04:08:17 +00001532 SourceLocation lastCurlyLoc = startLoc;
Steve Naroffc9ba1722008-07-16 15:31:30 +00001533 ObjCAtCatchStmt *catchList = S->getCatchStmts();
1534 if (catchList) {
1535 startLoc = startLoc.getFileLocWithOffset(1);
1536 buf = " /* @catch begin */ else {\n";
1537 buf += " id _caught = objc_exception_extract(&_stack);\n";
1538 buf += " objc_exception_try_enter (&_stack);\n";
1539 buf += " if (_setjmp(_stack.buf))\n";
1540 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1541 buf += " else { /* @catch continue */";
1542
1543 InsertText(startLoc, buf.c_str(), buf.size());
Steve Naroff8bd3dc62008-09-09 19:59:12 +00001544 } else { /* no catch list */
1545 buf = "}\nelse {\n";
1546 buf += " _rethrow = objc_exception_extract(&_stack);\n";
1547 buf += "}";
1548 ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size());
Steve Naroffc9ba1722008-07-16 15:31:30 +00001549 }
Steve Naroff75730982007-11-07 04:08:17 +00001550 bool sawIdTypedCatch = false;
1551 Stmt *lastCatchBody = 0;
Steve Naroff75730982007-11-07 04:08:17 +00001552 while (catchList) {
1553 Stmt *catchStmt = catchList->getCatchParamStmt();
1554
1555 if (catchList == S->getCatchStmts())
1556 buf = "if ("; // we are generating code for the first catch clause
1557 else
1558 buf = "else if (";
1559 startLoc = catchList->getLocStart();
1560 startBuf = SM->getCharacterData(startLoc);
1561
1562 assert((*startBuf == '@') && "bogus @catch location");
1563
1564 const char *lParenLoc = strchr(startBuf, '(');
1565
Steve Naroffbe4b3332008-02-01 22:08:12 +00001566 if (catchList->hasEllipsis()) {
Steve Naroffe12e6922008-02-01 20:02:07 +00001567 // Now rewrite the body...
1568 lastCatchBody = catchList->getCatchBody();
Steve Naroffe12e6922008-02-01 20:02:07 +00001569 SourceLocation bodyLoc = lastCatchBody->getLocStart();
1570 const char *bodyBuf = SM->getCharacterData(bodyLoc);
Chris Lattner06767512008-04-08 05:52:18 +00001571 assert(*SM->getCharacterData(catchList->getRParenLoc()) == ')' &&
1572 "bogus @catch paren location");
Steve Naroffe12e6922008-02-01 20:02:07 +00001573 assert((*bodyBuf == '{') && "bogus @catch body location");
1574
1575 buf += "1) { id _tmp = _caught;";
1576 Rewrite.ReplaceText(startLoc, bodyBuf-startBuf+1,
1577 buf.c_str(), buf.size());
1578 } else if (DeclStmt *declStmt = dyn_cast<DeclStmt>(catchStmt)) {
Ted Kremenek50a25e22008-10-06 22:39:38 +00001579 QualType t = dyn_cast<ValueDecl>(declStmt->getSolitaryDecl())->getType();
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001580 if (t == Context->getObjCIdType()) {
Steve Naroff75730982007-11-07 04:08:17 +00001581 buf += "1) { ";
Chris Lattneraadaf782008-01-31 19:51:04 +00001582 ReplaceText(startLoc, lParenLoc-startBuf+1, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001583 sawIdTypedCatch = true;
1584 } else if (const PointerType *pType = t->getAsPointerType()) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001585 ObjCInterfaceType *cls; // Should be a pointer to a class.
Steve Naroff75730982007-11-07 04:08:17 +00001586
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001587 cls = dyn_cast<ObjCInterfaceType>(pType->getPointeeType().getTypePtr());
Steve Naroff75730982007-11-07 04:08:17 +00001588 if (cls) {
Steve Naroff21867b12007-11-07 18:43:40 +00001589 buf += "objc_exception_match((struct objc_class *)objc_getClass(\"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001590 buf += cls->getDecl()->getNameAsString();
Steve Naroff21867b12007-11-07 18:43:40 +00001591 buf += "\"), (struct objc_object *)_caught)) { ";
Chris Lattneraadaf782008-01-31 19:51:04 +00001592 ReplaceText(startLoc, lParenLoc-startBuf+1, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001593 }
1594 }
1595 // Now rewrite the body...
1596 lastCatchBody = catchList->getCatchBody();
1597 SourceLocation rParenLoc = catchList->getRParenLoc();
1598 SourceLocation bodyLoc = lastCatchBody->getLocStart();
1599 const char *bodyBuf = SM->getCharacterData(bodyLoc);
1600 const char *rParenBuf = SM->getCharacterData(rParenLoc);
1601 assert((*rParenBuf == ')') && "bogus @catch paren location");
1602 assert((*bodyBuf == '{') && "bogus @catch body location");
1603
1604 buf = " = _caught;";
1605 // Here we replace ") {" with "= _caught;" (which initializes and
1606 // declares the @catch parameter).
Chris Lattneraadaf782008-01-31 19:51:04 +00001607 ReplaceText(rParenLoc, bodyBuf-rParenBuf+1, buf.c_str(), buf.size());
Steve Naroff2bd03922007-11-07 15:32:26 +00001608 } else if (!isa<NullStmt>(catchStmt)) {
Steve Naroff75730982007-11-07 04:08:17 +00001609 assert(false && "@catch rewrite bug");
Steve Naroff2bd03922007-11-07 15:32:26 +00001610 }
Steve Naroffe12e6922008-02-01 20:02:07 +00001611 // make sure all the catch bodies get rewritten!
Steve Naroff75730982007-11-07 04:08:17 +00001612 catchList = catchList->getNextCatchStmt();
1613 }
1614 // Complete the catch list...
1615 if (lastCatchBody) {
1616 SourceLocation bodyLoc = lastCatchBody->getLocEnd();
Chris Lattner06767512008-04-08 05:52:18 +00001617 assert(*SM->getCharacterData(bodyLoc) == '}' &&
1618 "bogus @catch body location");
Steve Naroff75730982007-11-07 04:08:17 +00001619
Steve Naroff378f47a2008-09-11 15:29:03 +00001620 // Insert the last (implicit) else clause *before* the right curly brace.
1621 bodyLoc = bodyLoc.getFileLocWithOffset(-1);
1622 buf = "} /* last catch end */\n";
1623 buf += "else {\n";
1624 buf += " _rethrow = _caught;\n";
1625 buf += " objc_exception_try_exit(&_stack);\n";
1626 buf += "} } /* @catch end */\n";
1627 if (!S->getFinallyStmt())
1628 buf += "}\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001629 InsertText(bodyLoc, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001630
1631 // Set lastCurlyLoc
1632 lastCurlyLoc = lastCatchBody->getLocEnd();
1633 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001634 if (ObjCAtFinallyStmt *finalStmt = S->getFinallyStmt()) {
Steve Naroff75730982007-11-07 04:08:17 +00001635 startLoc = finalStmt->getLocStart();
1636 startBuf = SM->getCharacterData(startLoc);
1637 assert((*startBuf == '@') && "bogus @finally start");
1638
1639 buf = "/* @finally */";
Chris Lattneraadaf782008-01-31 19:51:04 +00001640 ReplaceText(startLoc, 8, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001641
1642 Stmt *body = finalStmt->getFinallyBody();
1643 SourceLocation startLoc = body->getLocStart();
1644 SourceLocation endLoc = body->getLocEnd();
Chris Lattner06767512008-04-08 05:52:18 +00001645 assert(*SM->getCharacterData(startLoc) == '{' &&
1646 "bogus @finally body location");
1647 assert(*SM->getCharacterData(endLoc) == '}' &&
1648 "bogus @finally body location");
Steve Naroff75730982007-11-07 04:08:17 +00001649
1650 startLoc = startLoc.getFileLocWithOffset(1);
1651 buf = " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001652 InsertText(startLoc, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001653 endLoc = endLoc.getFileLocWithOffset(-1);
1654 buf = " if (_rethrow) objc_exception_throw(_rethrow);\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001655 InsertText(endLoc, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001656
1657 // Set lastCurlyLoc
1658 lastCurlyLoc = body->getLocEnd();
Steve Naroff8c565152008-12-05 17:03:39 +00001659
1660 // Now check for any return/continue/go statements within the @try.
1661 WarnAboutReturnGotoContinueOrBreakStmts(S->getTryBody());
Steve Naroff378f47a2008-09-11 15:29:03 +00001662 } else { /* no finally clause - make sure we synthesize an implicit one */
1663 buf = "{ /* implicit finally clause */\n";
1664 buf += " if (!_rethrow) objc_exception_try_exit(&_stack);\n";
1665 buf += " if (_rethrow) objc_exception_throw(_rethrow);\n";
1666 buf += "}";
1667 ReplaceText(lastCurlyLoc, 1, buf.c_str(), buf.size());
Steve Naroff75730982007-11-07 04:08:17 +00001668 }
1669 // Now emit the final closing curly brace...
1670 lastCurlyLoc = lastCurlyLoc.getFileLocWithOffset(1);
1671 buf = " } /* @try scope end */\n";
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001672 InsertText(lastCurlyLoc, buf.c_str(), buf.size());
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001673 return 0;
1674}
1675
Steve Naroffb29b4272008-04-14 22:03:09 +00001676Stmt *RewriteObjC::RewriteObjCCatchStmt(ObjCAtCatchStmt *S) {
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001677 return 0;
1678}
1679
Steve Naroffb29b4272008-04-14 22:03:09 +00001680Stmt *RewriteObjC::RewriteObjCFinallyStmt(ObjCAtFinallyStmt *S) {
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001681 return 0;
1682}
1683
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001684// This can't be done with ReplaceStmt(S, ThrowExpr), since
Steve Naroff2bd03922007-11-07 15:32:26 +00001685// the throw expression is typically a message expression that's already
1686// been rewritten! (which implies the SourceLocation's are invalid).
Steve Naroffb29b4272008-04-14 22:03:09 +00001687Stmt *RewriteObjC::RewriteObjCThrowStmt(ObjCAtThrowStmt *S) {
Steve Naroff2bd03922007-11-07 15:32:26 +00001688 // Get the start location and compute the semi location.
1689 SourceLocation startLoc = S->getLocStart();
1690 const char *startBuf = SM->getCharacterData(startLoc);
1691
1692 assert((*startBuf == '@') && "bogus @throw location");
1693
1694 std::string buf;
1695 /* void objc_exception_throw(id) __attribute__((noreturn)); */
Steve Naroff20ebf8f2008-01-19 00:42:38 +00001696 if (S->getThrowExpr())
1697 buf = "objc_exception_throw(";
1698 else // add an implicit argument
1699 buf = "objc_exception_throw(_caught";
Steve Naroff4ba0acb2008-07-25 15:41:30 +00001700
1701 // handle "@ throw" correctly.
1702 const char *wBuf = strchr(startBuf, 'w');
1703 assert((*wBuf == 'w') && "@throw: can't find 'w'");
1704 ReplaceText(startLoc, wBuf-startBuf+1, buf.c_str(), buf.size());
1705
Steve Naroff2bd03922007-11-07 15:32:26 +00001706 const char *semiBuf = strchr(startBuf, ';');
1707 assert((*semiBuf == ';') && "@throw: can't find ';'");
1708 SourceLocation semiLoc = startLoc.getFileLocWithOffset(semiBuf-startBuf);
1709 buf = ");";
Chris Lattneraadaf782008-01-31 19:51:04 +00001710 ReplaceText(semiLoc, 1, buf.c_str(), buf.size());
Steve Naroff2bd03922007-11-07 15:32:26 +00001711 return 0;
1712}
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00001713
Steve Naroffb29b4272008-04-14 22:03:09 +00001714Stmt *RewriteObjC::RewriteAtEncode(ObjCEncodeExpr *Exp) {
Chris Lattner01c57482007-10-17 22:35:30 +00001715 // Create a new string expression.
1716 QualType StrType = Context->getPointerType(Context->CharTy);
Anders Carlsson85f9bce2007-10-29 05:01:08 +00001717 std::string StrEncoding;
Daniel Dunbar0d504c12008-10-17 20:21:44 +00001718 Context->getObjCEncodingForType(Exp->getEncodedType(), StrEncoding);
Anders Carlsson85f9bce2007-10-29 05:01:08 +00001719 Expr *Replacement = new StringLiteral(StrEncoding.c_str(),
1720 StrEncoding.length(), false, StrType,
Chris Lattner01c57482007-10-17 22:35:30 +00001721 SourceLocation(), SourceLocation());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001722 ReplaceStmt(Exp, Replacement);
Chris Lattnere365c502007-11-30 22:25:36 +00001723
Chris Lattner07506182007-11-30 22:53:43 +00001724 // Replace this subexpr in the parent.
Steve Naroff4c3580e2008-12-04 23:50:32 +00001725 // delete Exp; leak for now, see RewritePropertySetter() usage for more info.
Chris Lattnere64b7772007-10-24 16:57:36 +00001726 return Replacement;
Chris Lattner311ff022007-10-16 22:36:42 +00001727}
1728
Steve Naroffb29b4272008-04-14 22:03:09 +00001729Stmt *RewriteObjC::RewriteAtSelector(ObjCSelectorExpr *Exp) {
Steve Naroffb42f8412007-11-05 14:50:49 +00001730 assert(SelGetUidFunctionDecl && "Can't find sel_registerName() decl");
1731 // Create a call to sel_registerName("selName").
1732 llvm::SmallVector<Expr*, 8> SelExprs;
1733 QualType argType = Context->getPointerType(Context->CharTy);
Chris Lattner077bf5e2008-11-24 03:33:13 +00001734 SelExprs.push_back(new StringLiteral(Exp->getSelector().getAsString().c_str(),
1735 Exp->getSelector().getAsString().size(),
Steve Naroffb42f8412007-11-05 14:50:49 +00001736 false, argType, SourceLocation(),
1737 SourceLocation()));
1738 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
1739 &SelExprs[0], SelExprs.size());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00001740 ReplaceStmt(Exp, SelExp);
Steve Naroff4c3580e2008-12-04 23:50:32 +00001741 // delete Exp; leak for now, see RewritePropertySetter() usage for more info.
Steve Naroffb42f8412007-11-05 14:50:49 +00001742 return SelExp;
1743}
1744
Steve Naroffb29b4272008-04-14 22:03:09 +00001745CallExpr *RewriteObjC::SynthesizeCallToFunctionDecl(
Steve Naroff934f2762007-10-24 22:48:43 +00001746 FunctionDecl *FD, Expr **args, unsigned nargs) {
Steve Naroffebf2b562007-10-23 23:50:29 +00001747 // Get the type, we will need to reference it in a couple spots.
Steve Naroff934f2762007-10-24 22:48:43 +00001748 QualType msgSendType = FD->getType();
Steve Naroffebf2b562007-10-23 23:50:29 +00001749
1750 // Create a reference to the objc_msgSend() declaration.
Steve Naroff934f2762007-10-24 22:48:43 +00001751 DeclRefExpr *DRE = new DeclRefExpr(FD, msgSendType, SourceLocation());
Steve Naroffebf2b562007-10-23 23:50:29 +00001752
1753 // Now, we cast the reference to a pointer to the objc_msgSend type.
Chris Lattnerf04da132007-10-24 17:06:59 +00001754 QualType pToFunc = Context->getPointerType(msgSendType);
Douglas Gregoreb8f3062008-11-12 17:17:38 +00001755 ImplicitCastExpr *ICE = new ImplicitCastExpr(pToFunc, DRE,
1756 /*isLvalue=*/false);
Steve Naroffebf2b562007-10-23 23:50:29 +00001757
1758 const FunctionType *FT = msgSendType->getAsFunctionType();
Chris Lattnere64b7772007-10-24 16:57:36 +00001759
Steve Naroff934f2762007-10-24 22:48:43 +00001760 return new CallExpr(ICE, args, nargs, FT->getResultType(), SourceLocation());
1761}
1762
Steve Naroffd5255f52007-11-01 13:24:47 +00001763static bool scanForProtocolRefs(const char *startBuf, const char *endBuf,
1764 const char *&startRef, const char *&endRef) {
1765 while (startBuf < endBuf) {
1766 if (*startBuf == '<')
1767 startRef = startBuf; // mark the start.
1768 if (*startBuf == '>') {
Steve Naroff32174822007-11-09 12:50:28 +00001769 if (startRef && *startRef == '<') {
1770 endRef = startBuf; // mark the end.
1771 return true;
1772 }
1773 return false;
Steve Naroffd5255f52007-11-01 13:24:47 +00001774 }
1775 startBuf++;
1776 }
1777 return false;
1778}
1779
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001780static void scanToNextArgument(const char *&argRef) {
1781 int angle = 0;
1782 while (*argRef != ')' && (*argRef != ',' || angle > 0)) {
1783 if (*argRef == '<')
1784 angle++;
1785 else if (*argRef == '>')
1786 angle--;
1787 argRef++;
1788 }
1789 assert(angle == 0 && "scanToNextArgument - bad protocol type syntax");
1790}
Fariborz Jahanian291e04b2007-12-11 23:04:08 +00001791
Steve Naroffb29b4272008-04-14 22:03:09 +00001792bool RewriteObjC::needToScanForQualifiers(QualType T) {
Fariborz Jahanianc5692492007-12-17 21:03:50 +00001793
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001794 if (T->isObjCQualifiedIdType())
Fariborz Jahanianc5692492007-12-17 21:03:50 +00001795 return true;
1796
Steve Naroffd5255f52007-11-01 13:24:47 +00001797 if (const PointerType *pType = T->getAsPointerType()) {
Steve Naroff9165ad32007-10-31 04:38:33 +00001798 Type *pointeeType = pType->getPointeeType().getTypePtr();
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001799 if (isa<ObjCQualifiedInterfaceType>(pointeeType))
Steve Naroff9165ad32007-10-31 04:38:33 +00001800 return true; // we have "Class <Protocol> *".
1801 }
Steve Naroffd5255f52007-11-01 13:24:47 +00001802 return false;
1803}
1804
Steve Naroff4f95b752008-07-29 18:15:38 +00001805void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Expr *E) {
1806 QualType Type = E->getType();
1807 if (needToScanForQualifiers(Type)) {
Steve Naroffcda658e2008-11-19 21:15:47 +00001808 SourceLocation Loc, EndLoc;
1809
1810 if (const CStyleCastExpr *ECE = dyn_cast<CStyleCastExpr>(E)) {
1811 Loc = ECE->getLParenLoc();
1812 EndLoc = ECE->getRParenLoc();
1813 } else {
1814 Loc = E->getLocStart();
1815 EndLoc = E->getLocEnd();
1816 }
1817 // This will defend against trying to rewrite synthesized expressions.
1818 if (Loc.isInvalid() || EndLoc.isInvalid())
1819 return;
1820
Steve Naroff4f95b752008-07-29 18:15:38 +00001821 const char *startBuf = SM->getCharacterData(Loc);
Steve Naroffcda658e2008-11-19 21:15:47 +00001822 const char *endBuf = SM->getCharacterData(EndLoc);
Steve Naroff4f95b752008-07-29 18:15:38 +00001823 const char *startRef = 0, *endRef = 0;
1824 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
1825 // Get the locations of the startRef, endRef.
1826 SourceLocation LessLoc = Loc.getFileLocWithOffset(startRef-startBuf);
1827 SourceLocation GreaterLoc = Loc.getFileLocWithOffset(endRef-startBuf+1);
1828 // Comment out the protocol references.
1829 InsertText(LessLoc, "/*", 2);
1830 InsertText(GreaterLoc, "*/", 2);
1831 }
1832 }
1833}
1834
Steve Naroffb29b4272008-04-14 22:03:09 +00001835void RewriteObjC::RewriteObjCQualifiedInterfaceTypes(Decl *Dcl) {
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001836 SourceLocation Loc;
1837 QualType Type;
1838 const FunctionTypeProto *proto = 0;
1839 if (VarDecl *VD = dyn_cast<VarDecl>(Dcl)) {
1840 Loc = VD->getLocation();
1841 Type = VD->getType();
1842 }
1843 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Dcl)) {
1844 Loc = FD->getLocation();
1845 // Check for ObjC 'id' and class types that have been adorned with protocol
1846 // information (id<p>, C<p>*). The protocol references need to be rewritten!
1847 const FunctionType *funcType = FD->getType()->getAsFunctionType();
1848 assert(funcType && "missing function type");
1849 proto = dyn_cast<FunctionTypeProto>(funcType);
1850 if (!proto)
1851 return;
1852 Type = proto->getResultType();
1853 }
1854 else
1855 return;
Steve Naroffd5255f52007-11-01 13:24:47 +00001856
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001857 if (needToScanForQualifiers(Type)) {
Steve Naroffd5255f52007-11-01 13:24:47 +00001858 // Since types are unique, we need to scan the buffer.
Steve Naroffd5255f52007-11-01 13:24:47 +00001859
1860 const char *endBuf = SM->getCharacterData(Loc);
1861 const char *startBuf = endBuf;
Steve Naroff6cafbf22008-05-31 05:02:17 +00001862 while (*startBuf != ';' && *startBuf != '<' && startBuf != MainFileStart)
Steve Naroffd5255f52007-11-01 13:24:47 +00001863 startBuf--; // scan backward (from the decl location) for return type.
1864 const char *startRef = 0, *endRef = 0;
1865 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
1866 // Get the locations of the startRef, endRef.
1867 SourceLocation LessLoc = Loc.getFileLocWithOffset(startRef-endBuf);
1868 SourceLocation GreaterLoc = Loc.getFileLocWithOffset(endRef-endBuf+1);
1869 // Comment out the protocol references.
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001870 InsertText(LessLoc, "/*", 2);
1871 InsertText(GreaterLoc, "*/", 2);
Steve Naroff9165ad32007-10-31 04:38:33 +00001872 }
1873 }
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001874 if (!proto)
1875 return; // most likely, was a variable
Steve Naroffd5255f52007-11-01 13:24:47 +00001876 // Now check arguments.
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001877 const char *startBuf = SM->getCharacterData(Loc);
1878 const char *startFuncBuf = startBuf;
Steve Naroffd5255f52007-11-01 13:24:47 +00001879 for (unsigned i = 0; i < proto->getNumArgs(); i++) {
1880 if (needToScanForQualifiers(proto->getArgType(i))) {
1881 // Since types are unique, we need to scan the buffer.
Steve Naroffd5255f52007-11-01 13:24:47 +00001882
Steve Naroffd5255f52007-11-01 13:24:47 +00001883 const char *endBuf = startBuf;
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001884 // scan forward (from the decl location) for argument types.
1885 scanToNextArgument(endBuf);
Steve Naroffd5255f52007-11-01 13:24:47 +00001886 const char *startRef = 0, *endRef = 0;
1887 if (scanForProtocolRefs(startBuf, endBuf, startRef, endRef)) {
1888 // Get the locations of the startRef, endRef.
Fariborz Jahanian291e04b2007-12-11 23:04:08 +00001889 SourceLocation LessLoc =
1890 Loc.getFileLocWithOffset(startRef-startFuncBuf);
1891 SourceLocation GreaterLoc =
1892 Loc.getFileLocWithOffset(endRef-startFuncBuf+1);
Steve Naroffd5255f52007-11-01 13:24:47 +00001893 // Comment out the protocol references.
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00001894 InsertText(LessLoc, "/*", 2);
1895 InsertText(GreaterLoc, "*/", 2);
Steve Naroffd5255f52007-11-01 13:24:47 +00001896 }
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001897 startBuf = ++endBuf;
1898 }
1899 else {
Steve Naroffaba49d12008-08-06 15:58:23 +00001900 // If the function name is derived from a macro expansion, then the
1901 // argument buffer will not follow the name. Need to speak with Chris.
1902 while (*startBuf && *startBuf != ')' && *startBuf != ',')
Fariborz Jahanian61477f72007-12-11 22:50:14 +00001903 startBuf++; // scan forward (from the decl location) for argument types.
1904 startBuf++;
1905 }
Steve Naroffd5255f52007-11-01 13:24:47 +00001906 }
Steve Naroff9165ad32007-10-31 04:38:33 +00001907}
1908
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001909// SynthSelGetUidFunctionDecl - SEL sel_registerName(const char *str);
Steve Naroffb29b4272008-04-14 22:03:09 +00001910void RewriteObjC::SynthSelGetUidFunctionDecl() {
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001911 IdentifierInfo *SelGetUidIdent = &Context->Idents.get("sel_registerName");
1912 llvm::SmallVector<QualType, 16> ArgTys;
1913 ArgTys.push_back(Context->getPointerType(
1914 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001915 QualType getFuncType = Context->getFunctionType(Context->getObjCSelType(),
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001916 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001917 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001918 SelGetUidFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001919 SourceLocation(),
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00001920 SelGetUidIdent, getFuncType,
1921 FunctionDecl::Extern, false, 0);
1922}
1923
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001924// SynthGetProtocolFunctionDecl - Protocol objc_getProtocol(const char *proto);
Steve Naroffb29b4272008-04-14 22:03:09 +00001925void RewriteObjC::SynthGetProtocolFunctionDecl() {
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001926 IdentifierInfo *SelGetProtoIdent = &Context->Idents.get("objc_getProtocol");
1927 llvm::SmallVector<QualType, 16> ArgTys;
1928 ArgTys.push_back(Context->getPointerType(
1929 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001930 QualType getFuncType = Context->getFunctionType(Context->getObjCProtoType(),
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001931 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001932 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001933 GetProtocolFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001934 SourceLocation(),
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00001935 SelGetProtoIdent, getFuncType,
1936 FunctionDecl::Extern, false, 0);
1937}
1938
Steve Naroffb29b4272008-04-14 22:03:09 +00001939void RewriteObjC::RewriteFunctionDecl(FunctionDecl *FD) {
Steve Naroff09b266e2007-10-30 23:14:51 +00001940 // declared in <objc/objc.h>
Chris Lattner8ec03f52008-11-24 03:54:41 +00001941 if (strcmp(FD->getNameAsCString(), "sel_registerName") == 0) {
Steve Naroff09b266e2007-10-30 23:14:51 +00001942 SelGetUidFunctionDecl = FD;
Steve Naroff9165ad32007-10-31 04:38:33 +00001943 return;
1944 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001945 RewriteObjCQualifiedInterfaceTypes(FD);
Steve Naroff09b266e2007-10-30 23:14:51 +00001946}
1947
Steve Naroffc0a123c2008-03-11 17:37:02 +00001948// SynthSuperContructorFunctionDecl - id objc_super(id obj, id super);
Steve Naroffb29b4272008-04-14 22:03:09 +00001949void RewriteObjC::SynthSuperContructorFunctionDecl() {
Steve Naroffc0a123c2008-03-11 17:37:02 +00001950 if (SuperContructorFunctionDecl)
1951 return;
1952 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_super");
1953 llvm::SmallVector<QualType, 16> ArgTys;
1954 QualType argT = Context->getObjCIdType();
1955 assert(!argT.isNull() && "Can't find 'id' type");
1956 ArgTys.push_back(argT);
1957 ArgTys.push_back(argT);
1958 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
1959 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001960 false, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001961 SuperContructorFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001962 SourceLocation(),
Steve Naroffc0a123c2008-03-11 17:37:02 +00001963 msgSendIdent, msgSendType,
1964 FunctionDecl::Extern, false, 0);
1965}
1966
Steve Naroff09b266e2007-10-30 23:14:51 +00001967// SynthMsgSendFunctionDecl - id objc_msgSend(id self, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001968void RewriteObjC::SynthMsgSendFunctionDecl() {
Steve Naroff09b266e2007-10-30 23:14:51 +00001969 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend");
1970 llvm::SmallVector<QualType, 16> ArgTys;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001971 QualType argT = Context->getObjCIdType();
Steve Naroff09b266e2007-10-30 23:14:51 +00001972 assert(!argT.isNull() && "Can't find 'id' type");
1973 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001974 argT = Context->getObjCSelType();
Steve Naroff09b266e2007-10-30 23:14:51 +00001975 assert(!argT.isNull() && "Can't find 'SEL' type");
1976 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001977 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff09b266e2007-10-30 23:14:51 +00001978 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00001979 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00001980 MsgSendFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001981 SourceLocation(),
Steve Naroff09b266e2007-10-30 23:14:51 +00001982 msgSendIdent, msgSendType,
1983 FunctionDecl::Extern, false, 0);
1984}
1985
Steve Naroff874e2322007-11-15 10:28:18 +00001986// SynthMsgSendSuperFunctionDecl - id objc_msgSendSuper(struct objc_super *, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00001987void RewriteObjC::SynthMsgSendSuperFunctionDecl() {
Steve Naroff874e2322007-11-15 10:28:18 +00001988 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSendSuper");
1989 llvm::SmallVector<QualType, 16> ArgTys;
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00001990 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00001991 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00001992 &Context->Idents.get("objc_super"));
Steve Naroff874e2322007-11-15 10:28:18 +00001993 QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
1994 assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
1995 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001996 argT = Context->getObjCSelType();
Steve Naroff874e2322007-11-15 10:28:18 +00001997 assert(!argT.isNull() && "Can't find 'SEL' type");
1998 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001999 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff874e2322007-11-15 10:28:18 +00002000 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002001 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002002 MsgSendSuperFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00002003 SourceLocation(),
Steve Naroff874e2322007-11-15 10:28:18 +00002004 msgSendIdent, msgSendType,
2005 FunctionDecl::Extern, false, 0);
2006}
2007
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002008// SynthMsgSendStretFunctionDecl - id objc_msgSend_stret(id self, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00002009void RewriteObjC::SynthMsgSendStretFunctionDecl() {
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002010 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_stret");
2011 llvm::SmallVector<QualType, 16> ArgTys;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002012 QualType argT = Context->getObjCIdType();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002013 assert(!argT.isNull() && "Can't find 'id' type");
2014 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002015 argT = Context->getObjCSelType();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002016 assert(!argT.isNull() && "Can't find 'SEL' type");
2017 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002018 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002019 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002020 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002021 MsgSendStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00002022 SourceLocation(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002023 msgSendIdent, msgSendType,
2024 FunctionDecl::Extern, false, 0);
2025}
2026
2027// SynthMsgSendSuperStretFunctionDecl -
2028// id objc_msgSendSuper_stret(struct objc_super *, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00002029void RewriteObjC::SynthMsgSendSuperStretFunctionDecl() {
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002030 IdentifierInfo *msgSendIdent =
2031 &Context->Idents.get("objc_msgSendSuper_stret");
2032 llvm::SmallVector<QualType, 16> ArgTys;
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002033 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00002034 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00002035 &Context->Idents.get("objc_super"));
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002036 QualType argT = Context->getPointerType(Context->getTagDeclType(RD));
2037 assert(!argT.isNull() && "Can't build 'struct objc_super *' type");
2038 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002039 argT = Context->getObjCSelType();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002040 assert(!argT.isNull() && "Can't find 'SEL' type");
2041 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002042 QualType msgSendType = Context->getFunctionType(Context->getObjCIdType(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002043 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002044 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002045 MsgSendSuperStretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattnera98e58d2008-03-15 21:24:04 +00002046 SourceLocation(),
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002047 msgSendIdent, msgSendType,
2048 FunctionDecl::Extern, false, 0);
2049}
2050
Steve Naroff1284db82008-05-08 22:02:18 +00002051// SynthMsgSendFpretFunctionDecl - double objc_msgSend_fpret(id self, SEL op, ...);
Steve Naroffb29b4272008-04-14 22:03:09 +00002052void RewriteObjC::SynthMsgSendFpretFunctionDecl() {
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002053 IdentifierInfo *msgSendIdent = &Context->Idents.get("objc_msgSend_fpret");
2054 llvm::SmallVector<QualType, 16> ArgTys;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002055 QualType argT = Context->getObjCIdType();
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002056 assert(!argT.isNull() && "Can't find 'id' type");
2057 ArgTys.push_back(argT);
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002058 argT = Context->getObjCSelType();
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002059 assert(!argT.isNull() && "Can't find 'SEL' type");
2060 ArgTys.push_back(argT);
Steve Naroff1284db82008-05-08 22:02:18 +00002061 QualType msgSendType = Context->getFunctionType(Context->DoubleTy,
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002062 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002063 true /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002064 MsgSendFpretFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00002065 SourceLocation(),
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002066 msgSendIdent, msgSendType,
2067 FunctionDecl::Extern, false, 0);
2068}
2069
Steve Naroff09b266e2007-10-30 23:14:51 +00002070// SynthGetClassFunctionDecl - id objc_getClass(const char *name);
Steve Naroffb29b4272008-04-14 22:03:09 +00002071void RewriteObjC::SynthGetClassFunctionDecl() {
Steve Naroff09b266e2007-10-30 23:14:51 +00002072 IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getClass");
2073 llvm::SmallVector<QualType, 16> ArgTys;
2074 ArgTys.push_back(Context->getPointerType(
2075 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002076 QualType getClassType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff09b266e2007-10-30 23:14:51 +00002077 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002078 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002079 GetClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00002080 SourceLocation(),
Steve Naroff09b266e2007-10-30 23:14:51 +00002081 getClassIdent, getClassType,
2082 FunctionDecl::Extern, false, 0);
2083}
2084
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002085// SynthGetMetaClassFunctionDecl - id objc_getClass(const char *name);
Steve Naroffb29b4272008-04-14 22:03:09 +00002086void RewriteObjC::SynthGetMetaClassFunctionDecl() {
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002087 IdentifierInfo *getClassIdent = &Context->Idents.get("objc_getMetaClass");
2088 llvm::SmallVector<QualType, 16> ArgTys;
2089 ArgTys.push_back(Context->getPointerType(
2090 Context->CharTy.getQualifiedType(QualType::Const)));
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002091 QualType getClassType = Context->getFunctionType(Context->getObjCIdType(),
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002092 &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002093 false /*isVariadic*/, 0);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002094 GetMetaClassFunctionDecl = FunctionDecl::Create(*Context, TUDecl,
Chris Lattner0ed844b2008-04-04 06:12:32 +00002095 SourceLocation(),
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002096 getClassIdent, getClassType,
2097 FunctionDecl::Extern, false, 0);
2098}
2099
Steve Naroffb29b4272008-04-14 22:03:09 +00002100Stmt *RewriteObjC::RewriteObjCStringLiteral(ObjCStringLiteral *Exp) {
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002101 QualType strType = getConstantStringStructType();
2102
2103 std::string S = "__NSConstantStringImpl_";
Steve Naroff7691d9b2008-05-31 03:35:42 +00002104
2105 std::string tmpName = InFileName;
2106 unsigned i;
2107 for (i=0; i < tmpName.length(); i++) {
2108 char c = tmpName.at(i);
2109 // replace any non alphanumeric characters with '_'.
2110 if (!isalpha(c) && (c < '0' || c > '9'))
2111 tmpName[i] = '_';
2112 }
2113 S += tmpName;
2114 S += "_";
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002115 S += utostr(NumObjCStringLiterals++);
2116
Steve Naroffba92b2e2008-03-27 22:29:16 +00002117 Preamble += "static __NSConstantStringImpl " + S;
2118 Preamble += " __attribute__ ((section (\"__DATA, __cfstring\"))) = {__CFConstantStringClassReference,";
2119 Preamble += "0x000007c8,"; // utf8_str
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002120 // The pretty printer for StringLiteral handles escape characters properly.
Ted Kremeneka95d3752008-09-13 05:16:45 +00002121 std::string prettyBufS;
2122 llvm::raw_string_ostream prettyBuf(prettyBufS);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002123 Exp->getString()->printPretty(prettyBuf);
Steve Naroffba92b2e2008-03-27 22:29:16 +00002124 Preamble += prettyBuf.str();
2125 Preamble += ",";
Steve Naroff3652c2d2008-03-15 01:36:04 +00002126 // The minus 2 removes the begin/end double quotes.
Steve Naroffba92b2e2008-03-27 22:29:16 +00002127 Preamble += utostr(prettyBuf.str().size()-2) + "};\n";
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002128
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00002129 VarDecl *NewVD = VarDecl::Create(*Context, TUDecl, SourceLocation(),
Steve Naroff248a7532008-04-15 22:42:06 +00002130 &Context->Idents.get(S.c_str()), strType,
2131 VarDecl::Static, NULL);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002132 DeclRefExpr *DRE = new DeclRefExpr(NewVD, strType, SourceLocation());
2133 Expr *Unop = new UnaryOperator(DRE, UnaryOperator::AddrOf,
2134 Context->getPointerType(DRE->getType()),
2135 SourceLocation());
Steve Naroff96984642007-11-08 14:30:50 +00002136 // cast to NSConstantString *
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002137 CastExpr *cast = new CStyleCastExpr(Exp->getType(), Unop,
Steve Naroffb2f9e512008-11-03 23:29:32 +00002138 Exp->getType(), SourceLocation(), SourceLocation());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00002139 ReplaceStmt(Exp, cast);
Steve Naroff4c3580e2008-12-04 23:50:32 +00002140 // delete Exp; leak for now, see RewritePropertySetter() usage for more info.
Steve Naroff96984642007-11-08 14:30:50 +00002141 return cast;
Steve Naroffbeaf2992007-11-03 11:27:19 +00002142}
2143
Steve Naroffb29b4272008-04-14 22:03:09 +00002144ObjCInterfaceDecl *RewriteObjC::isSuperReceiver(Expr *recExpr) {
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002145 // check if we are sending a message to 'super'
Steve Naroff54055232008-10-27 17:20:55 +00002146 if (!CurMethodDef || !CurMethodDef->isInstance()) return 0;
Chris Lattner6c2b6eb2008-03-15 06:12:44 +00002147
Douglas Gregorcd9b46e2008-11-04 14:56:14 +00002148 if (ObjCSuperExpr *Super = dyn_cast<ObjCSuperExpr>(recExpr)) {
2149 const PointerType *PT = Super->getType()->getAsPointerType();
Chris Lattner0d17f6f2008-06-21 18:04:54 +00002150 assert(PT);
2151 ObjCInterfaceType *IT = cast<ObjCInterfaceType>(PT->getPointeeType());
2152 return IT->getDecl();
2153 }
2154 return 0;
Steve Naroff874e2322007-11-15 10:28:18 +00002155}
2156
2157// struct objc_super { struct objc_object *receiver; struct objc_class *super; };
Steve Naroffb29b4272008-04-14 22:03:09 +00002158QualType RewriteObjC::getSuperStructType() {
Steve Naroff874e2322007-11-15 10:28:18 +00002159 if (!SuperStructDecl) {
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002160 SuperStructDecl = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattnerc63e6602008-03-15 21:32:50 +00002161 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00002162 &Context->Idents.get("objc_super"));
Steve Naroff874e2322007-11-15 10:28:18 +00002163 QualType FieldTypes[2];
2164
2165 // struct objc_object *receiver;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002166 FieldTypes[0] = Context->getObjCIdType();
Steve Naroff874e2322007-11-15 10:28:18 +00002167 // struct objc_class *super;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002168 FieldTypes[1] = Context->getObjCClassType();
Douglas Gregor44b43212008-12-11 16:49:14 +00002169
Steve Naroff874e2322007-11-15 10:28:18 +00002170 // Create fields
Douglas Gregor44b43212008-12-11 16:49:14 +00002171 for (unsigned i = 0; i < 2; ++i) {
2172 SuperStructDecl->addDecl(*Context,
2173 FieldDecl::Create(*Context, SuperStructDecl,
2174 SourceLocation(), 0,
2175 FieldTypes[i], /*BitWidth=*/0,
2176 /*Mutable=*/false, 0),
2177 true);
2178 }
Steve Naroff874e2322007-11-15 10:28:18 +00002179
Douglas Gregor44b43212008-12-11 16:49:14 +00002180 SuperStructDecl->completeDefinition(*Context);
Steve Naroff874e2322007-11-15 10:28:18 +00002181 }
2182 return Context->getTagDeclType(SuperStructDecl);
2183}
2184
Steve Naroffb29b4272008-04-14 22:03:09 +00002185QualType RewriteObjC::getConstantStringStructType() {
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002186 if (!ConstantStringDecl) {
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00002187 ConstantStringDecl = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
Chris Lattnerc63e6602008-03-15 21:32:50 +00002188 SourceLocation(),
Ted Kremenekdf042e62008-09-05 01:34:33 +00002189 &Context->Idents.get("__NSConstantStringImpl"));
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002190 QualType FieldTypes[4];
2191
2192 // struct objc_object *receiver;
2193 FieldTypes[0] = Context->getObjCIdType();
2194 // int flags;
2195 FieldTypes[1] = Context->IntTy;
2196 // char *str;
2197 FieldTypes[2] = Context->getPointerType(Context->CharTy);
2198 // long length;
2199 FieldTypes[3] = Context->LongTy;
Douglas Gregor44b43212008-12-11 16:49:14 +00002200
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002201 // Create fields
Douglas Gregor44b43212008-12-11 16:49:14 +00002202 for (unsigned i = 0; i < 4; ++i) {
2203 ConstantStringDecl->addDecl(*Context,
2204 FieldDecl::Create(*Context,
2205 ConstantStringDecl,
2206 SourceLocation(), 0,
2207 FieldTypes[i],
2208 /*BitWidth=*/0,
2209 /*Mutable=*/true, 0),
2210 true);
2211 }
2212
2213 ConstantStringDecl->completeDefinition(*Context);
Steve Naroffd82a9ab2008-03-15 00:55:56 +00002214 }
2215 return Context->getTagDeclType(ConstantStringDecl);
2216}
2217
Steve Naroffb29b4272008-04-14 22:03:09 +00002218Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
Fariborz Jahaniana70711b2007-12-04 21:47:40 +00002219 if (!SelGetUidFunctionDecl)
2220 SynthSelGetUidFunctionDecl();
Steve Naroff09b266e2007-10-30 23:14:51 +00002221 if (!MsgSendFunctionDecl)
2222 SynthMsgSendFunctionDecl();
Steve Naroff874e2322007-11-15 10:28:18 +00002223 if (!MsgSendSuperFunctionDecl)
2224 SynthMsgSendSuperFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002225 if (!MsgSendStretFunctionDecl)
2226 SynthMsgSendStretFunctionDecl();
2227 if (!MsgSendSuperStretFunctionDecl)
2228 SynthMsgSendSuperStretFunctionDecl();
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002229 if (!MsgSendFpretFunctionDecl)
2230 SynthMsgSendFpretFunctionDecl();
Steve Naroff09b266e2007-10-30 23:14:51 +00002231 if (!GetClassFunctionDecl)
2232 SynthGetClassFunctionDecl();
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002233 if (!GetMetaClassFunctionDecl)
2234 SynthGetMetaClassFunctionDecl();
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002235
Steve Naroff874e2322007-11-15 10:28:18 +00002236 // default to objc_msgSend().
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002237 FunctionDecl *MsgSendFlavor = MsgSendFunctionDecl;
2238 // May need to use objc_msgSend_stret() as well.
2239 FunctionDecl *MsgSendStretFlavor = 0;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002240 if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002241 QualType resultType = mDecl->getResultType();
Chris Lattner8b51fd72008-07-26 22:36:27 +00002242 if (resultType->isStructureType() || resultType->isUnionType())
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002243 MsgSendStretFlavor = MsgSendStretFunctionDecl;
Chris Lattner8b51fd72008-07-26 22:36:27 +00002244 else if (resultType->isRealFloatingType())
Fariborz Jahanianacb49772007-12-03 21:26:48 +00002245 MsgSendFlavor = MsgSendFpretFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002246 }
Steve Naroff874e2322007-11-15 10:28:18 +00002247
Steve Naroff934f2762007-10-24 22:48:43 +00002248 // Synthesize a call to objc_msgSend().
2249 llvm::SmallVector<Expr*, 8> MsgExprs;
2250 IdentifierInfo *clsName = Exp->getClassName();
2251
2252 // Derive/push the receiver/selector, 2 implicit arguments to objc_msgSend().
2253 if (clsName) { // class message.
Steve Narofffc93d522008-07-24 19:44:33 +00002254 // FIXME: We need to fix Sema (and the AST for ObjCMessageExpr) to handle
2255 // the 'super' idiom within a class method.
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002256 if (!strcmp(clsName->getName(), "super")) {
2257 MsgSendFlavor = MsgSendSuperFunctionDecl;
2258 if (MsgSendStretFlavor)
2259 MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
2260 assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
2261
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002262 ObjCInterfaceDecl *SuperDecl =
Steve Naroff54055232008-10-27 17:20:55 +00002263 CurMethodDef->getClassInterface()->getSuperClass();
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002264
2265 llvm::SmallVector<Expr*, 4> InitExprs;
2266
2267 // set the receiver to self, the first argument to all methods.
Chris Lattner41110242008-06-17 18:05:57 +00002268 InitExprs.push_back(new DeclRefExpr(
Steve Naroff54055232008-10-27 17:20:55 +00002269 CurMethodDef->getSelfDecl(),
Chris Lattner41110242008-06-17 18:05:57 +00002270 Context->getObjCIdType(),
2271 SourceLocation()));
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002272 llvm::SmallVector<Expr*, 8> ClsExprs;
2273 QualType argType = Context->getPointerType(Context->CharTy);
2274 ClsExprs.push_back(new StringLiteral(SuperDecl->getIdentifier()->getName(),
2275 SuperDecl->getIdentifier()->getLength(),
2276 false, argType, SourceLocation(),
2277 SourceLocation()));
2278 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetMetaClassFunctionDecl,
2279 &ClsExprs[0],
2280 ClsExprs.size());
2281 // To turn off a warning, type-cast to 'id'
Douglas Gregor49badde2008-10-27 19:41:14 +00002282 InitExprs.push_back( // set 'super class', using objc_getClass().
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002283 new CStyleCastExpr(Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00002284 Cls, Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002285 SourceLocation(), SourceLocation()));
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002286 // struct objc_super
2287 QualType superType = getSuperStructType();
Steve Naroff23f41272008-03-11 18:14:26 +00002288 Expr *SuperRep;
Steve Naroffc0a123c2008-03-11 17:37:02 +00002289
Steve Naroff23f41272008-03-11 18:14:26 +00002290 if (LangOpts.Microsoft) {
2291 SynthSuperContructorFunctionDecl();
2292 // Simulate a contructor call...
2293 DeclRefExpr *DRE = new DeclRefExpr(SuperContructorFunctionDecl,
2294 superType, SourceLocation());
2295 SuperRep = new CallExpr(DRE, &InitExprs[0], InitExprs.size(),
2296 superType, SourceLocation());
2297 } else {
2298 // (struct objc_super) { <exprs from above> }
2299 InitListExpr *ILE = new InitListExpr(SourceLocation(),
2300 &InitExprs[0], InitExprs.size(),
Chris Lattner418f6c72008-10-26 23:43:26 +00002301 SourceLocation(), false);
2302 SuperRep = new CompoundLiteralExpr(SourceLocation(), superType, ILE,
2303 false);
Steve Naroff23f41272008-03-11 18:14:26 +00002304 }
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002305 // struct objc_super *
2306 Expr *Unop = new UnaryOperator(SuperRep, UnaryOperator::AddrOf,
2307 Context->getPointerType(SuperRep->getType()),
2308 SourceLocation());
2309 MsgExprs.push_back(Unop);
2310 } else {
2311 llvm::SmallVector<Expr*, 8> ClsExprs;
2312 QualType argType = Context->getPointerType(Context->CharTy);
2313 ClsExprs.push_back(new StringLiteral(clsName->getName(),
2314 clsName->getLength(),
2315 false, argType, SourceLocation(),
2316 SourceLocation()));
2317 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl,
2318 &ClsExprs[0],
2319 ClsExprs.size());
2320 MsgExprs.push_back(Cls);
2321 }
Steve Naroff6568d4d2007-11-14 23:54:14 +00002322 } else { // instance message.
2323 Expr *recExpr = Exp->getReceiver();
Steve Naroff874e2322007-11-15 10:28:18 +00002324
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002325 if (ObjCInterfaceDecl *SuperDecl = isSuperReceiver(recExpr)) {
Steve Naroff874e2322007-11-15 10:28:18 +00002326 MsgSendFlavor = MsgSendSuperFunctionDecl;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002327 if (MsgSendStretFlavor)
2328 MsgSendStretFlavor = MsgSendSuperStretFunctionDecl;
Steve Naroff874e2322007-11-15 10:28:18 +00002329 assert(MsgSendFlavor && "MsgSendFlavor is NULL!");
2330
2331 llvm::SmallVector<Expr*, 4> InitExprs;
2332
Fariborz Jahanianceee3e82007-12-04 22:32:58 +00002333 InitExprs.push_back(
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002334 new CStyleCastExpr(Context->getObjCIdType(),
Steve Naroff54055232008-10-27 17:20:55 +00002335 new DeclRefExpr(CurMethodDef->getSelfDecl(),
Steve Narofff616ebb2008-07-16 22:35:27 +00002336 Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00002337 SourceLocation()),
2338 Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002339 SourceLocation(), SourceLocation())); // set the 'receiver'.
Steve Naroff874e2322007-11-15 10:28:18 +00002340
2341 llvm::SmallVector<Expr*, 8> ClsExprs;
2342 QualType argType = Context->getPointerType(Context->CharTy);
Steve Naroff9bcb5fc2007-12-07 03:50:46 +00002343 ClsExprs.push_back(new StringLiteral(SuperDecl->getIdentifier()->getName(),
2344 SuperDecl->getIdentifier()->getLength(),
Steve Naroff874e2322007-11-15 10:28:18 +00002345 false, argType, SourceLocation(),
2346 SourceLocation()));
2347 CallExpr *Cls = SynthesizeCallToFunctionDecl(GetClassFunctionDecl,
Fariborz Jahanianceee3e82007-12-04 22:32:58 +00002348 &ClsExprs[0],
2349 ClsExprs.size());
Fariborz Jahanian71274312007-12-05 17:29:46 +00002350 // To turn off a warning, type-cast to 'id'
Fariborz Jahanianceee3e82007-12-04 22:32:58 +00002351 InitExprs.push_back(
Douglas Gregor49badde2008-10-27 19:41:14 +00002352 // set 'super class', using objc_getClass().
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002353 new CStyleCastExpr(Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002354 Cls, Context->getObjCIdType(), SourceLocation(), SourceLocation()));
Steve Naroff874e2322007-11-15 10:28:18 +00002355 // struct objc_super
2356 QualType superType = getSuperStructType();
Steve Naroffc0a123c2008-03-11 17:37:02 +00002357 Expr *SuperRep;
2358
2359 if (LangOpts.Microsoft) {
2360 SynthSuperContructorFunctionDecl();
2361 // Simulate a contructor call...
2362 DeclRefExpr *DRE = new DeclRefExpr(SuperContructorFunctionDecl,
2363 superType, SourceLocation());
2364 SuperRep = new CallExpr(DRE, &InitExprs[0], InitExprs.size(),
2365 superType, SourceLocation());
2366 } else {
2367 // (struct objc_super) { <exprs from above> }
2368 InitListExpr *ILE = new InitListExpr(SourceLocation(),
2369 &InitExprs[0], InitExprs.size(),
Chris Lattner418f6c72008-10-26 23:43:26 +00002370 SourceLocation(), false);
Steve Naroffc0a123c2008-03-11 17:37:02 +00002371 SuperRep = new CompoundLiteralExpr(SourceLocation(), superType, ILE, false);
2372 }
Steve Naroff874e2322007-11-15 10:28:18 +00002373 // struct objc_super *
2374 Expr *Unop = new UnaryOperator(SuperRep, UnaryOperator::AddrOf,
2375 Context->getPointerType(SuperRep->getType()),
2376 SourceLocation());
2377 MsgExprs.push_back(Unop);
2378 } else {
Fariborz Jahanian7dd82832007-12-07 21:21:21 +00002379 // Remove all type-casts because it may contain objc-style types; e.g.
2380 // Foo<Proto> *.
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002381 while (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(recExpr))
Fariborz Jahanian7dd82832007-12-07 21:21:21 +00002382 recExpr = CE->getSubExpr();
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002383 recExpr = new CStyleCastExpr(Context->getObjCIdType(), recExpr,
Douglas Gregor49badde2008-10-27 19:41:14 +00002384 Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002385 SourceLocation(), SourceLocation());
Steve Naroff874e2322007-11-15 10:28:18 +00002386 MsgExprs.push_back(recExpr);
2387 }
Steve Naroff6568d4d2007-11-14 23:54:14 +00002388 }
Steve Naroffbeaf2992007-11-03 11:27:19 +00002389 // Create a call to sel_registerName("selName"), it will be the 2nd argument.
Steve Naroff934f2762007-10-24 22:48:43 +00002390 llvm::SmallVector<Expr*, 8> SelExprs;
2391 QualType argType = Context->getPointerType(Context->CharTy);
Chris Lattner077bf5e2008-11-24 03:33:13 +00002392 SelExprs.push_back(new StringLiteral(Exp->getSelector().getAsString().c_str(),
2393 Exp->getSelector().getAsString().size(),
Steve Naroff934f2762007-10-24 22:48:43 +00002394 false, argType, SourceLocation(),
2395 SourceLocation()));
2396 CallExpr *SelExp = SynthesizeCallToFunctionDecl(SelGetUidFunctionDecl,
2397 &SelExprs[0], SelExprs.size());
2398 MsgExprs.push_back(SelExp);
2399
2400 // Now push any user supplied arguments.
2401 for (unsigned i = 0; i < Exp->getNumArgs(); i++) {
Steve Naroff6568d4d2007-11-14 23:54:14 +00002402 Expr *userExpr = Exp->getArg(i);
Steve Naroff7e3411b2007-11-15 02:58:25 +00002403 // Make all implicit casts explicit...ICE comes in handy:-)
2404 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(userExpr)) {
2405 // Reuse the ICE type, it is exactly what the doctor ordered.
Douglas Gregor49badde2008-10-27 19:41:14 +00002406 QualType type = ICE->getType()->isObjCQualifiedIdType()
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002407 ? Context->getObjCIdType()
Douglas Gregor49badde2008-10-27 19:41:14 +00002408 : ICE->getType();
Steve Naroffb2f9e512008-11-03 23:29:32 +00002409 userExpr = new CStyleCastExpr(type, userExpr, type, SourceLocation(), SourceLocation());
Fariborz Jahaniand58fabf2007-12-18 21:33:44 +00002410 }
2411 // Make id<P...> cast into an 'id' cast.
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002412 else if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(userExpr)) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002413 if (CE->getType()->isObjCQualifiedIdType()) {
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002414 while ((CE = dyn_cast<CStyleCastExpr>(userExpr)))
Fariborz Jahaniand58fabf2007-12-18 21:33:44 +00002415 userExpr = CE->getSubExpr();
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002416 userExpr = new CStyleCastExpr(Context->getObjCIdType(),
Douglas Gregor49badde2008-10-27 19:41:14 +00002417 userExpr, Context->getObjCIdType(),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002418 SourceLocation(), SourceLocation());
Fariborz Jahaniand58fabf2007-12-18 21:33:44 +00002419 }
Steve Naroff7e3411b2007-11-15 02:58:25 +00002420 }
Steve Naroff6568d4d2007-11-14 23:54:14 +00002421 MsgExprs.push_back(userExpr);
Steve Naroff934f2762007-10-24 22:48:43 +00002422 // We've transferred the ownership to MsgExprs. Null out the argument in
2423 // the original expression, since we will delete it below.
2424 Exp->setArg(i, 0);
2425 }
Steve Naroffab972d32007-11-04 22:37:50 +00002426 // Generate the funky cast.
2427 CastExpr *cast;
2428 llvm::SmallVector<QualType, 8> ArgTypes;
2429 QualType returnType;
2430
2431 // Push 'id' and 'SEL', the 2 implicit arguments.
Steve Naroffc3a438c2007-11-15 10:43:57 +00002432 if (MsgSendFlavor == MsgSendSuperFunctionDecl)
2433 ArgTypes.push_back(Context->getPointerType(getSuperStructType()));
2434 else
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002435 ArgTypes.push_back(Context->getObjCIdType());
2436 ArgTypes.push_back(Context->getObjCSelType());
2437 if (ObjCMethodDecl *mDecl = Exp->getMethodDecl()) {
Steve Naroffab972d32007-11-04 22:37:50 +00002438 // Push any user argument types.
Chris Lattner58cce3b2008-03-16 01:07:14 +00002439 for (unsigned i = 0; i < mDecl->getNumParams(); i++) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002440 QualType t = mDecl->getParamDecl(i)->getType()->isObjCQualifiedIdType()
2441 ? Context->getObjCIdType()
Fariborz Jahanianc5692492007-12-17 21:03:50 +00002442 : mDecl->getParamDecl(i)->getType();
Steve Naroffa206b062008-10-29 14:49:46 +00002443 // Make sure we convert "t (^)(...)" to "t (*)(...)".
Steve Naroff01f2ffa2008-12-11 21:05:33 +00002444 if (isTopLevelBlockPointerType(t)) {
Steve Naroffa206b062008-10-29 14:49:46 +00002445 const BlockPointerType *BPT = t->getAsBlockPointerType();
2446 t = Context->getPointerType(BPT->getPointeeType());
2447 }
Steve Naroff352336b2007-11-05 14:36:37 +00002448 ArgTypes.push_back(t);
2449 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002450 returnType = mDecl->getResultType()->isObjCQualifiedIdType()
2451 ? Context->getObjCIdType() : mDecl->getResultType();
Steve Naroffab972d32007-11-04 22:37:50 +00002452 } else {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002453 returnType = Context->getObjCIdType();
Steve Naroffab972d32007-11-04 22:37:50 +00002454 }
2455 // Get the type, we will need to reference it in a couple spots.
Steve Naroff874e2322007-11-15 10:28:18 +00002456 QualType msgSendType = MsgSendFlavor->getType();
Steve Naroffab972d32007-11-04 22:37:50 +00002457
2458 // Create a reference to the objc_msgSend() declaration.
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002459 DeclRefExpr *DRE = new DeclRefExpr(MsgSendFlavor, msgSendType,
2460 SourceLocation());
Steve Naroffab972d32007-11-04 22:37:50 +00002461
2462 // Need to cast objc_msgSend to "void *" (to workaround a GCC bandaid).
2463 // If we don't do this cast, we get the following bizarre warning/note:
2464 // xx.m:13: warning: function called through a non-compatible type
2465 // xx.m:13: note: if this code is reached, the program will abort
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002466 cast = new CStyleCastExpr(Context->getPointerType(Context->VoidTy), DRE,
Douglas Gregor49badde2008-10-27 19:41:14 +00002467 Context->getPointerType(Context->VoidTy),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002468 SourceLocation(), SourceLocation());
Steve Naroff335eafa2007-11-15 12:35:21 +00002469
Steve Naroffab972d32007-11-04 22:37:50 +00002470 // Now do the "normal" pointer to function cast.
2471 QualType castType = Context->getFunctionType(returnType,
Fariborz Jahaniand0ee6f92007-12-06 19:49:56 +00002472 &ArgTypes[0], ArgTypes.size(),
Steve Naroff2679e482008-03-18 02:02:04 +00002473 // If we don't have a method decl, force a variadic cast.
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002474 Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : true, 0);
Steve Naroffab972d32007-11-04 22:37:50 +00002475 castType = Context->getPointerType(castType);
Steve Naroffb2f9e512008-11-03 23:29:32 +00002476 cast = new CStyleCastExpr(castType, cast, castType, SourceLocation(), SourceLocation());
Steve Naroffab972d32007-11-04 22:37:50 +00002477
2478 // Don't forget the parens to enforce the proper binding.
2479 ParenExpr *PE = new ParenExpr(SourceLocation(), SourceLocation(), cast);
2480
2481 const FunctionType *FT = msgSendType->getAsFunctionType();
2482 CallExpr *CE = new CallExpr(PE, &MsgExprs[0], MsgExprs.size(),
2483 FT->getResultType(), SourceLocation());
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002484 Stmt *ReplacingStmt = CE;
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002485 if (MsgSendStretFlavor) {
2486 // We have the method which returns a struct/union. Must also generate
2487 // call to objc_msgSend_stret and hang both varieties on a conditional
2488 // expression which dictate which one to envoke depending on size of
2489 // method's return type.
2490
2491 // Create a reference to the objc_msgSend_stret() declaration.
2492 DeclRefExpr *STDRE = new DeclRefExpr(MsgSendStretFlavor, msgSendType,
2493 SourceLocation());
2494 // Need to cast objc_msgSend_stret to "void *" (see above comment).
Douglas Gregor6eec8e82008-10-28 15:36:24 +00002495 cast = new CStyleCastExpr(Context->getPointerType(Context->VoidTy), STDRE,
Douglas Gregor49badde2008-10-27 19:41:14 +00002496 Context->getPointerType(Context->VoidTy),
Steve Naroffb2f9e512008-11-03 23:29:32 +00002497 SourceLocation(), SourceLocation());
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002498 // Now do the "normal" pointer to function cast.
2499 castType = Context->getFunctionType(returnType,
Fariborz Jahaniand0ee6f92007-12-06 19:49:56 +00002500 &ArgTypes[0], ArgTypes.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +00002501 Exp->getMethodDecl() ? Exp->getMethodDecl()->isVariadic() : false, 0);
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002502 castType = Context->getPointerType(castType);
Steve Naroffb2f9e512008-11-03 23:29:32 +00002503 cast = new CStyleCastExpr(castType, cast, castType, SourceLocation(), SourceLocation());
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002504
2505 // Don't forget the parens to enforce the proper binding.
2506 PE = new ParenExpr(SourceLocation(), SourceLocation(), cast);
2507
2508 FT = msgSendType->getAsFunctionType();
2509 CallExpr *STCE = new CallExpr(PE, &MsgExprs[0], MsgExprs.size(),
2510 FT->getResultType(), SourceLocation());
2511
2512 // Build sizeof(returnType)
Sebastian Redl05189992008-11-11 17:56:53 +00002513 SizeOfAlignOfExpr *sizeofExpr = new SizeOfAlignOfExpr(true, true,
2514 returnType.getAsOpaquePtr(),
2515 Context->getSizeType(),
2516 SourceLocation(), SourceLocation());
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002517 // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
2518 // FIXME: Value of 8 is base on ppc32/x86 ABI for the most common cases.
2519 // For X86 it is more complicated and some kind of target specific routine
2520 // is needed to decide what to do.
Chris Lattner98be4942008-03-05 18:54:05 +00002521 unsigned IntSize =
2522 static_cast<unsigned>(Context->getTypeSize(Context->IntTy));
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002523 IntegerLiteral *limit = new IntegerLiteral(llvm::APInt(IntSize, 8),
2524 Context->IntTy,
2525 SourceLocation());
2526 BinaryOperator *lessThanExpr = new BinaryOperator(sizeofExpr, limit,
2527 BinaryOperator::LE,
2528 Context->IntTy,
2529 SourceLocation());
2530 // (sizeof(returnType) <= 8 ? objc_msgSend(...) : objc_msgSend_stret(...))
2531 ConditionalOperator *CondExpr =
2532 new ConditionalOperator(lessThanExpr, CE, STCE, returnType);
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002533 ReplacingStmt = new ParenExpr(SourceLocation(), SourceLocation(), CondExpr);
Fariborz Jahanian80a6a5a2007-12-03 19:17:29 +00002534 }
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002535 return ReplacingStmt;
2536}
2537
Steve Naroffb29b4272008-04-14 22:03:09 +00002538Stmt *RewriteObjC::RewriteMessageExpr(ObjCMessageExpr *Exp) {
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002539 Stmt *ReplacingStmt = SynthMessageExpr(Exp);
Steve Naroff80c28552008-10-27 20:54:44 +00002540
Steve Naroffc77a6362008-12-04 16:24:46 +00002541 //ReplacingStmt->dump();
Steve Naroff934f2762007-10-24 22:48:43 +00002542 // Now do the actual rewrite.
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00002543 ReplaceStmt(Exp, ReplacingStmt);
Steve Naroff934f2762007-10-24 22:48:43 +00002544
Steve Naroff4c3580e2008-12-04 23:50:32 +00002545 // delete Exp; leak for now, see RewritePropertySetter() usage for more info.
Fariborz Jahanian33b9c4e2008-01-08 22:06:28 +00002546 return ReplacingStmt;
Steve Naroffebf2b562007-10-23 23:50:29 +00002547}
2548
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002549/// RewriteObjCProtocolExpr - Rewrite a protocol expression into
2550/// call to objc_getProtocol("proto-name").
Steve Naroffb29b4272008-04-14 22:03:09 +00002551Stmt *RewriteObjC::RewriteObjCProtocolExpr(ObjCProtocolExpr *Exp) {
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002552 if (!GetProtocolFunctionDecl)
2553 SynthGetProtocolFunctionDecl();
2554 // Create a call to objc_getProtocol("ProtocolName").
2555 llvm::SmallVector<Expr*, 8> ProtoExprs;
2556 QualType argType = Context->getPointerType(Context->CharTy);
Chris Lattner8ec03f52008-11-24 03:54:41 +00002557 ProtoExprs.push_back(new StringLiteral(Exp->getProtocol()->getNameAsCString(),
2558 strlen(Exp->getProtocol()->getNameAsCString()),
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002559 false, argType, SourceLocation(),
2560 SourceLocation()));
2561 CallExpr *ProtoExp = SynthesizeCallToFunctionDecl(GetProtocolFunctionDecl,
2562 &ProtoExprs[0],
2563 ProtoExprs.size());
Chris Lattnerdcbc5b02008-01-31 19:37:57 +00002564 ReplaceStmt(Exp, ProtoExp);
Steve Naroff4c3580e2008-12-04 23:50:32 +00002565 // delete Exp; leak for now, see RewritePropertySetter() usage for more info.
Fariborz Jahanian36ee2cb2007-12-07 18:47:10 +00002566 return ProtoExp;
2567
2568}
2569
Steve Naroffbaf58c32008-05-31 14:15:04 +00002570bool RewriteObjC::BufferContainsPPDirectives(const char *startBuf,
2571 const char *endBuf) {
2572 while (startBuf < endBuf) {
2573 if (*startBuf == '#') {
2574 // Skip whitespace.
2575 for (++startBuf; startBuf[0] == ' ' || startBuf[0] == '\t'; ++startBuf)
2576 ;
2577 if (!strncmp(startBuf, "if", strlen("if")) ||
2578 !strncmp(startBuf, "ifdef", strlen("ifdef")) ||
2579 !strncmp(startBuf, "ifndef", strlen("ifndef")) ||
2580 !strncmp(startBuf, "define", strlen("define")) ||
2581 !strncmp(startBuf, "undef", strlen("undef")) ||
2582 !strncmp(startBuf, "else", strlen("else")) ||
2583 !strncmp(startBuf, "elif", strlen("elif")) ||
2584 !strncmp(startBuf, "endif", strlen("endif")) ||
2585 !strncmp(startBuf, "pragma", strlen("pragma")) ||
2586 !strncmp(startBuf, "include", strlen("include")) ||
2587 !strncmp(startBuf, "import", strlen("import")) ||
2588 !strncmp(startBuf, "include_next", strlen("include_next")))
2589 return true;
2590 }
2591 startBuf++;
2592 }
2593 return false;
2594}
2595
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002596/// SynthesizeObjCInternalStruct - Rewrite one internal struct corresponding to
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002597/// an objective-c class with ivars.
Steve Naroffb29b4272008-04-14 22:03:09 +00002598void RewriteObjC::SynthesizeObjCInternalStruct(ObjCInterfaceDecl *CDecl,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002599 std::string &Result) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002600 assert(CDecl && "Class missing in SynthesizeObjCInternalStruct");
Chris Lattner8ec03f52008-11-24 03:54:41 +00002601 assert(CDecl->getNameAsCString() &&
Douglas Gregor2e1cd422008-11-17 14:58:09 +00002602 "Name missing in SynthesizeObjCInternalStruct");
Fariborz Jahanian212b7682007-10-31 23:08:24 +00002603 // Do not synthesize more than once.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002604 if (ObjCSynthesizedStructs.count(CDecl))
Fariborz Jahanian212b7682007-10-31 23:08:24 +00002605 return;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002606 ObjCInterfaceDecl *RCDecl = CDecl->getSuperClass();
Chris Lattnerf3a7af92008-03-16 21:08:55 +00002607 int NumIvars = CDecl->ivar_size();
Steve Narofffea763e82007-11-14 19:25:57 +00002608 SourceLocation LocStart = CDecl->getLocStart();
2609 SourceLocation LocEnd = CDecl->getLocEnd();
2610
2611 const char *startBuf = SM->getCharacterData(LocStart);
2612 const char *endBuf = SM->getCharacterData(LocEnd);
Steve Naroffbaf58c32008-05-31 14:15:04 +00002613
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002614 // If no ivars and no root or if its root, directly or indirectly,
2615 // have no ivars (thus not synthesized) then no need to synthesize this class.
Chris Lattnerf3a7af92008-03-16 21:08:55 +00002616 if ((CDecl->isForwardDecl() || NumIvars == 0) &&
2617 (!RCDecl || !ObjCSynthesizedStructs.count(RCDecl))) {
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002618 endBuf += Lexer::MeasureTokenLength(LocEnd, *SM);
Chris Lattneraadaf782008-01-31 19:51:04 +00002619 ReplaceText(LocStart, endBuf-startBuf, Result.c_str(), Result.size());
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002620 return;
2621 }
2622
2623 // FIXME: This has potential of causing problem. If
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002624 // SynthesizeObjCInternalStruct is ever called recursively.
Fariborz Jahanian2c7038b2007-11-26 19:52:57 +00002625 Result += "\nstruct ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002626 Result += CDecl->getNameAsString();
Steve Naroff61ed9ca2008-03-10 23:16:54 +00002627 if (LangOpts.Microsoft)
2628 Result += "_IMPL";
Steve Naroff05b8c782008-03-12 00:25:36 +00002629
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002630 if (NumIvars > 0) {
Steve Narofffea763e82007-11-14 19:25:57 +00002631 const char *cursor = strchr(startBuf, '{');
2632 assert((cursor && endBuf)
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002633 && "SynthesizeObjCInternalStruct - malformed @interface");
Steve Naroffbaf58c32008-05-31 14:15:04 +00002634 // If the buffer contains preprocessor directives, we do more fine-grained
2635 // rewrites. This is intended to fix code that looks like (which occurs in
2636 // NSURL.h, for example):
2637 //
2638 // #ifdef XYZ
2639 // @interface Foo : NSObject
2640 // #else
2641 // @interface FooBar : NSObject
2642 // #endif
2643 // {
2644 // int i;
2645 // }
2646 // @end
2647 //
2648 // This clause is segregated to avoid breaking the common case.
2649 if (BufferContainsPPDirectives(startBuf, cursor)) {
2650 SourceLocation L = RCDecl ? CDecl->getSuperClassLoc() :
2651 CDecl->getClassLoc();
2652 const char *endHeader = SM->getCharacterData(L);
2653 endHeader += Lexer::MeasureTokenLength(L, *SM);
2654
Chris Lattner3db6cae2008-07-21 18:19:38 +00002655 if (!CDecl->getReferencedProtocols().empty()) {
Steve Naroffbaf58c32008-05-31 14:15:04 +00002656 // advance to the end of the referenced protocols.
2657 while (endHeader < cursor && *endHeader != '>') endHeader++;
2658 endHeader++;
2659 }
2660 // rewrite the original header
2661 ReplaceText(LocStart, endHeader-startBuf, Result.c_str(), Result.size());
2662 } else {
2663 // rewrite the original header *without* disturbing the '{'
2664 ReplaceText(LocStart, cursor-startBuf-1, Result.c_str(), Result.size());
2665 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002666 if (RCDecl && ObjCSynthesizedStructs.count(RCDecl)) {
Steve Narofffea763e82007-11-14 19:25:57 +00002667 Result = "\n struct ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002668 Result += RCDecl->getNameAsString();
Steve Naroff39bbd9f2008-03-12 21:09:20 +00002669 Result += "_IMPL ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002670 Result += RCDecl->getNameAsString();
Steve Naroff819173c2008-03-12 21:22:52 +00002671 Result += "_IVARS;\n";
Steve Narofffea763e82007-11-14 19:25:57 +00002672
2673 // insert the super class structure definition.
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002674 SourceLocation OnePastCurly =
2675 LocStart.getFileLocWithOffset(cursor-startBuf+1);
2676 InsertText(OnePastCurly, Result.c_str(), Result.size());
Steve Narofffea763e82007-11-14 19:25:57 +00002677 }
2678 cursor++; // past '{'
2679
2680 // Now comment out any visibility specifiers.
2681 while (cursor < endBuf) {
2682 if (*cursor == '@') {
2683 SourceLocation atLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
Chris Lattnerdf6a51b2007-11-14 22:57:51 +00002684 // Skip whitespace.
2685 for (++cursor; cursor[0] == ' ' || cursor[0] == '\t'; ++cursor)
2686 /*scan*/;
2687
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002688 // FIXME: presence of @public, etc. inside comment results in
2689 // this transformation as well, which is still correct c-code.
Steve Narofffea763e82007-11-14 19:25:57 +00002690 if (!strncmp(cursor, "public", strlen("public")) ||
2691 !strncmp(cursor, "private", strlen("private")) ||
Steve Naroffc5e32772008-04-04 22:34:24 +00002692 !strncmp(cursor, "package", strlen("package")) ||
Fariborz Jahanian95673922007-11-14 22:26:25 +00002693 !strncmp(cursor, "protected", strlen("protected")))
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002694 InsertText(atLoc, "// ", 3);
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002695 }
Fariborz Jahanian95673922007-11-14 22:26:25 +00002696 // FIXME: If there are cases where '<' is used in ivar declaration part
2697 // of user code, then scan the ivar list and use needToScanForQualifiers
2698 // for type checking.
2699 else if (*cursor == '<') {
2700 SourceLocation atLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002701 InsertText(atLoc, "/* ", 3);
Fariborz Jahanian95673922007-11-14 22:26:25 +00002702 cursor = strchr(cursor, '>');
2703 cursor++;
2704 atLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002705 InsertText(atLoc, " */", 3);
Steve Naroffced80a82008-10-30 12:09:33 +00002706 } else if (*cursor == '^') { // rewrite block specifier.
2707 SourceLocation caretLoc = LocStart.getFileLocWithOffset(cursor-startBuf);
2708 ReplaceText(caretLoc, 1, "*", 1);
Fariborz Jahanian95673922007-11-14 22:26:25 +00002709 }
Steve Narofffea763e82007-11-14 19:25:57 +00002710 cursor++;
Fariborz Jahanianfdc08a02007-10-31 17:29:28 +00002711 }
Steve Narofffea763e82007-11-14 19:25:57 +00002712 // Don't forget to add a ';'!!
Chris Lattnerf3dd57e2008-01-31 19:42:41 +00002713 InsertText(LocEnd.getFileLocWithOffset(1), ";", 1);
Steve Narofffea763e82007-11-14 19:25:57 +00002714 } else { // we don't have any instance variables - insert super struct.
2715 endBuf += Lexer::MeasureTokenLength(LocEnd, *SM);
2716 Result += " {\n struct ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002717 Result += RCDecl->getNameAsString();
Steve Naroff39bbd9f2008-03-12 21:09:20 +00002718 Result += "_IMPL ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002719 Result += RCDecl->getNameAsString();
Steve Naroff819173c2008-03-12 21:22:52 +00002720 Result += "_IVARS;\n};\n";
Chris Lattneraadaf782008-01-31 19:51:04 +00002721 ReplaceText(LocStart, endBuf-startBuf, Result.c_str(), Result.size());
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002722 }
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002723 // Mark this struct as having been generated.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002724 if (!ObjCSynthesizedStructs.insert(CDecl))
Steve Narofffbfe8252008-05-06 18:26:51 +00002725 assert(false && "struct already synthesize- SynthesizeObjCInternalStruct");
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00002726}
2727
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002728// RewriteObjCMethodsMetaData - Rewrite methods metadata for instance or
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002729/// class methods.
Steve Naroffb29b4272008-04-14 22:03:09 +00002730void RewriteObjC::RewriteObjCMethodsMetaData(instmeth_iterator MethodBegin,
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002731 instmeth_iterator MethodEnd,
Fariborz Jahanian8e991ba2007-10-25 00:14:44 +00002732 bool IsInstanceMethod,
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002733 const char *prefix,
Chris Lattner158ecb92007-10-25 17:07:24 +00002734 const char *ClassName,
2735 std::string &Result) {
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002736 if (MethodBegin == MethodEnd) return;
2737
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002738 static bool objc_impl_method = false;
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002739 if (!objc_impl_method) {
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002740 /* struct _objc_method {
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002741 SEL _cmd;
2742 char *method_types;
2743 void *_imp;
2744 }
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002745 */
Chris Lattner158ecb92007-10-25 17:07:24 +00002746 Result += "\nstruct _objc_method {\n";
2747 Result += "\tSEL _cmd;\n";
2748 Result += "\tchar *method_types;\n";
2749 Result += "\tvoid *_imp;\n";
2750 Result += "};\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002751
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002752 objc_impl_method = true;
Fariborz Jahanian776d6ff2007-10-19 00:36:46 +00002753 }
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002754
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002755 // Build _objc_method_list for class's methods if needed
Steve Naroff946a6932008-03-11 00:12:29 +00002756
2757 /* struct {
2758 struct _objc_method_list *next_method;
2759 int method_count;
2760 struct _objc_method method_list[];
2761 }
2762 */
2763 Result += "\nstatic struct {\n";
2764 Result += "\tstruct _objc_method_list *next_method;\n";
2765 Result += "\tint method_count;\n";
2766 Result += "\tstruct _objc_method method_list[";
2767 Result += utostr(MethodEnd-MethodBegin);
2768 Result += "];\n} _OBJC_";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002769 Result += prefix;
2770 Result += IsInstanceMethod ? "INSTANCE" : "CLASS";
2771 Result += "_METHODS_";
2772 Result += ClassName;
Steve Naroffdbb65432008-03-12 17:18:30 +00002773 Result += " __attribute__ ((used, section (\"__OBJC, __";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002774 Result += IsInstanceMethod ? "inst" : "cls";
2775 Result += "_meth\")))= ";
2776 Result += "{\n\t0, " + utostr(MethodEnd-MethodBegin) + "\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002777
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002778 Result += "\t,{{(SEL)\"";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002779 Result += (*MethodBegin)->getSelector().getAsString().c_str();
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002780 std::string MethodTypeString;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002781 Context->getObjCEncodingForMethodDecl(*MethodBegin, MethodTypeString);
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002782 Result += "\", \"";
2783 Result += MethodTypeString;
Steve Naroff946a6932008-03-11 00:12:29 +00002784 Result += "\", (void *)";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002785 Result += MethodInternalNames[*MethodBegin];
2786 Result += "}\n";
2787 for (++MethodBegin; MethodBegin != MethodEnd; ++MethodBegin) {
2788 Result += "\t ,{(SEL)\"";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002789 Result += (*MethodBegin)->getSelector().getAsString().c_str();
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002790 std::string MethodTypeString;
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002791 Context->getObjCEncodingForMethodDecl(*MethodBegin, MethodTypeString);
Fariborz Jahanian33e1d642007-10-29 22:57:28 +00002792 Result += "\", \"";
2793 Result += MethodTypeString;
Steve Naroff946a6932008-03-11 00:12:29 +00002794 Result += "\", (void *)";
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002795 Result += MethodInternalNames[*MethodBegin];
Fariborz Jahanianb7908b52007-11-13 21:02:00 +00002796 Result += "}\n";
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002797 }
Chris Lattnerab4c4d52007-12-12 07:46:12 +00002798 Result += "\t }\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002799}
2800
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002801/// RewriteObjCProtocolsMetaData - Rewrite protocols meta-data.
Chris Lattner780f3292008-07-21 21:32:27 +00002802void RewriteObjC::
2803RewriteObjCProtocolsMetaData(const ObjCList<ObjCProtocolDecl> &Protocols,
2804 const char *prefix,
2805 const char *ClassName,
2806 std::string &Result) {
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002807 static bool objc_protocol_methods = false;
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002808 if (Protocols.empty()) return;
2809
2810 for (unsigned i = 0; i != Protocols.size(); i++) {
2811 ObjCProtocolDecl *PDecl = Protocols[i];
2812 // Output struct protocol_methods holder of method selector and type.
2813 if (!objc_protocol_methods && !PDecl->isForwardDecl()) {
2814 /* struct protocol_methods {
2815 SEL _cmd;
2816 char *method_types;
2817 }
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002818 */
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002819 Result += "\nstruct protocol_methods {\n";
2820 Result += "\tSEL _cmd;\n";
2821 Result += "\tchar *method_types;\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002822 Result += "};\n";
Steve Narofffbfe8252008-05-06 18:26:51 +00002823
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002824 objc_protocol_methods = true;
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002825 }
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002826 // Do not synthesize the protocol more than once.
2827 if (ObjCSynthesizedProtocols.count(PDecl))
2828 continue;
2829
2830 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) {
2831 unsigned NumMethods = PDecl->getNumInstanceMethods();
2832 /* struct _objc_protocol_method_list {
2833 int protocol_method_count;
2834 struct protocol_methods protocols[];
2835 }
2836 */
2837 Result += "\nstatic struct {\n";
2838 Result += "\tint protocol_method_count;\n";
2839 Result += "\tstruct protocol_methods protocols[";
2840 Result += utostr(NumMethods);
2841 Result += "];\n} _OBJC_PROTOCOL_INSTANCE_METHODS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002842 Result += PDecl->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002843 Result += " __attribute__ ((used, section (\"__OBJC, __cat_inst_meth\")))= "
2844 "{\n\t" + utostr(NumMethods) + "\n";
2845
2846 // Output instance methods declared in this protocol.
2847 for (ObjCProtocolDecl::instmeth_iterator I = PDecl->instmeth_begin(),
2848 E = PDecl->instmeth_end(); I != E; ++I) {
2849 if (I == PDecl->instmeth_begin())
2850 Result += "\t ,{{(SEL)\"";
2851 else
2852 Result += "\t ,{(SEL)\"";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002853 Result += (*I)->getSelector().getAsString().c_str();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002854 std::string MethodTypeString;
2855 Context->getObjCEncodingForMethodDecl((*I), MethodTypeString);
2856 Result += "\", \"";
2857 Result += MethodTypeString;
2858 Result += "\"}\n";
2859 }
2860 Result += "\t }\n};\n";
2861 }
2862
2863 // Output class methods declared in this protocol.
2864 int NumMethods = PDecl->getNumClassMethods();
2865 if (NumMethods > 0) {
2866 /* struct _objc_protocol_method_list {
2867 int protocol_method_count;
2868 struct protocol_methods protocols[];
2869 }
2870 */
2871 Result += "\nstatic struct {\n";
2872 Result += "\tint protocol_method_count;\n";
2873 Result += "\tstruct protocol_methods protocols[";
2874 Result += utostr(NumMethods);
2875 Result += "];\n} _OBJC_PROTOCOL_CLASS_METHODS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002876 Result += PDecl->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002877 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= "
2878 "{\n\t";
2879 Result += utostr(NumMethods);
2880 Result += "\n";
2881
2882 // Output instance methods declared in this protocol.
2883 for (ObjCProtocolDecl::classmeth_iterator I = PDecl->classmeth_begin(),
2884 E = PDecl->classmeth_end(); I != E; ++I) {
2885 if (I == PDecl->classmeth_begin())
2886 Result += "\t ,{{(SEL)\"";
2887 else
2888 Result += "\t ,{(SEL)\"";
Chris Lattner077bf5e2008-11-24 03:33:13 +00002889 Result += (*I)->getSelector().getAsString().c_str();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002890 std::string MethodTypeString;
2891 Context->getObjCEncodingForMethodDecl((*I), MethodTypeString);
2892 Result += "\", \"";
2893 Result += MethodTypeString;
2894 Result += "\"}\n";
2895 }
2896 Result += "\t }\n};\n";
2897 }
2898
2899 // Output:
2900 /* struct _objc_protocol {
2901 // Objective-C 1.0 extensions
2902 struct _objc_protocol_extension *isa;
2903 char *protocol_name;
2904 struct _objc_protocol **protocol_list;
2905 struct _objc_protocol_method_list *instance_methods;
2906 struct _objc_protocol_method_list *class_methods;
2907 };
Steve Naroff8eb4a5e2008-03-12 01:06:30 +00002908 */
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002909 static bool objc_protocol = false;
2910 if (!objc_protocol) {
2911 Result += "\nstruct _objc_protocol {\n";
2912 Result += "\tstruct _objc_protocol_extension *isa;\n";
2913 Result += "\tchar *protocol_name;\n";
2914 Result += "\tstruct _objc_protocol **protocol_list;\n";
2915 Result += "\tstruct _objc_protocol_method_list *instance_methods;\n";
2916 Result += "\tstruct _objc_protocol_method_list *class_methods;\n";
2917 Result += "};\n";
2918
2919 objc_protocol = true;
2920 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002921
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002922 Result += "\nstatic struct _objc_protocol _OBJC_PROTOCOL_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002923 Result += PDecl->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002924 Result += " __attribute__ ((used, section (\"__OBJC, __protocol\")))= "
2925 "{\n\t0, \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002926 Result += PDecl->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002927 Result += "\", 0, ";
2928 if (PDecl->instmeth_begin() != PDecl->instmeth_end()) {
2929 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_INSTANCE_METHODS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002930 Result += PDecl->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002931 Result += ", ";
2932 }
2933 else
2934 Result += "0, ";
2935 if (PDecl->getNumClassMethods() > 0) {
2936 Result += "(struct _objc_protocol_method_list *)&_OBJC_PROTOCOL_CLASS_METHODS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002937 Result += PDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002938 Result += "\n";
Fariborz Jahaniane887c092007-10-22 21:41:37 +00002939 }
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002940 else
2941 Result += "0\n";
2942 Result += "};\n";
2943
2944 // Mark this protocol as having been generated.
2945 if (!ObjCSynthesizedProtocols.insert(PDecl))
2946 assert(false && "protocol already synthesized");
2947 }
2948 // Output the top lovel protocol meta-data for the class.
2949 /* struct _objc_protocol_list {
2950 struct _objc_protocol_list *next;
2951 int protocol_count;
2952 struct _objc_protocol *class_protocols[];
2953 }
2954 */
2955 Result += "\nstatic struct {\n";
2956 Result += "\tstruct _objc_protocol_list *next;\n";
2957 Result += "\tint protocol_count;\n";
2958 Result += "\tstruct _objc_protocol *class_protocols[";
2959 Result += utostr(Protocols.size());
2960 Result += "];\n} _OBJC_";
2961 Result += prefix;
2962 Result += "_PROTOCOLS_";
2963 Result += ClassName;
2964 Result += " __attribute__ ((used, section (\"__OBJC, __cat_cls_meth\")))= "
2965 "{\n\t0, ";
2966 Result += utostr(Protocols.size());
2967 Result += "\n";
2968
2969 Result += "\t,{&_OBJC_PROTOCOL_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002970 Result += Protocols[0]->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002971 Result += " \n";
2972
2973 for (unsigned i = 1; i != Protocols.size(); i++) {
2974 Result += "\t ,&_OBJC_PROTOCOL_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002975 Result += Protocols[i]->getNameAsString();
Chris Lattner9d0aaa12008-07-21 21:33:21 +00002976 Result += "\n";
2977 }
2978 Result += "\t }\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002979}
2980
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002981/// RewriteObjCCategoryImplDecl - Rewrite metadata for each category
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002982/// implementation.
Steve Naroffb29b4272008-04-14 22:03:09 +00002983void RewriteObjC::RewriteObjCCategoryImplDecl(ObjCCategoryImplDecl *IDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00002984 std::string &Result) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002985 ObjCInterfaceDecl *ClassDecl = IDecl->getClassInterface();
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002986 // Find category declaration for this implementation.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002987 ObjCCategoryDecl *CDecl;
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002988 for (CDecl = ClassDecl->getCategoryList(); CDecl;
2989 CDecl = CDecl->getNextClassCategory())
2990 if (CDecl->getIdentifier() == IDecl->getIdentifier())
2991 break;
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002992
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002993 std::string FullCategoryName = ClassDecl->getNameAsString();
Chris Lattnereb44eee2007-12-23 01:40:15 +00002994 FullCategoryName += '_';
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00002995 FullCategoryName += IDecl->getNameAsString();
Chris Lattnereb44eee2007-12-23 01:40:15 +00002996
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00002997 // Build _objc_method_list for class's instance methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002998 RewriteObjCMethodsMetaData(IDecl->instmeth_begin(), IDecl->instmeth_end(),
Chris Lattnereb44eee2007-12-23 01:40:15 +00002999 true, "CATEGORY_", FullCategoryName.c_str(),
3000 Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003001
3002 // Build _objc_method_list for class's class methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003003 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(),
Chris Lattnereb44eee2007-12-23 01:40:15 +00003004 false, "CATEGORY_", FullCategoryName.c_str(),
3005 Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003006
3007 // Protocols referenced in class declaration?
Fariborz Jahanianbac97d42007-11-13 22:09:49 +00003008 // Null CDecl is case of a category implementation with no category interface
3009 if (CDecl)
Chris Lattner780f3292008-07-21 21:32:27 +00003010 RewriteObjCProtocolsMetaData(CDecl->getReferencedProtocols(), "CATEGORY",
Chris Lattnereb44eee2007-12-23 01:40:15 +00003011 FullCategoryName.c_str(), Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003012
3013 /* struct _objc_category {
3014 char *category_name;
3015 char *class_name;
3016 struct _objc_method_list *instance_methods;
3017 struct _objc_method_list *class_methods;
3018 struct _objc_protocol_list *protocols;
3019 // Objective-C 1.0 extensions
3020 uint32_t size; // sizeof (struct _objc_category)
3021 struct _objc_property_list *instance_properties; // category's own
3022 // @property decl.
3023 };
3024 */
3025
3026 static bool objc_category = false;
3027 if (!objc_category) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003028 Result += "\nstruct _objc_category {\n";
3029 Result += "\tchar *category_name;\n";
3030 Result += "\tchar *class_name;\n";
3031 Result += "\tstruct _objc_method_list *instance_methods;\n";
3032 Result += "\tstruct _objc_method_list *class_methods;\n";
3033 Result += "\tstruct _objc_protocol_list *protocols;\n";
3034 Result += "\tunsigned int size;\n";
3035 Result += "\tstruct _objc_property_list *instance_properties;\n";
3036 Result += "};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003037 objc_category = true;
Fariborz Jahaniane887c092007-10-22 21:41:37 +00003038 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003039 Result += "\nstatic struct _objc_category _OBJC_CATEGORY_";
3040 Result += FullCategoryName;
Steve Naroffdbb65432008-03-12 17:18:30 +00003041 Result += " __attribute__ ((used, section (\"__OBJC, __category\")))= {\n\t\"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003042 Result += IDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003043 Result += "\"\n\t, \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003044 Result += ClassDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003045 Result += "\"\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003046
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003047 if (IDecl->getNumInstanceMethods() > 0) {
3048 Result += "\t, (struct _objc_method_list *)"
3049 "&_OBJC_CATEGORY_INSTANCE_METHODS_";
3050 Result += FullCategoryName;
3051 Result += "\n";
3052 }
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003053 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003054 Result += "\t, 0\n";
3055 if (IDecl->getNumClassMethods() > 0) {
3056 Result += "\t, (struct _objc_method_list *)"
3057 "&_OBJC_CATEGORY_CLASS_METHODS_";
3058 Result += FullCategoryName;
3059 Result += "\n";
3060 }
3061 else
3062 Result += "\t, 0\n";
3063
Chris Lattner780f3292008-07-21 21:32:27 +00003064 if (CDecl && !CDecl->getReferencedProtocols().empty()) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003065 Result += "\t, (struct _objc_protocol_list *)&_OBJC_CATEGORY_PROTOCOLS_";
3066 Result += FullCategoryName;
3067 Result += "\n";
3068 }
3069 else
3070 Result += "\t, 0\n";
3071 Result += "\t, sizeof(struct _objc_category), 0\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003072}
3073
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003074/// SynthesizeIvarOffsetComputation - This rutine synthesizes computation of
3075/// ivar offset.
Steve Naroffb29b4272008-04-14 22:03:09 +00003076void RewriteObjC::SynthesizeIvarOffsetComputation(ObjCImplementationDecl *IDecl,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003077 ObjCIvarDecl *ivar,
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003078 std::string &Result) {
Steve Naroff8f3b2652008-07-16 18:22:22 +00003079 if (ivar->isBitField()) {
3080 // FIXME: The hack below doesn't work for bitfields. For now, we simply
3081 // place all bitfields at offset 0.
3082 Result += "0";
3083 } else {
3084 Result += "__OFFSETOFIVAR__(struct ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003085 Result += IDecl->getNameAsString();
Steve Naroff8f3b2652008-07-16 18:22:22 +00003086 if (LangOpts.Microsoft)
3087 Result += "_IMPL";
3088 Result += ", ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003089 Result += ivar->getNameAsString();
Steve Naroff8f3b2652008-07-16 18:22:22 +00003090 Result += ")";
3091 }
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003092}
3093
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003094//===----------------------------------------------------------------------===//
3095// Meta Data Emission
3096//===----------------------------------------------------------------------===//
3097
Steve Naroffb29b4272008-04-14 22:03:09 +00003098void RewriteObjC::RewriteObjCClassMetaData(ObjCImplementationDecl *IDecl,
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003099 std::string &Result) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003100 ObjCInterfaceDecl *CDecl = IDecl->getClassInterface();
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003101
Fariborz Jahanianebe668f2007-11-26 20:59:57 +00003102 // Explictly declared @interface's are already synthesized.
3103 if (CDecl->ImplicitInterfaceDecl()) {
3104 // FIXME: Implementation of a class with no @interface (legacy) doese not
3105 // produce correct synthesis as yet.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003106 SynthesizeObjCInternalStruct(CDecl, Result);
Fariborz Jahanianebe668f2007-11-26 20:59:57 +00003107 }
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003108
Chris Lattnerbe6df082007-12-12 07:56:42 +00003109 // Build _objc_ivar_list metadata for classes ivars if needed
Chris Lattnerf3a7af92008-03-16 21:08:55 +00003110 unsigned NumIvars = !IDecl->ivar_empty()
3111 ? IDecl->ivar_size()
3112 : (CDecl ? CDecl->ivar_size() : 0);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003113 if (NumIvars > 0) {
3114 static bool objc_ivar = false;
3115 if (!objc_ivar) {
3116 /* struct _objc_ivar {
3117 char *ivar_name;
3118 char *ivar_type;
3119 int ivar_offset;
3120 };
3121 */
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003122 Result += "\nstruct _objc_ivar {\n";
3123 Result += "\tchar *ivar_name;\n";
3124 Result += "\tchar *ivar_type;\n";
3125 Result += "\tint ivar_offset;\n";
3126 Result += "};\n";
3127
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003128 objc_ivar = true;
3129 }
3130
Steve Naroff946a6932008-03-11 00:12:29 +00003131 /* struct {
3132 int ivar_count;
3133 struct _objc_ivar ivar_list[nIvars];
3134 };
3135 */
3136 Result += "\nstatic struct {\n";
3137 Result += "\tint ivar_count;\n";
3138 Result += "\tstruct _objc_ivar ivar_list[";
3139 Result += utostr(NumIvars);
3140 Result += "];\n} _OBJC_INSTANCE_VARIABLES_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003141 Result += IDecl->getNameAsString();
Steve Naroffdbb65432008-03-12 17:18:30 +00003142 Result += " __attribute__ ((used, section (\"__OBJC, __instance_vars\")))= "
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003143 "{\n\t";
3144 Result += utostr(NumIvars);
3145 Result += "\n";
Chris Lattnerbe6df082007-12-12 07:56:42 +00003146
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003147 ObjCInterfaceDecl::ivar_iterator IVI, IVE;
Chris Lattnerf3a7af92008-03-16 21:08:55 +00003148 if (!IDecl->ivar_empty()) {
Chris Lattnerbe6df082007-12-12 07:56:42 +00003149 IVI = IDecl->ivar_begin();
3150 IVE = IDecl->ivar_end();
3151 } else {
3152 IVI = CDecl->ivar_begin();
3153 IVE = CDecl->ivar_end();
3154 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003155 Result += "\t,{{\"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003156 Result += (*IVI)->getNameAsString();
Fariborz Jahanian160eb652007-10-29 17:16:25 +00003157 Result += "\", \"";
3158 std::string StrEncoding;
Daniel Dunbar0d504c12008-10-17 20:21:44 +00003159 Context->getObjCEncodingForType((*IVI)->getType(), StrEncoding);
Fariborz Jahanian160eb652007-10-29 17:16:25 +00003160 Result += StrEncoding;
3161 Result += "\", ";
Chris Lattnerbe6df082007-12-12 07:56:42 +00003162 SynthesizeIvarOffsetComputation(IDecl, *IVI, Result);
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003163 Result += "}\n";
Chris Lattnerbe6df082007-12-12 07:56:42 +00003164 for (++IVI; IVI != IVE; ++IVI) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003165 Result += "\t ,{\"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003166 Result += (*IVI)->getNameAsString();
Fariborz Jahanian160eb652007-10-29 17:16:25 +00003167 Result += "\", \"";
3168 std::string StrEncoding;
Daniel Dunbar0d504c12008-10-17 20:21:44 +00003169 Context->getObjCEncodingForType((*IVI)->getType(), StrEncoding);
Fariborz Jahanian160eb652007-10-29 17:16:25 +00003170 Result += StrEncoding;
3171 Result += "\", ";
Chris Lattnerbe6df082007-12-12 07:56:42 +00003172 SynthesizeIvarOffsetComputation(IDecl, (*IVI), Result);
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003173 Result += "}\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003174 }
3175
3176 Result += "\t }\n};\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003177 }
3178
3179 // Build _objc_method_list for class's instance methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003180 RewriteObjCMethodsMetaData(IDecl->instmeth_begin(), IDecl->instmeth_end(),
Chris Lattner8ec03f52008-11-24 03:54:41 +00003181 true, "", IDecl->getNameAsCString(), Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003182
3183 // Build _objc_method_list for class's class methods if needed
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003184 RewriteObjCMethodsMetaData(IDecl->classmeth_begin(), IDecl->classmeth_end(),
Chris Lattner8ec03f52008-11-24 03:54:41 +00003185 false, "", IDecl->getNameAsCString(), Result);
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003186
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003187 // Protocols referenced in class declaration?
Chris Lattner780f3292008-07-21 21:32:27 +00003188 RewriteObjCProtocolsMetaData(CDecl->getReferencedProtocols(),
Chris Lattner8ec03f52008-11-24 03:54:41 +00003189 "CLASS", CDecl->getNameAsCString(), Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003190
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003191
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003192 // Declaration of class/meta-class metadata
3193 /* struct _objc_class {
3194 struct _objc_class *isa; // or const char *root_class_name when metadata
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003195 const char *super_class_name;
3196 char *name;
3197 long version;
3198 long info;
3199 long instance_size;
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003200 struct _objc_ivar_list *ivars;
3201 struct _objc_method_list *methods;
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003202 struct objc_cache *cache;
3203 struct objc_protocol_list *protocols;
3204 const char *ivar_layout;
3205 struct _objc_class_ext *ext;
3206 };
3207 */
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003208 static bool objc_class = false;
3209 if (!objc_class) {
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003210 Result += "\nstruct _objc_class {\n";
3211 Result += "\tstruct _objc_class *isa;\n";
3212 Result += "\tconst char *super_class_name;\n";
3213 Result += "\tchar *name;\n";
3214 Result += "\tlong version;\n";
3215 Result += "\tlong info;\n";
3216 Result += "\tlong instance_size;\n";
3217 Result += "\tstruct _objc_ivar_list *ivars;\n";
3218 Result += "\tstruct _objc_method_list *methods;\n";
3219 Result += "\tstruct objc_cache *cache;\n";
3220 Result += "\tstruct _objc_protocol_list *protocols;\n";
3221 Result += "\tconst char *ivar_layout;\n";
3222 Result += "\tstruct _objc_class_ext *ext;\n";
3223 Result += "};\n";
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003224 objc_class = true;
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003225 }
3226
3227 // Meta-class metadata generation.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003228 ObjCInterfaceDecl *RootClass = 0;
3229 ObjCInterfaceDecl *SuperClass = CDecl->getSuperClass();
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003230 while (SuperClass) {
3231 RootClass = SuperClass;
3232 SuperClass = SuperClass->getSuperClass();
3233 }
3234 SuperClass = CDecl->getSuperClass();
3235
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003236 Result += "\nstatic struct _objc_class _OBJC_METACLASS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003237 Result += CDecl->getNameAsString();
Steve Naroffdbb65432008-03-12 17:18:30 +00003238 Result += " __attribute__ ((used, section (\"__OBJC, __meta_class\")))= "
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003239 "{\n\t(struct _objc_class *)\"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003240 Result += (RootClass ? RootClass->getNameAsString() : CDecl->getNameAsString());
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003241 Result += "\"";
3242
3243 if (SuperClass) {
3244 Result += ", \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003245 Result += SuperClass->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003246 Result += "\", \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003247 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003248 Result += "\"";
3249 }
3250 else {
3251 Result += ", 0, \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003252 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003253 Result += "\"";
3254 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003255 // Set 'ivars' field for root class to 0. ObjC1 runtime does not use it.
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003256 // 'info' field is initialized to CLS_META(2) for metaclass
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003257 Result += ", 0,2, sizeof(struct _objc_class), 0";
Steve Naroffb26d7132007-12-05 21:49:40 +00003258 if (IDecl->getNumClassMethods() > 0) {
Steve Naroff23f41272008-03-11 18:14:26 +00003259 Result += "\n\t, (struct _objc_method_list *)&_OBJC_CLASS_METHODS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003260 Result += IDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003261 Result += "\n";
3262 }
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003263 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003264 Result += ", 0\n";
Chris Lattner3db6cae2008-07-21 18:19:38 +00003265 if (!CDecl->getReferencedProtocols().empty()) {
Steve Naroff8eb4a5e2008-03-12 01:06:30 +00003266 Result += "\t,0, (struct _objc_protocol_list *)&_OBJC_CLASS_PROTOCOLS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003267 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003268 Result += ",0,0\n";
3269 }
Fariborz Jahanian454cb012007-10-24 20:54:23 +00003270 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003271 Result += "\t,0,0,0,0\n";
3272 Result += "};\n";
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003273
3274 // class metadata generation.
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003275 Result += "\nstatic struct _objc_class _OBJC_CLASS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003276 Result += CDecl->getNameAsString();
Steve Naroffdbb65432008-03-12 17:18:30 +00003277 Result += " __attribute__ ((used, section (\"__OBJC, __class\")))= "
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003278 "{\n\t&_OBJC_METACLASS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003279 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003280 if (SuperClass) {
3281 Result += ", \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003282 Result += SuperClass->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003283 Result += "\", \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003284 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003285 Result += "\"";
3286 }
3287 else {
3288 Result += ", 0, \"";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003289 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003290 Result += "\"";
3291 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003292 // 'info' field is initialized to CLS_CLASS(1) for class
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003293 Result += ", 0,1";
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003294 if (!ObjCSynthesizedStructs.count(CDecl))
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003295 Result += ",0";
3296 else {
3297 // class has size. Must synthesize its size.
Fariborz Jahanian909f02a2007-11-05 17:47:33 +00003298 Result += ",sizeof(struct ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003299 Result += CDecl->getNameAsString();
Steve Naroffba9ac4e2008-03-10 23:33:22 +00003300 if (LangOpts.Microsoft)
3301 Result += "_IMPL";
Fariborz Jahanian4d733d32007-10-26 23:09:28 +00003302 Result += ")";
3303 }
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003304 if (NumIvars > 0) {
Steve Naroffc0a123c2008-03-11 17:37:02 +00003305 Result += ", (struct _objc_ivar_list *)&_OBJC_INSTANCE_VARIABLES_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003306 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003307 Result += "\n\t";
3308 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003309 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003310 Result += ",0";
3311 if (IDecl->getNumInstanceMethods() > 0) {
Steve Naroff946a6932008-03-11 00:12:29 +00003312 Result += ", (struct _objc_method_list *)&_OBJC_INSTANCE_METHODS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003313 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003314 Result += ", 0\n\t";
3315 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003316 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003317 Result += ",0,0";
Chris Lattner3db6cae2008-07-21 18:19:38 +00003318 if (!CDecl->getReferencedProtocols().empty()) {
Steve Naroff8eb4a5e2008-03-12 01:06:30 +00003319 Result += ", (struct _objc_protocol_list*)&_OBJC_CLASS_PROTOCOLS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003320 Result += CDecl->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003321 Result += ", 0,0\n";
3322 }
Fariborz Jahaniandeef5182007-10-23 18:53:48 +00003323 else
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003324 Result += ",0,0,0\n";
3325 Result += "};\n";
Fariborz Jahanian9f0a1cb2007-10-23 00:02:02 +00003326}
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003327
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +00003328/// RewriteImplementations - This routine rewrites all method implementations
3329/// and emits meta-data.
3330
Steve Narofface66252008-11-13 20:07:04 +00003331void RewriteObjC::RewriteImplementations() {
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003332 int ClsDefCount = ClassImplementation.size();
3333 int CatDefCount = CategoryImplementation.size();
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +00003334
Fariborz Jahanian7a3279d2007-11-13 19:21:13 +00003335 // Rewrite implemented methods
3336 for (int i = 0; i < ClsDefCount; i++)
3337 RewriteImplementationDecl(ClassImplementation[i]);
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003338
Fariborz Jahanian66d6b292007-11-13 20:04:28 +00003339 for (int i = 0; i < CatDefCount; i++)
3340 RewriteImplementationDecl(CategoryImplementation[i]);
Steve Narofface66252008-11-13 20:07:04 +00003341}
Fariborz Jahanian66d6b292007-11-13 20:04:28 +00003342
Steve Narofface66252008-11-13 20:07:04 +00003343void RewriteObjC::SynthesizeMetaDataIntoBuffer(std::string &Result) {
3344 int ClsDefCount = ClassImplementation.size();
3345 int CatDefCount = CategoryImplementation.size();
3346
Steve Naroff5df5b762008-05-07 21:23:49 +00003347 // This is needed for determining instance variable offsets.
Steve Naroffa11440b2008-08-05 18:47:23 +00003348 Result += "\n#define __OFFSETOFIVAR__(TYPE, MEMBER) ((int) &((TYPE *)0)->MEMBER)\n";
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003349 // For each implemented class, write out all its meta data.
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003350 for (int i = 0; i < ClsDefCount; i++)
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003351 RewriteObjCClassMetaData(ClassImplementation[i], Result);
Fariborz Jahanian2e6d9352007-10-24 19:23:36 +00003352
3353 // For each implemented category, write out all its meta data.
3354 for (int i = 0; i < CatDefCount; i++)
Ted Kremeneka526c5c2008-01-07 19:49:32 +00003355 RewriteObjCCategoryImplDecl(CategoryImplementation[i], Result);
Fariborz Jahanianf4d331d2007-10-18 22:09:03 +00003356
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003357 // Write objc_symtab metadata
3358 /*
3359 struct _objc_symtab
3360 {
3361 long sel_ref_cnt;
3362 SEL *refs;
3363 short cls_def_cnt;
3364 short cat_def_cnt;
3365 void *defs[cls_def_cnt + cat_def_cnt];
3366 };
3367 */
3368
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003369 Result += "\nstruct _objc_symtab {\n";
3370 Result += "\tlong sel_ref_cnt;\n";
3371 Result += "\tSEL *refs;\n";
3372 Result += "\tshort cls_def_cnt;\n";
3373 Result += "\tshort cat_def_cnt;\n";
3374 Result += "\tvoid *defs[" + utostr(ClsDefCount + CatDefCount)+ "];\n";
3375 Result += "};\n\n";
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003376
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003377 Result += "static struct _objc_symtab "
Steve Naroffdbb65432008-03-12 17:18:30 +00003378 "_OBJC_SYMBOLS __attribute__((used, section (\"__OBJC, __symbols\")))= {\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003379 Result += "\t0, 0, " + utostr(ClsDefCount)
3380 + ", " + utostr(CatDefCount) + "\n";
3381 for (int i = 0; i < ClsDefCount; i++) {
3382 Result += "\t,&_OBJC_CLASS_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003383 Result += ClassImplementation[i]->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003384 Result += "\n";
3385 }
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003386
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003387 for (int i = 0; i < CatDefCount; i++) {
3388 Result += "\t,&_OBJC_CATEGORY_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003389 Result += CategoryImplementation[i]->getClassInterface()->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003390 Result += "_";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003391 Result += CategoryImplementation[i]->getNameAsString();
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003392 Result += "\n";
3393 }
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003394
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003395 Result += "};\n\n";
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003396
3397 // Write objc_module metadata
3398
3399 /*
3400 struct _objc_module {
3401 long version;
3402 long size;
3403 const char *name;
3404 struct _objc_symtab *symtab;
3405 }
3406 */
3407
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003408 Result += "\nstruct _objc_module {\n";
3409 Result += "\tlong version;\n";
3410 Result += "\tlong size;\n";
3411 Result += "\tconst char *name;\n";
3412 Result += "\tstruct _objc_symtab *symtab;\n";
3413 Result += "};\n\n";
3414 Result += "static struct _objc_module "
Steve Naroffdbb65432008-03-12 17:18:30 +00003415 "_OBJC_MODULES __attribute__ ((used, section (\"__OBJC, __module_info\")))= {\n";
Fariborz Jahanian26e4cd32007-10-26 19:46:17 +00003416 Result += "\t" + utostr(OBJC_ABI_VERSION) +
3417 ", sizeof(struct _objc_module), \"\", &_OBJC_SYMBOLS\n";
Fariborz Jahanianccd87b02007-10-25 20:55:25 +00003418 Result += "};\n\n";
Steve Naroff4f943c22008-03-10 20:43:59 +00003419
3420 if (LangOpts.Microsoft) {
3421 Result += "#pragma section(\".objc_module_info$B\",long,read,write)\n";
Steve Naroff19190322008-05-07 00:06:16 +00003422 Result += "#pragma data_seg(push, \".objc_module_info$B\")\n";
Steve Naroff4f943c22008-03-10 20:43:59 +00003423 Result += "static struct _objc_module *_POINTER_OBJC_MODULES = ";
3424 Result += "&_OBJC_MODULES;\n";
3425 Result += "#pragma data_seg(pop)\n\n";
3426 }
Fariborz Jahanian545b9ae2007-10-18 19:23:00 +00003427}
Chris Lattner311ff022007-10-16 22:36:42 +00003428
Steve Naroff54055232008-10-27 17:20:55 +00003429std::string RewriteObjC::SynthesizeBlockFunc(BlockExpr *CE, int i,
3430 const char *funcName,
3431 std::string Tag) {
3432 const FunctionType *AFT = CE->getFunctionType();
3433 QualType RT = AFT->getResultType();
3434 std::string StructRef = "struct " + Tag;
3435 std::string S = "static " + RT.getAsString() + " __" +
3436 funcName + "_" + "block_func_" + utostr(i);
Argyrios Kyrtzidisef177822008-04-17 14:40:12 +00003437
Steve Naroff54055232008-10-27 17:20:55 +00003438 BlockDecl *BD = CE->getBlockDecl();
3439
3440 if (isa<FunctionTypeNoProto>(AFT)) {
3441 S += "()";
3442 } else if (BD->param_empty()) {
3443 S += "(" + StructRef + " *__cself)";
3444 } else {
3445 const FunctionTypeProto *FT = cast<FunctionTypeProto>(AFT);
3446 assert(FT && "SynthesizeBlockFunc: No function proto");
3447 S += '(';
3448 // first add the implicit argument.
3449 S += StructRef + " *__cself, ";
3450 std::string ParamStr;
3451 for (BlockDecl::param_iterator AI = BD->param_begin(),
3452 E = BD->param_end(); AI != E; ++AI) {
3453 if (AI != BD->param_begin()) S += ", ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003454 ParamStr = (*AI)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003455 (*AI)->getType().getAsStringInternal(ParamStr);
3456 S += ParamStr;
3457 }
3458 if (FT->isVariadic()) {
3459 if (!BD->param_empty()) S += ", ";
3460 S += "...";
3461 }
3462 S += ')';
3463 }
3464 S += " {\n";
3465
3466 // Create local declarations to avoid rewriting all closure decl ref exprs.
3467 // First, emit a declaration for all "by ref" decls.
3468 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3469 E = BlockByRefDecls.end(); I != E; ++I) {
3470 S += " ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003471 std::string Name = (*I)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003472 Context->getPointerType((*I)->getType()).getAsStringInternal(Name);
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003473 S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by ref\n";
Steve Naroff54055232008-10-27 17:20:55 +00003474 }
3475 // Next, emit a declaration for all "by copy" declarations.
3476 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3477 E = BlockByCopyDecls.end(); I != E; ++I) {
3478 S += " ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003479 std::string Name = (*I)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003480 // Handle nested closure invocation. For example:
3481 //
3482 // void (^myImportedClosure)(void);
3483 // myImportedClosure = ^(void) { setGlobalInt(x + y); };
3484 //
3485 // void (^anotherClosure)(void);
3486 // anotherClosure = ^(void) {
3487 // myImportedClosure(); // import and invoke the closure
3488 // };
3489 //
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003490 if (isTopLevelBlockPointerType((*I)->getType()))
Steve Naroff54055232008-10-27 17:20:55 +00003491 S += "struct __block_impl *";
3492 else
3493 (*I)->getType().getAsStringInternal(Name);
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003494 S += Name + " = __cself->" + (*I)->getNameAsString() + "; // bound by copy\n";
Steve Naroff54055232008-10-27 17:20:55 +00003495 }
3496 std::string RewrittenStr = RewrittenBlockExprs[CE];
3497 const char *cstr = RewrittenStr.c_str();
3498 while (*cstr++ != '{') ;
3499 S += cstr;
3500 S += "\n";
3501 return S;
3502}
Argyrios Kyrtzidis39ba4ae2008-06-09 23:19:58 +00003503
Steve Naroff54055232008-10-27 17:20:55 +00003504std::string RewriteObjC::SynthesizeBlockHelperFuncs(BlockExpr *CE, int i,
3505 const char *funcName,
3506 std::string Tag) {
3507 std::string StructRef = "struct " + Tag;
3508 std::string S = "static void __";
3509
3510 S += funcName;
3511 S += "_block_copy_" + utostr(i);
3512 S += "(" + StructRef;
3513 S += "*dst, " + StructRef;
3514 S += "*src) {";
3515 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(),
3516 E = ImportedBlockDecls.end(); I != E; ++I) {
Steve Naroff5bc60d02008-12-16 15:50:30 +00003517 S += "_Block_object_assign((void*)&dst->";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003518 S += (*I)->getNameAsString();
Steve Naroff47a24222008-12-11 20:51:38 +00003519 S += ", (void*)src->";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003520 S += (*I)->getNameAsString();
Steve Naroff5bc60d02008-12-16 15:50:30 +00003521 S += ", 3/*BLOCK_FIELD_IS_OBJECT*/);}";
Steve Naroff54055232008-10-27 17:20:55 +00003522 }
3523 S += "\nstatic void __";
3524 S += funcName;
3525 S += "_block_dispose_" + utostr(i);
3526 S += "(" + StructRef;
3527 S += "*src) {";
3528 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = ImportedBlockDecls.begin(),
3529 E = ImportedBlockDecls.end(); I != E; ++I) {
Steve Naroff5bc60d02008-12-16 15:50:30 +00003530 S += "_Block_object_dispose((void*)src->";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003531 S += (*I)->getNameAsString();
Steve Naroff5bc60d02008-12-16 15:50:30 +00003532 S += ", 3/*BLOCK_FIELD_IS_OBJECT*/);";
Steve Naroff54055232008-10-27 17:20:55 +00003533 }
3534 S += "}\n";
3535 return S;
3536}
3537
3538std::string RewriteObjC::SynthesizeBlockImpl(BlockExpr *CE, std::string Tag,
3539 bool hasCopyDisposeHelpers) {
Steve Naroffced80a82008-10-30 12:09:33 +00003540 std::string S = "\nstruct " + Tag;
Steve Naroff54055232008-10-27 17:20:55 +00003541 std::string Constructor = " " + Tag;
3542
3543 S += " {\n struct __block_impl impl;\n";
3544
3545 if (hasCopyDisposeHelpers)
3546 S += " void *copy;\n void *dispose;\n";
3547
3548 Constructor += "(void *fp";
3549
3550 if (hasCopyDisposeHelpers)
3551 Constructor += ", void *copyHelp, void *disposeHelp";
3552
3553 if (BlockDeclRefs.size()) {
3554 // Output all "by copy" declarations.
3555 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3556 E = BlockByCopyDecls.end(); I != E; ++I) {
3557 S += " ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003558 std::string FieldName = (*I)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003559 std::string ArgName = "_" + FieldName;
3560 // Handle nested closure invocation. For example:
3561 //
3562 // void (^myImportedBlock)(void);
3563 // myImportedBlock = ^(void) { setGlobalInt(x + y); };
3564 //
3565 // void (^anotherBlock)(void);
3566 // anotherBlock = ^(void) {
3567 // myImportedBlock(); // import and invoke the closure
3568 // };
3569 //
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003570 if (isTopLevelBlockPointerType((*I)->getType())) {
Steve Naroff54055232008-10-27 17:20:55 +00003571 S += "struct __block_impl *";
3572 Constructor += ", void *" + ArgName;
3573 } else {
3574 (*I)->getType().getAsStringInternal(FieldName);
3575 (*I)->getType().getAsStringInternal(ArgName);
3576 Constructor += ", " + ArgName;
3577 }
3578 S += FieldName + ";\n";
3579 }
3580 // Output all "by ref" declarations.
3581 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3582 E = BlockByRefDecls.end(); I != E; ++I) {
3583 S += " ";
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003584 std::string FieldName = (*I)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003585 std::string ArgName = "_" + FieldName;
3586 // Handle nested closure invocation. For example:
3587 //
3588 // void (^myImportedBlock)(void);
3589 // myImportedBlock = ^(void) { setGlobalInt(x + y); };
3590 //
3591 // void (^anotherBlock)(void);
3592 // anotherBlock = ^(void) {
3593 // myImportedBlock(); // import and invoke the closure
3594 // };
3595 //
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003596 if (isTopLevelBlockPointerType((*I)->getType())) {
Steve Naroff54055232008-10-27 17:20:55 +00003597 S += "struct __block_impl *";
3598 Constructor += ", void *" + ArgName;
3599 } else {
3600 Context->getPointerType((*I)->getType()).getAsStringInternal(FieldName);
3601 Context->getPointerType((*I)->getType()).getAsStringInternal(ArgName);
3602 Constructor += ", " + ArgName;
3603 }
3604 S += FieldName + "; // by ref\n";
3605 }
3606 // Finish writing the constructor.
3607 // FIXME: handle NSConcreteGlobalBlock.
3608 Constructor += ", int flags=0) {\n";
3609 Constructor += " impl.isa = 0/*&_NSConcreteStackBlock*/;\n impl.Size = sizeof(";
3610 Constructor += Tag + ");\n impl.Flags = flags;\n impl.FuncPtr = fp;\n";
3611
3612 if (hasCopyDisposeHelpers)
3613 Constructor += " copy = copyHelp;\n dispose = disposeHelp;\n";
3614
3615 // Initialize all "by copy" arguments.
3616 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
3617 E = BlockByCopyDecls.end(); I != E; ++I) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003618 std::string Name = (*I)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003619 Constructor += " ";
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003620 if (isTopLevelBlockPointerType((*I)->getType()))
Steve Naroff54055232008-10-27 17:20:55 +00003621 Constructor += Name + " = (struct __block_impl *)_";
3622 else
3623 Constructor += Name + " = _";
3624 Constructor += Name + ";\n";
3625 }
3626 // Initialize all "by ref" arguments.
3627 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
3628 E = BlockByRefDecls.end(); I != E; ++I) {
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00003629 std::string Name = (*I)->getNameAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003630 Constructor += " ";
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003631 if (isTopLevelBlockPointerType((*I)->getType()))
Steve Naroff54055232008-10-27 17:20:55 +00003632 Constructor += Name + " = (struct __block_impl *)_";
3633 else
3634 Constructor += Name + " = _";
3635 Constructor += Name + ";\n";
3636 }
3637 } else {
3638 // Finish writing the constructor.
3639 // FIXME: handle NSConcreteGlobalBlock.
3640 Constructor += ", int flags=0) {\n";
3641 Constructor += " impl.isa = 0/*&_NSConcreteStackBlock*/;\n impl.Size = sizeof(";
3642 Constructor += Tag + ");\n impl.Flags = flags;\n impl.FuncPtr = fp;\n";
3643 if (hasCopyDisposeHelpers)
3644 Constructor += " copy = copyHelp;\n dispose = disposeHelp;\n";
3645 }
3646 Constructor += " ";
3647 Constructor += "}\n";
3648 S += Constructor;
3649 S += "};\n";
3650 return S;
3651}
3652
3653void RewriteObjC::SynthesizeBlockLiterals(SourceLocation FunLocStart,
3654 const char *FunName) {
3655 // Insert closures that were part of the function.
3656 for (unsigned i = 0; i < Blocks.size(); i++) {
3657
3658 CollectBlockDeclRefInfo(Blocks[i]);
3659
3660 std::string Tag = "__" + std::string(FunName) + "_block_impl_" + utostr(i);
3661
3662 std::string CI = SynthesizeBlockImpl(Blocks[i], Tag,
3663 ImportedBlockDecls.size() > 0);
3664
3665 InsertText(FunLocStart, CI.c_str(), CI.size());
3666
3667 std::string CF = SynthesizeBlockFunc(Blocks[i], i, FunName, Tag);
3668
3669 InsertText(FunLocStart, CF.c_str(), CF.size());
3670
3671 if (ImportedBlockDecls.size()) {
3672 std::string HF = SynthesizeBlockHelperFuncs(Blocks[i], i, FunName, Tag);
3673 InsertText(FunLocStart, HF.c_str(), HF.size());
3674 }
3675
3676 BlockDeclRefs.clear();
3677 BlockByRefDecls.clear();
3678 BlockByCopyDecls.clear();
3679 BlockCallExprs.clear();
3680 ImportedBlockDecls.clear();
3681 }
3682 Blocks.clear();
3683 RewrittenBlockExprs.clear();
3684}
3685
3686void RewriteObjC::InsertBlockLiteralsWithinFunction(FunctionDecl *FD) {
3687 SourceLocation FunLocStart = FD->getTypeSpecStartLoc();
Chris Lattner8ec03f52008-11-24 03:54:41 +00003688 const char *FuncName = FD->getNameAsCString();
Steve Naroff54055232008-10-27 17:20:55 +00003689
3690 SynthesizeBlockLiterals(FunLocStart, FuncName);
3691}
3692
3693void RewriteObjC::InsertBlockLiteralsWithinMethod(ObjCMethodDecl *MD) {
Steve Naroffced80a82008-10-30 12:09:33 +00003694 //fprintf(stderr,"In InsertBlockLiteralsWitinMethod\n");
3695 //SourceLocation FunLocStart = MD->getLocStart();
3696 // FIXME: This hack works around a bug in Rewrite.InsertText().
3697 SourceLocation FunLocStart = MD->getLocStart().getFileLocWithOffset(-1);
Chris Lattner077bf5e2008-11-24 03:33:13 +00003698 std::string FuncName = MD->getSelector().getAsString();
Steve Naroff54055232008-10-27 17:20:55 +00003699 // Convert colons to underscores.
3700 std::string::size_type loc = 0;
3701 while ((loc = FuncName.find(":", loc)) != std::string::npos)
3702 FuncName.replace(loc, 1, "_");
3703
3704 SynthesizeBlockLiterals(FunLocStart, FuncName.c_str());
3705}
3706
3707void RewriteObjC::GetBlockDeclRefExprs(Stmt *S) {
3708 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
3709 CI != E; ++CI)
3710 if (*CI) {
3711 if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI))
3712 GetBlockDeclRefExprs(CBE->getBody());
3713 else
3714 GetBlockDeclRefExprs(*CI);
3715 }
3716 // Handle specific things.
3717 if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(S))
3718 // FIXME: Handle enums.
3719 if (!isa<FunctionDecl>(CDRE->getDecl()))
3720 BlockDeclRefs.push_back(CDRE);
3721 return;
3722}
3723
3724void RewriteObjC::GetBlockCallExprs(Stmt *S) {
3725 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
3726 CI != E; ++CI)
3727 if (*CI) {
3728 if (BlockExpr *CBE = dyn_cast<BlockExpr>(*CI))
3729 GetBlockCallExprs(CBE->getBody());
3730 else
3731 GetBlockCallExprs(*CI);
3732 }
3733
3734 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
3735 if (CE->getCallee()->getType()->isBlockPointerType()) {
3736 BlockCallExprs[dyn_cast<BlockDeclRefExpr>(CE->getCallee())] = CE;
3737 }
3738 }
3739 return;
3740}
3741
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003742Stmt *RewriteObjC::SynthesizeBlockCall(CallExpr *Exp) {
Steve Naroff54055232008-10-27 17:20:55 +00003743 // Navigate to relevant type information.
3744 const char *closureName = 0;
3745 const BlockPointerType *CPT = 0;
3746
3747 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Exp->getCallee())) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00003748 closureName = DRE->getDecl()->getNameAsCString();
Steve Naroff54055232008-10-27 17:20:55 +00003749 CPT = DRE->getType()->getAsBlockPointerType();
3750 } else if (BlockDeclRefExpr *CDRE = dyn_cast<BlockDeclRefExpr>(Exp->getCallee())) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00003751 closureName = CDRE->getDecl()->getNameAsCString();
Steve Naroff54055232008-10-27 17:20:55 +00003752 CPT = CDRE->getType()->getAsBlockPointerType();
3753 } else if (MemberExpr *MExpr = dyn_cast<MemberExpr>(Exp->getCallee())) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00003754 closureName = MExpr->getMemberDecl()->getNameAsCString();
Steve Naroff54055232008-10-27 17:20:55 +00003755 CPT = MExpr->getType()->getAsBlockPointerType();
3756 } else {
3757 assert(1 && "RewriteBlockClass: Bad type");
3758 }
3759 assert(CPT && "RewriteBlockClass: Bad type");
3760 const FunctionType *FT = CPT->getPointeeType()->getAsFunctionType();
3761 assert(FT && "RewriteBlockClass: Bad type");
3762 const FunctionTypeProto *FTP = dyn_cast<FunctionTypeProto>(FT);
3763 // FTP will be null for closures that don't take arguments.
3764
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003765 RecordDecl *RD = RecordDecl::Create(*Context, TagDecl::TK_struct, TUDecl,
3766 SourceLocation(),
3767 &Context->Idents.get("__block_impl"));
3768 QualType PtrBlock = Context->getPointerType(Context->getTagDeclType(RD));
Steve Naroff54055232008-10-27 17:20:55 +00003769
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003770 // Generate a funky cast.
3771 llvm::SmallVector<QualType, 8> ArgTypes;
3772
3773 // Push the block argument type.
3774 ArgTypes.push_back(PtrBlock);
Steve Naroff54055232008-10-27 17:20:55 +00003775 if (FTP) {
3776 for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003777 E = FTP->arg_type_end(); I && (I != E); ++I) {
3778 QualType t = *I;
3779 // Make sure we convert "t (^)(...)" to "t (*)(...)".
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003780 if (isTopLevelBlockPointerType(t)) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003781 const BlockPointerType *BPT = t->getAsBlockPointerType();
3782 t = Context->getPointerType(BPT->getPointeeType());
3783 }
3784 ArgTypes.push_back(t);
3785 }
Steve Naroff54055232008-10-27 17:20:55 +00003786 }
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003787 // Now do the pointer to function cast.
3788 QualType PtrToFuncCastType = Context->getFunctionType(Exp->getType(),
3789 &ArgTypes[0], ArgTypes.size(), false/*no variadic*/, 0);
3790
3791 PtrToFuncCastType = Context->getPointerType(PtrToFuncCastType);
Steve Naroff54055232008-10-27 17:20:55 +00003792
Steve Naroffb2f9e512008-11-03 23:29:32 +00003793 CastExpr *BlkCast = new CStyleCastExpr(PtrBlock, Exp->getCallee(), PtrBlock, SourceLocation(), SourceLocation());
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003794 // Don't forget the parens to enforce the proper binding.
3795 ParenExpr *PE = new ParenExpr(SourceLocation(), SourceLocation(), BlkCast);
3796 //PE->dump();
Steve Naroff54055232008-10-27 17:20:55 +00003797
Douglas Gregor44b43212008-12-11 16:49:14 +00003798 FieldDecl *FD = FieldDecl::Create(*Context, 0, SourceLocation(),
3799 &Context->Idents.get("FuncPtr"), Context->VoidPtrTy,
3800 /*BitWidth=*/0, /*Mutable=*/true, 0);
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003801 MemberExpr *ME = new MemberExpr(PE, true, FD, SourceLocation(), FD->getType());
3802
Steve Naroffb2f9e512008-11-03 23:29:32 +00003803 CastExpr *FunkCast = new CStyleCastExpr(PtrToFuncCastType, ME, PtrToFuncCastType, SourceLocation(), SourceLocation());
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003804 PE = new ParenExpr(SourceLocation(), SourceLocation(), FunkCast);
3805
3806 llvm::SmallVector<Expr*, 8> BlkExprs;
3807 // Add the implicit argument.
3808 BlkExprs.push_back(BlkCast);
3809 // Add the user arguments.
Steve Naroff54055232008-10-27 17:20:55 +00003810 for (CallExpr::arg_iterator I = Exp->arg_begin(),
3811 E = Exp->arg_end(); I != E; ++I) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003812 BlkExprs.push_back(*I);
Steve Naroff54055232008-10-27 17:20:55 +00003813 }
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003814 CallExpr *CE = new CallExpr(PE, &BlkExprs[0], BlkExprs.size(), Exp->getType(), SourceLocation());
3815 return CE;
Steve Naroff54055232008-10-27 17:20:55 +00003816}
3817
3818void RewriteObjC::RewriteBlockCall(CallExpr *Exp) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00003819 Stmt *BlockCall = SynthesizeBlockCall(Exp);
3820 ReplaceStmt(Exp, BlockCall);
Steve Naroff54055232008-10-27 17:20:55 +00003821}
3822
3823void RewriteObjC::RewriteBlockDeclRefExpr(BlockDeclRefExpr *BDRE) {
3824 // FIXME: Add more elaborate code generation required by the ABI.
3825 InsertText(BDRE->getLocStart(), "*", 1);
3826}
3827
Steve Naroffb2f9e512008-11-03 23:29:32 +00003828void RewriteObjC::RewriteCastExpr(CStyleCastExpr *CE) {
3829 SourceLocation LocStart = CE->getLParenLoc();
3830 SourceLocation LocEnd = CE->getRParenLoc();
Steve Narofffa15fd92008-10-28 20:29:00 +00003831
3832 // Need to avoid trying to rewrite synthesized casts.
3833 if (LocStart.isInvalid())
3834 return;
Steve Naroff8f6ce572008-11-03 11:20:24 +00003835 // Need to avoid trying to rewrite casts contained in macros.
3836 if (!Rewriter::isRewritable(LocStart) || !Rewriter::isRewritable(LocEnd))
3837 return;
Steve Narofffa15fd92008-10-28 20:29:00 +00003838
Steve Naroff54055232008-10-27 17:20:55 +00003839 const char *startBuf = SM->getCharacterData(LocStart);
3840 const char *endBuf = SM->getCharacterData(LocEnd);
3841
3842 // advance the location to startArgList.
3843 const char *argPtr = startBuf;
3844
3845 while (*argPtr++ && (argPtr < endBuf)) {
3846 switch (*argPtr) {
3847 case '^':
3848 // Replace the '^' with '*'.
3849 LocStart = LocStart.getFileLocWithOffset(argPtr-startBuf);
3850 ReplaceText(LocStart, 1, "*", 1);
3851 break;
3852 }
3853 }
3854 return;
3855}
3856
3857void RewriteObjC::RewriteBlockPointerFunctionArgs(FunctionDecl *FD) {
3858 SourceLocation DeclLoc = FD->getLocation();
3859 unsigned parenCount = 0;
3860
3861 // We have 1 or more arguments that have closure pointers.
3862 const char *startBuf = SM->getCharacterData(DeclLoc);
3863 const char *startArgList = strchr(startBuf, '(');
3864
3865 assert((*startArgList == '(') && "Rewriter fuzzy parser confused");
3866
3867 parenCount++;
3868 // advance the location to startArgList.
3869 DeclLoc = DeclLoc.getFileLocWithOffset(startArgList-startBuf);
3870 assert((DeclLoc.isValid()) && "Invalid DeclLoc");
3871
3872 const char *argPtr = startArgList;
3873
3874 while (*argPtr++ && parenCount) {
3875 switch (*argPtr) {
3876 case '^':
3877 // Replace the '^' with '*'.
3878 DeclLoc = DeclLoc.getFileLocWithOffset(argPtr-startArgList);
3879 ReplaceText(DeclLoc, 1, "*", 1);
3880 break;
3881 case '(':
3882 parenCount++;
3883 break;
3884 case ')':
3885 parenCount--;
3886 break;
3887 }
3888 }
3889 return;
3890}
3891
3892bool RewriteObjC::PointerTypeTakesAnyBlockArguments(QualType QT) {
3893 const FunctionTypeProto *FTP;
3894 const PointerType *PT = QT->getAsPointerType();
3895 if (PT) {
3896 FTP = PT->getPointeeType()->getAsFunctionTypeProto();
3897 } else {
3898 const BlockPointerType *BPT = QT->getAsBlockPointerType();
3899 assert(BPT && "BlockPointerTypeTakeAnyBlockArguments(): not a block pointer type");
3900 FTP = BPT->getPointeeType()->getAsFunctionTypeProto();
3901 }
3902 if (FTP) {
3903 for (FunctionTypeProto::arg_type_iterator I = FTP->arg_type_begin(),
3904 E = FTP->arg_type_end(); I != E; ++I)
Steve Naroff01f2ffa2008-12-11 21:05:33 +00003905 if (isTopLevelBlockPointerType(*I))
Steve Naroff54055232008-10-27 17:20:55 +00003906 return true;
3907 }
3908 return false;
3909}
3910
3911void RewriteObjC::GetExtentOfArgList(const char *Name,
3912 const char *&LParen, const char *&RParen) {
3913 const char *argPtr = strchr(Name, '(');
3914 assert((*argPtr == '(') && "Rewriter fuzzy parser confused");
3915
3916 LParen = argPtr; // output the start.
3917 argPtr++; // skip past the left paren.
3918 unsigned parenCount = 1;
3919
3920 while (*argPtr && parenCount) {
3921 switch (*argPtr) {
3922 case '(': parenCount++; break;
3923 case ')': parenCount--; break;
3924 default: break;
3925 }
3926 if (parenCount) argPtr++;
3927 }
3928 assert((*argPtr == ')') && "Rewriter fuzzy parser confused");
3929 RParen = argPtr; // output the end
3930}
3931
3932void RewriteObjC::RewriteBlockPointerDecl(NamedDecl *ND) {
3933 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
3934 RewriteBlockPointerFunctionArgs(FD);
3935 return;
3936 }
3937 // Handle Variables and Typedefs.
3938 SourceLocation DeclLoc = ND->getLocation();
3939 QualType DeclT;
3940 if (VarDecl *VD = dyn_cast<VarDecl>(ND))
3941 DeclT = VD->getType();
3942 else if (TypedefDecl *TDD = dyn_cast<TypedefDecl>(ND))
3943 DeclT = TDD->getUnderlyingType();
3944 else if (FieldDecl *FD = dyn_cast<FieldDecl>(ND))
3945 DeclT = FD->getType();
3946 else
3947 assert(0 && "RewriteBlockPointerDecl(): Decl type not yet handled");
3948
3949 const char *startBuf = SM->getCharacterData(DeclLoc);
3950 const char *endBuf = startBuf;
3951 // scan backward (from the decl location) for the end of the previous decl.
3952 while (*startBuf != '^' && *startBuf != ';' && startBuf != MainFileStart)
3953 startBuf--;
3954
3955 // *startBuf != '^' if we are dealing with a pointer to function that
3956 // may take block argument types (which will be handled below).
3957 if (*startBuf == '^') {
3958 // Replace the '^' with '*', computing a negative offset.
3959 DeclLoc = DeclLoc.getFileLocWithOffset(startBuf-endBuf);
3960 ReplaceText(DeclLoc, 1, "*", 1);
3961 }
3962 if (PointerTypeTakesAnyBlockArguments(DeclT)) {
3963 // Replace the '^' with '*' for arguments.
3964 DeclLoc = ND->getLocation();
3965 startBuf = SM->getCharacterData(DeclLoc);
3966 const char *argListBegin, *argListEnd;
3967 GetExtentOfArgList(startBuf, argListBegin, argListEnd);
3968 while (argListBegin < argListEnd) {
3969 if (*argListBegin == '^') {
3970 SourceLocation CaretLoc = DeclLoc.getFileLocWithOffset(argListBegin-startBuf);
3971 ReplaceText(CaretLoc, 1, "*", 1);
3972 }
3973 argListBegin++;
3974 }
3975 }
3976 return;
3977}
3978
3979void RewriteObjC::CollectBlockDeclRefInfo(BlockExpr *Exp) {
3980 // Add initializers for any closure decl refs.
3981 GetBlockDeclRefExprs(Exp->getBody());
3982 if (BlockDeclRefs.size()) {
3983 // Unique all "by copy" declarations.
3984 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
3985 if (!BlockDeclRefs[i]->isByRef())
3986 BlockByCopyDecls.insert(BlockDeclRefs[i]->getDecl());
3987 // Unique all "by ref" declarations.
3988 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
3989 if (BlockDeclRefs[i]->isByRef()) {
3990 BlockByRefDecls.insert(BlockDeclRefs[i]->getDecl());
3991 }
3992 // Find any imported blocks...they will need special attention.
3993 for (unsigned i = 0; i < BlockDeclRefs.size(); i++)
Steve Naroff47a24222008-12-11 20:51:38 +00003994 if (BlockDeclRefs[i]->getType()->isBlockPointerType()) {
Steve Naroff00072682008-11-13 17:40:07 +00003995 GetBlockCallExprs(BlockDeclRefs[i]);
Steve Naroff54055232008-10-27 17:20:55 +00003996 ImportedBlockDecls.insert(BlockDeclRefs[i]->getDecl());
3997 }
3998 }
3999}
4000
Steve Narofffa15fd92008-10-28 20:29:00 +00004001FunctionDecl *RewriteObjC::SynthBlockInitFunctionDecl(const char *name) {
4002 IdentifierInfo *ID = &Context->Idents.get(name);
4003 QualType FType = Context->getFunctionTypeNoProto(Context->VoidPtrTy);
4004 return FunctionDecl::Create(*Context, TUDecl,SourceLocation(),
4005 ID, FType, FunctionDecl::Extern, false, 0);
4006}
4007
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004008Stmt *RewriteObjC::SynthBlockInitExpr(BlockExpr *Exp) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004009 Blocks.push_back(Exp);
4010
4011 CollectBlockDeclRefInfo(Exp);
4012 std::string FuncName;
4013
4014 if (CurFunctionDef)
Chris Lattner077bf5e2008-11-24 03:33:13 +00004015 FuncName = CurFunctionDef->getNameAsString();
Steve Narofffa15fd92008-10-28 20:29:00 +00004016 else if (CurMethodDef) {
Chris Lattner077bf5e2008-11-24 03:33:13 +00004017 FuncName = CurMethodDef->getSelector().getAsString();
Steve Narofffa15fd92008-10-28 20:29:00 +00004018 // Convert colons to underscores.
4019 std::string::size_type loc = 0;
4020 while ((loc = FuncName.find(":", loc)) != std::string::npos)
4021 FuncName.replace(loc, 1, "_");
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004022 } else if (GlobalVarDecl)
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00004023 FuncName = std::string(GlobalVarDecl->getNameAsString());
Steve Narofffa15fd92008-10-28 20:29:00 +00004024
4025 std::string BlockNumber = utostr(Blocks.size()-1);
4026
4027 std::string Tag = "__" + FuncName + "_block_impl_" + BlockNumber;
4028 std::string Func = "__" + FuncName + "_block_func_" + BlockNumber;
4029
4030 // Get a pointer to the function type so we can cast appropriately.
4031 QualType FType = Context->getPointerType(QualType(Exp->getFunctionType(),0));
4032
4033 FunctionDecl *FD;
4034 Expr *NewRep;
4035
4036 // Simulate a contructor call...
4037 FD = SynthBlockInitFunctionDecl(Tag.c_str());
4038 DeclRefExpr *DRE = new DeclRefExpr(FD, FType, SourceLocation());
4039
4040 llvm::SmallVector<Expr*, 4> InitExprs;
4041
Steve Narofffdc03722008-10-29 21:23:59 +00004042 // Initialize the block function.
Steve Narofffa15fd92008-10-28 20:29:00 +00004043 FD = SynthBlockInitFunctionDecl(Func.c_str());
4044 DeclRefExpr *Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
4045 CastExpr *castExpr = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00004046 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00004047 InitExprs.push_back(castExpr);
Steve Narofffa15fd92008-10-28 20:29:00 +00004048
4049 if (ImportedBlockDecls.size()) {
4050 std::string Buf = "__" + FuncName + "_block_copy_" + BlockNumber;
Steve Narofffdc03722008-10-29 21:23:59 +00004051 FD = SynthBlockInitFunctionDecl(Buf.c_str());
4052 Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
4053 castExpr = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00004054 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffdc03722008-10-29 21:23:59 +00004055 InitExprs.push_back(castExpr);
4056
Steve Narofffa15fd92008-10-28 20:29:00 +00004057 Buf = "__" + FuncName + "_block_dispose_" + BlockNumber;
Steve Narofffdc03722008-10-29 21:23:59 +00004058 FD = SynthBlockInitFunctionDecl(Buf.c_str());
4059 Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
4060 castExpr = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00004061 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffdc03722008-10-29 21:23:59 +00004062 InitExprs.push_back(castExpr);
Steve Narofffa15fd92008-10-28 20:29:00 +00004063 }
4064 // Add initializers for any closure decl refs.
4065 if (BlockDeclRefs.size()) {
Steve Narofffdc03722008-10-29 21:23:59 +00004066 Expr *Exp;
Steve Narofffa15fd92008-10-28 20:29:00 +00004067 // Output all "by copy" declarations.
4068 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByCopyDecls.begin(),
4069 E = BlockByCopyDecls.end(); I != E; ++I) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004070 if (isObjCType((*I)->getType())) {
Steve Narofffdc03722008-10-29 21:23:59 +00004071 // FIXME: Conform to ABI ([[obj retain] autorelease]).
Chris Lattner8ec03f52008-11-24 03:54:41 +00004072 FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString());
Steve Narofffdc03722008-10-29 21:23:59 +00004073 Exp = new DeclRefExpr(FD, FD->getType(), SourceLocation());
Steve Naroff01f2ffa2008-12-11 21:05:33 +00004074 } else if (isTopLevelBlockPointerType((*I)->getType())) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00004075 FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString());
Steve Narofffdc03722008-10-29 21:23:59 +00004076 Arg = new DeclRefExpr(FD, FD->getType(), SourceLocation());
4077 Exp = new CStyleCastExpr(Context->VoidPtrTy, Arg,
Steve Naroffb2f9e512008-11-03 23:29:32 +00004078 Context->VoidPtrTy, SourceLocation(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00004079 } else {
Chris Lattner8ec03f52008-11-24 03:54:41 +00004080 FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString());
Steve Narofffdc03722008-10-29 21:23:59 +00004081 Exp = new DeclRefExpr(FD, FD->getType(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00004082 }
Steve Narofffdc03722008-10-29 21:23:59 +00004083 InitExprs.push_back(Exp);
Steve Narofffa15fd92008-10-28 20:29:00 +00004084 }
4085 // Output all "by ref" declarations.
4086 for (llvm::SmallPtrSet<ValueDecl*,8>::iterator I = BlockByRefDecls.begin(),
4087 E = BlockByRefDecls.end(); I != E; ++I) {
Chris Lattner8ec03f52008-11-24 03:54:41 +00004088 FD = SynthBlockInitFunctionDecl((*I)->getNameAsCString());
Steve Narofffdc03722008-10-29 21:23:59 +00004089 Exp = new DeclRefExpr(FD, FD->getType(), SourceLocation());
4090 Exp = new UnaryOperator(Exp, UnaryOperator::AddrOf,
4091 Context->getPointerType(Exp->getType()),
4092 SourceLocation());
Steve Naroff707b0fe2008-11-14 21:36:12 +00004093 InitExprs.push_back(Exp);
Steve Narofffa15fd92008-10-28 20:29:00 +00004094 }
4095 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004096 NewRep = new CallExpr(DRE, &InitExprs[0], InitExprs.size(),
4097 FType, SourceLocation());
4098 NewRep = new UnaryOperator(NewRep, UnaryOperator::AddrOf,
4099 Context->getPointerType(NewRep->getType()),
4100 SourceLocation());
Steve Naroffb2f9e512008-11-03 23:29:32 +00004101 NewRep = new CStyleCastExpr(FType, NewRep, FType, SourceLocation(), SourceLocation());
Steve Narofffa15fd92008-10-28 20:29:00 +00004102 BlockDeclRefs.clear();
4103 BlockByRefDecls.clear();
4104 BlockByCopyDecls.clear();
4105 ImportedBlockDecls.clear();
4106 return NewRep;
4107}
4108
4109//===----------------------------------------------------------------------===//
4110// Function Body / Expression rewriting
4111//===----------------------------------------------------------------------===//
4112
Steve Naroffc77a6362008-12-04 16:24:46 +00004113// This is run as a first "pass" prior to RewriteFunctionBodyOrGlobalInitializer().
4114// The allows the main rewrite loop to associate all ObjCPropertyRefExprs with
4115// their respective BinaryOperator. Without this knowledge, we'd need to rewrite
4116// the ObjCPropertyRefExpr twice (once as a getter, and later as a setter).
4117// Since the rewriter isn't capable of rewriting rewritten code, it's important
4118// we get this right.
4119void RewriteObjC::CollectPropertySetters(Stmt *S) {
4120 // Perform a bottom up traversal of all children.
4121 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
4122 CI != E; ++CI)
4123 if (*CI)
4124 CollectPropertySetters(*CI);
4125
4126 if (BinaryOperator *BinOp = dyn_cast<BinaryOperator>(S)) {
4127 if (BinOp->isAssignmentOp()) {
4128 if (ObjCPropertyRefExpr *PRE = dyn_cast<ObjCPropertyRefExpr>(BinOp->getLHS()))
4129 PropSetters[PRE] = BinOp;
4130 }
4131 }
4132}
4133
Steve Narofffa15fd92008-10-28 20:29:00 +00004134Stmt *RewriteObjC::RewriteFunctionBodyOrGlobalInitializer(Stmt *S) {
4135 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
4136 isa<DoStmt>(S) || isa<ForStmt>(S))
4137 Stmts.push_back(S);
4138 else if (isa<ObjCForCollectionStmt>(S)) {
4139 Stmts.push_back(S);
4140 ObjCBcLabelNo.push_back(++BcLabelCount);
4141 }
4142
4143 SourceRange OrigStmtRange = S->getSourceRange();
4144
4145 // Perform a bottom up rewrite of all children.
4146 for (Stmt::child_iterator CI = S->child_begin(), E = S->child_end();
4147 CI != E; ++CI)
4148 if (*CI) {
4149 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(*CI);
4150 if (newStmt)
4151 *CI = newStmt;
4152 }
4153
4154 if (BlockExpr *BE = dyn_cast<BlockExpr>(S)) {
4155 // Rewrite the block body in place.
4156 RewriteFunctionBodyOrGlobalInitializer(BE->getBody());
4157
4158 // Now we snarf the rewritten text and stash it away for later use.
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004159 std::string Str = Rewrite.getRewritenText(BE->getSourceRange());
4160 RewrittenBlockExprs[BE] = Str;
Steve Narofffa15fd92008-10-28 20:29:00 +00004161
4162 Stmt *blockTranscribed = SynthBlockInitExpr(BE);
4163 //blockTranscribed->dump();
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004164 ReplaceStmt(S, blockTranscribed);
Steve Narofffa15fd92008-10-28 20:29:00 +00004165 return blockTranscribed;
4166 }
4167 // Handle specific things.
4168 if (ObjCEncodeExpr *AtEncode = dyn_cast<ObjCEncodeExpr>(S))
4169 return RewriteAtEncode(AtEncode);
4170
4171 if (ObjCIvarRefExpr *IvarRefExpr = dyn_cast<ObjCIvarRefExpr>(S))
4172 return RewriteObjCIvarRefExpr(IvarRefExpr, OrigStmtRange.getBegin());
4173
Steve Naroffc77a6362008-12-04 16:24:46 +00004174 if (ObjCPropertyRefExpr *PropRefExpr = dyn_cast<ObjCPropertyRefExpr>(S)) {
4175 BinaryOperator *BinOp = PropSetters[PropRefExpr];
4176 if (BinOp) {
4177 // Because the rewriter doesn't allow us to rewrite rewritten code,
4178 // we need to rewrite the right hand side prior to rewriting the setter.
Steve Naroffb619d952008-12-09 12:56:34 +00004179 DisableReplaceStmt = true;
4180 // Save the source range. Even if we disable the replacement, the
4181 // rewritten node will have been inserted into the tree. If the synthesized
4182 // node is at the 'end', the rewriter will fail. Consider this:
4183 // self.errorHandler = handler ? handler :
4184 // ^(NSURL *errorURL, NSError *error) { return (BOOL)1; };
4185 SourceRange SrcRange = BinOp->getSourceRange();
Steve Naroffc77a6362008-12-04 16:24:46 +00004186 Stmt *newStmt = RewriteFunctionBodyOrGlobalInitializer(BinOp->getRHS());
Steve Naroffb619d952008-12-09 12:56:34 +00004187 DisableReplaceStmt = false;
Steve Naroff4c3580e2008-12-04 23:50:32 +00004188 //
4189 // Unlike the main iterator, we explicily avoid changing 'BinOp'. If
4190 // we changed the RHS of BinOp, the rewriter would fail (since it needs
4191 // to see the original expression). Consider this example:
4192 //
4193 // Foo *obj1, *obj2;
4194 //
4195 // obj1.i = [obj2 rrrr];
4196 //
4197 // 'BinOp' for the previous expression looks like:
4198 //
4199 // (BinaryOperator 0x231ccf0 'int' '='
4200 // (ObjCPropertyRefExpr 0x231cc70 'int' Kind=PropertyRef Property="i"
4201 // (DeclRefExpr 0x231cc50 'Foo *' Var='obj1' 0x231cbb0))
4202 // (ObjCMessageExpr 0x231ccb0 'int' selector=rrrr
4203 // (DeclRefExpr 0x231cc90 'Foo *' Var='obj2' 0x231cbe0)))
4204 //
4205 // 'newStmt' represents the rewritten message expression. For example:
4206 //
4207 // (CallExpr 0x231d300 'id':'struct objc_object *'
4208 // (ParenExpr 0x231d2e0 'int (*)(id, SEL)'
4209 // (CStyleCastExpr 0x231d2c0 'int (*)(id, SEL)'
4210 // (CStyleCastExpr 0x231d220 'void *'
4211 // (DeclRefExpr 0x231d200 'id (id, SEL, ...)' FunctionDecl='objc_msgSend' 0x231cdc0))))
4212 //
4213 // Note that 'newStmt' is passed to RewritePropertySetter so that it
4214 // can be used as the setter argument. ReplaceStmt() will still 'see'
4215 // the original RHS (since we haven't altered BinOp).
4216 //
4217 // This implies the Rewrite* routines can no longer delete the original
4218 // node. As a result, we now leak the original AST nodes.
4219 //
Steve Naroffb619d952008-12-09 12:56:34 +00004220 return RewritePropertySetter(BinOp, dyn_cast<Expr>(newStmt), SrcRange);
Steve Naroffc77a6362008-12-04 16:24:46 +00004221 } else {
4222 return RewritePropertyGetter(PropRefExpr);
Steve Naroff15f081d2008-12-03 00:56:33 +00004223 }
4224 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004225 if (ObjCSelectorExpr *AtSelector = dyn_cast<ObjCSelectorExpr>(S))
4226 return RewriteAtSelector(AtSelector);
4227
4228 if (ObjCStringLiteral *AtString = dyn_cast<ObjCStringLiteral>(S))
4229 return RewriteObjCStringLiteral(AtString);
4230
4231 if (ObjCMessageExpr *MessExpr = dyn_cast<ObjCMessageExpr>(S)) {
Steve Naroffc77a6362008-12-04 16:24:46 +00004232#if 0
Steve Narofffa15fd92008-10-28 20:29:00 +00004233 // Before we rewrite it, put the original message expression in a comment.
4234 SourceLocation startLoc = MessExpr->getLocStart();
4235 SourceLocation endLoc = MessExpr->getLocEnd();
4236
4237 const char *startBuf = SM->getCharacterData(startLoc);
4238 const char *endBuf = SM->getCharacterData(endLoc);
4239
4240 std::string messString;
4241 messString += "// ";
4242 messString.append(startBuf, endBuf-startBuf+1);
4243 messString += "\n";
4244
4245 // FIXME: Missing definition of
4246 // InsertText(clang::SourceLocation, char const*, unsigned int).
4247 // InsertText(startLoc, messString.c_str(), messString.size());
4248 // Tried this, but it didn't work either...
4249 // ReplaceText(startLoc, 0, messString.c_str(), messString.size());
Steve Naroffc77a6362008-12-04 16:24:46 +00004250#endif
Steve Narofffa15fd92008-10-28 20:29:00 +00004251 return RewriteMessageExpr(MessExpr);
4252 }
4253
4254 if (ObjCAtTryStmt *StmtTry = dyn_cast<ObjCAtTryStmt>(S))
4255 return RewriteObjCTryStmt(StmtTry);
4256
4257 if (ObjCAtSynchronizedStmt *StmtTry = dyn_cast<ObjCAtSynchronizedStmt>(S))
4258 return RewriteObjCSynchronizedStmt(StmtTry);
4259
4260 if (ObjCAtThrowStmt *StmtThrow = dyn_cast<ObjCAtThrowStmt>(S))
4261 return RewriteObjCThrowStmt(StmtThrow);
4262
4263 if (ObjCProtocolExpr *ProtocolExp = dyn_cast<ObjCProtocolExpr>(S))
4264 return RewriteObjCProtocolExpr(ProtocolExp);
4265
4266 if (ObjCForCollectionStmt *StmtForCollection =
4267 dyn_cast<ObjCForCollectionStmt>(S))
4268 return RewriteObjCForCollectionStmt(StmtForCollection,
4269 OrigStmtRange.getEnd());
4270 if (BreakStmt *StmtBreakStmt =
4271 dyn_cast<BreakStmt>(S))
4272 return RewriteBreakStmt(StmtBreakStmt);
4273 if (ContinueStmt *StmtContinueStmt =
4274 dyn_cast<ContinueStmt>(S))
4275 return RewriteContinueStmt(StmtContinueStmt);
4276
4277 // Need to check for protocol refs (id <P>, Foo <P> *) in variable decls
4278 // and cast exprs.
4279 if (DeclStmt *DS = dyn_cast<DeclStmt>(S)) {
4280 // FIXME: What we're doing here is modifying the type-specifier that
4281 // precedes the first Decl. In the future the DeclGroup should have
4282 // a separate type-specifier that we can rewrite.
4283 RewriteObjCQualifiedInterfaceTypes(*DS->decl_begin());
4284
4285 // Blocks rewrite rules.
4286 for (DeclStmt::decl_iterator DI = DS->decl_begin(), DE = DS->decl_end();
4287 DI != DE; ++DI) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004288 ScopedDecl *SD = *DI;
4289 if (ValueDecl *ND = dyn_cast<ValueDecl>(SD)) {
Steve Naroff01f2ffa2008-12-11 21:05:33 +00004290 if (isTopLevelBlockPointerType(ND->getType()))
Steve Narofffa15fd92008-10-28 20:29:00 +00004291 RewriteBlockPointerDecl(ND);
4292 else if (ND->getType()->isFunctionPointerType())
4293 CheckFunctionPointerDecl(ND->getType(), ND);
4294 }
4295 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) {
Steve Naroff01f2ffa2008-12-11 21:05:33 +00004296 if (isTopLevelBlockPointerType(TD->getUnderlyingType()))
Steve Narofffa15fd92008-10-28 20:29:00 +00004297 RewriteBlockPointerDecl(TD);
4298 else if (TD->getUnderlyingType()->isFunctionPointerType())
4299 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
4300 }
4301 }
4302 }
4303
4304 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S))
4305 RewriteObjCQualifiedInterfaceTypes(CE);
4306
4307 if (isa<SwitchStmt>(S) || isa<WhileStmt>(S) ||
4308 isa<DoStmt>(S) || isa<ForStmt>(S)) {
4309 assert(!Stmts.empty() && "Statement stack is empty");
4310 assert ((isa<SwitchStmt>(Stmts.back()) || isa<WhileStmt>(Stmts.back()) ||
4311 isa<DoStmt>(Stmts.back()) || isa<ForStmt>(Stmts.back()))
4312 && "Statement stack mismatch");
4313 Stmts.pop_back();
4314 }
4315 // Handle blocks rewriting.
4316 if (BlockDeclRefExpr *BDRE = dyn_cast<BlockDeclRefExpr>(S)) {
4317 if (BDRE->isByRef())
4318 RewriteBlockDeclRefExpr(BDRE);
4319 }
4320 if (CallExpr *CE = dyn_cast<CallExpr>(S)) {
Steve Naroffaa4d5ae2008-10-30 10:07:53 +00004321 if (CE->getCallee()->getType()->isBlockPointerType()) {
4322 Stmt *BlockCall = SynthesizeBlockCall(CE);
4323 ReplaceStmt(S, BlockCall);
4324 return BlockCall;
4325 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004326 }
Steve Naroffb2f9e512008-11-03 23:29:32 +00004327 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(S)) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004328 RewriteCastExpr(CE);
4329 }
4330#if 0
4331 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(S)) {
4332 CastExpr *Replacement = new CastExpr(ICE->getType(), ICE->getSubExpr(), SourceLocation());
4333 // Get the new text.
4334 std::string SStr;
4335 llvm::raw_string_ostream Buf(SStr);
4336 Replacement->printPretty(Buf);
4337 const std::string &Str = Buf.str();
4338
4339 printf("CAST = %s\n", &Str[0]);
4340 InsertText(ICE->getSubExpr()->getLocStart(), &Str[0], Str.size());
4341 delete S;
4342 return Replacement;
4343 }
4344#endif
4345 // Return this stmt unmodified.
4346 return S;
4347}
4348
4349/// HandleDeclInMainFile - This is called for each top-level decl defined in the
4350/// main file of the input.
4351void RewriteObjC::HandleDeclInMainFile(Decl *D) {
4352 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
4353 // Since function prototypes don't have ParmDecl's, we check the function
4354 // prototype. This enables us to rewrite function declarations and
4355 // definitions using the same code.
4356 RewriteBlocksInFunctionTypeProto(FD->getType(), FD);
4357
4358 if (Stmt *Body = FD->getBody()) {
4359 CurFunctionDef = FD;
Steve Naroffc77a6362008-12-04 16:24:46 +00004360 CollectPropertySetters(Body);
Steve Naroff8599e7a2008-12-08 16:43:47 +00004361 CurrentBody = Body;
Steve Narofffa15fd92008-10-28 20:29:00 +00004362 FD->setBody(RewriteFunctionBodyOrGlobalInitializer(Body));
Steve Naroff8599e7a2008-12-08 16:43:47 +00004363 CurrentBody = 0;
4364 if (PropParentMap) {
4365 delete PropParentMap;
4366 PropParentMap = 0;
4367 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004368 // This synthesizes and inserts the block "impl" struct, invoke function,
4369 // and any copy/dispose helper functions.
4370 InsertBlockLiteralsWithinFunction(FD);
4371 CurFunctionDef = 0;
4372 }
4373 return;
4374 }
4375 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
4376 if (Stmt *Body = MD->getBody()) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004377 CurMethodDef = MD;
Steve Naroffc77a6362008-12-04 16:24:46 +00004378 CollectPropertySetters(Body);
Steve Naroff8599e7a2008-12-08 16:43:47 +00004379 CurrentBody = Body;
Steve Narofffa15fd92008-10-28 20:29:00 +00004380 MD->setBody(RewriteFunctionBodyOrGlobalInitializer(Body));
Steve Naroff8599e7a2008-12-08 16:43:47 +00004381 CurrentBody = 0;
4382 if (PropParentMap) {
4383 delete PropParentMap;
4384 PropParentMap = 0;
4385 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004386 InsertBlockLiteralsWithinMethod(MD);
4387 CurMethodDef = 0;
4388 }
4389 }
4390 if (ObjCImplementationDecl *CI = dyn_cast<ObjCImplementationDecl>(D))
4391 ClassImplementation.push_back(CI);
4392 else if (ObjCCategoryImplDecl *CI = dyn_cast<ObjCCategoryImplDecl>(D))
4393 CategoryImplementation.push_back(CI);
4394 else if (ObjCClassDecl *CD = dyn_cast<ObjCClassDecl>(D))
4395 RewriteForwardClassDecl(CD);
4396 else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
4397 RewriteObjCQualifiedInterfaceTypes(VD);
Steve Naroff01f2ffa2008-12-11 21:05:33 +00004398 if (isTopLevelBlockPointerType(VD->getType()))
Steve Narofffa15fd92008-10-28 20:29:00 +00004399 RewriteBlockPointerDecl(VD);
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004400 else if (VD->getType()->isFunctionPointerType()) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004401 CheckFunctionPointerDecl(VD->getType(), VD);
4402 if (VD->getInit()) {
Steve Naroffb2f9e512008-11-03 23:29:32 +00004403 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) {
Steve Narofffa15fd92008-10-28 20:29:00 +00004404 RewriteCastExpr(CE);
4405 }
4406 }
4407 }
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004408 if (VD->getInit()) {
4409 GlobalVarDecl = VD;
Steve Naroffc77a6362008-12-04 16:24:46 +00004410 CollectPropertySetters(VD->getInit());
Steve Naroff8599e7a2008-12-08 16:43:47 +00004411 CurrentBody = VD->getInit();
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004412 RewriteFunctionBodyOrGlobalInitializer(VD->getInit());
Steve Naroff8599e7a2008-12-08 16:43:47 +00004413 CurrentBody = 0;
4414 if (PropParentMap) {
4415 delete PropParentMap;
4416 PropParentMap = 0;
4417 }
Douglas Gregor2e1cd422008-11-17 14:58:09 +00004418 SynthesizeBlockLiterals(VD->getTypeSpecStartLoc(),
Chris Lattner8ec03f52008-11-24 03:54:41 +00004419 VD->getNameAsCString());
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004420 GlobalVarDecl = 0;
4421
4422 // This is needed for blocks.
Steve Naroffb2f9e512008-11-03 23:29:32 +00004423 if (CStyleCastExpr *CE = dyn_cast<CStyleCastExpr>(VD->getInit())) {
Steve Naroff8e2f57a2008-10-29 18:15:37 +00004424 RewriteCastExpr(CE);
4425 }
4426 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004427 return;
4428 }
4429 if (TypedefDecl *TD = dyn_cast<TypedefDecl>(D)) {
Steve Naroff01f2ffa2008-12-11 21:05:33 +00004430 if (isTopLevelBlockPointerType(TD->getUnderlyingType()))
Steve Narofffa15fd92008-10-28 20:29:00 +00004431 RewriteBlockPointerDecl(TD);
4432 else if (TD->getUnderlyingType()->isFunctionPointerType())
4433 CheckFunctionPointerDecl(TD->getUnderlyingType(), TD);
4434 return;
4435 }
4436 if (RecordDecl *RD = dyn_cast<RecordDecl>(D)) {
4437 if (RD->isDefinition()) {
Douglas Gregora4c46df2008-12-11 17:59:21 +00004438 for (RecordDecl::field_iterator i = RD->field_begin(),
Steve Narofffa15fd92008-10-28 20:29:00 +00004439 e = RD->field_end(); i != e; ++i) {
4440 FieldDecl *FD = *i;
Steve Naroff01f2ffa2008-12-11 21:05:33 +00004441 if (isTopLevelBlockPointerType(FD->getType()))
Steve Narofffa15fd92008-10-28 20:29:00 +00004442 RewriteBlockPointerDecl(FD);
4443 }
4444 }
4445 return;
4446 }
4447 // Nothing yet.
4448}
4449
4450void RewriteObjC::HandleTranslationUnit(TranslationUnit& TU) {
4451 // Get the top-level buffer that this corresponds to.
4452
4453 // Rewrite tabs if we care.
4454 //RewriteTabs();
4455
4456 if (Diags.hasErrorOccurred())
4457 return;
4458
4459 // Create the output file.
4460
4461 llvm::OwningPtr<llvm::raw_ostream> OwnedStream;
4462 llvm::raw_ostream *OutFile;
4463 if (OutFileName == "-") {
4464 OutFile = &llvm::outs();
4465 } else if (!OutFileName.empty()) {
4466 std::string Err;
Daniel Dunbar26fb2722008-11-13 05:09:21 +00004467 OutFile = new llvm::raw_fd_ostream(OutFileName.c_str(), false, Err);
Steve Narofffa15fd92008-10-28 20:29:00 +00004468 OwnedStream.reset(OutFile);
4469 } else if (InFileName == "-") {
4470 OutFile = &llvm::outs();
4471 } else {
4472 llvm::sys::Path Path(InFileName);
4473 Path.eraseSuffix();
4474 Path.appendSuffix("cpp");
4475 std::string Err;
Daniel Dunbar26fb2722008-11-13 05:09:21 +00004476 OutFile = new llvm::raw_fd_ostream(Path.toString().c_str(), false, Err);
Steve Narofffa15fd92008-10-28 20:29:00 +00004477 OwnedStream.reset(OutFile);
4478 }
4479
4480 RewriteInclude();
4481
4482 InsertText(SourceLocation::getFileLoc(MainFileID, 0),
4483 Preamble.c_str(), Preamble.size(), false);
4484
Steve Naroff0aab7962008-11-14 14:10:01 +00004485 if (ClassImplementation.size() || CategoryImplementation.size())
4486 RewriteImplementations();
Steve Narofffa15fd92008-10-28 20:29:00 +00004487
4488 // Get the buffer corresponding to MainFileID. If we haven't changed it, then
4489 // we are done.
4490 if (const RewriteBuffer *RewriteBuf =
4491 Rewrite.getRewriteBufferFor(MainFileID)) {
4492 //printf("Changed:\n");
4493 *OutFile << std::string(RewriteBuf->begin(), RewriteBuf->end());
4494 } else {
4495 fprintf(stderr, "No changes\n");
4496 }
Steve Narofface66252008-11-13 20:07:04 +00004497
Steve Naroff0aab7962008-11-14 14:10:01 +00004498 if (ClassImplementation.size() || CategoryImplementation.size()) {
4499 // Rewrite Objective-c meta data*
4500 std::string ResultStr;
4501 SynthesizeMetaDataIntoBuffer(ResultStr);
4502 // Emit metadata.
4503 *OutFile << ResultStr;
4504 }
Steve Narofffa15fd92008-10-28 20:29:00 +00004505 OutFile->flush();
4506}
4507