diff --git a/clang/Driver/RewriteObjC.cpp b/clang/Driver/RewriteObjC.cpp
index fe71e54a86b7..9a4657e522b2 100644
--- a/clang/Driver/RewriteObjC.cpp
+++ b/clang/Driver/RewriteObjC.cpp
@@ -1975,9 +1975,10 @@ Stmt *RewriteObjC::SynthMessageExpr(ObjCMessageExpr *Exp) {
       llvm::SmallVector<Expr*, 4> InitExprs;
       
       // set the receiver to self, the first argument to all methods.
-      InitExprs.push_back(new DeclRefExpr(CurMethodDecl->getSelfDecl(), 
-                                          Context->getObjCIdType(),
-                                          SourceLocation())); 
+      InitExprs.push_back(new DeclRefExpr(
+            CurMethodDecl->getSelfDecl(), 
+            Context->getObjCIdType(),
+            SourceLocation())); 
       llvm::SmallVector<Expr*, 8> ClsExprs;
       QualType argType = Context->getPointerType(Context->CharTy);
       ClsExprs.push_back(new StringLiteral(SuperDecl->getIdentifier()->getName(), 
diff --git a/clang/include/clang/AST/Decl.h b/clang/include/clang/AST/Decl.h
index 8b355e9f2292..bf7efe8043d7 100644
--- a/clang/include/clang/AST/Decl.h
+++ b/clang/include/clang/AST/Decl.h
@@ -308,6 +308,20 @@ protected:
   static VarDecl* CreateImpl(llvm::Deserializer& D, ASTContext& C);
 };
 
+class ImplicitParamDecl : public VarDecl {
+protected:
+  ImplicitParamDecl(Kind DK, DeclContext *DC, SourceLocation L,
+            IdentifierInfo *Id, QualType T, ScopedDecl *PrevDecl) 
+    : VarDecl(DK, DC, L, Id, T, VarDecl::None, PrevDecl) {}
+public:
+  static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
+                         SourceLocation L, IdentifierInfo *Id,
+                         QualType T, ScopedDecl *PrevDecl);
+  // Implement isa/cast/dyncast/etc.
+  static bool classof(const ImplicitParamDecl *D) { return true; }
+  static bool classof(const Decl *D) { return D->getKind() == ImplicitParam; }
+};
+
 /// ParmVarDecl - Represent a parameter to a function.
 class ParmVarDecl : public VarDecl {
   // NOTE: VC++ treats enums as signed, avoid using the ObjCDeclQualifier enum
diff --git a/clang/include/clang/AST/DeclBase.h b/clang/include/clang/AST/DeclBase.h
index 60387b1ad4ce..55c2e61ff09b 100644
--- a/clang/include/clang/AST/DeclBase.h
+++ b/clang/include/clang/AST/DeclBase.h
@@ -69,6 +69,7 @@ public:
                Function,  // [DeclContext]
                  CXXMethod,
                Var,
+                 ImplicitParam,
                  CXXClassVar,
                  ParmVar,
          ObjCInterface,  // [DeclContext]
@@ -172,6 +173,7 @@ public:
   IdentifierNamespace getIdentifierNamespace() const {
     switch (DeclKind) {
     default: assert(0 && "Unknown decl kind!");
+    case ImplicitParam:
     case Typedef:
     case Function:
     case Var:
diff --git a/clang/include/clang/AST/DeclObjC.h b/clang/include/clang/AST/DeclObjC.h
index be1e888242de..093a5cf1a209 100644
--- a/clang/include/clang/AST/DeclObjC.h
+++ b/clang/include/clang/AST/DeclObjC.h
@@ -91,7 +91,9 @@ private:
   // The following are only used for method definitions, null otherwise.
   // FIXME: space savings opportunity, consider a sub-class.
   Stmt *Body;
-  ParmVarDecl *SelfDecl;
+  // Decls for implicit parameters
+  ImplicitParamDecl *SelfDecl;
+  ImplicitParamDecl *CmdDecl;
   
   ObjCMethodDecl(SourceLocation beginLoc, SourceLocation endLoc,
                  Selector SelInfo, QualType T,
@@ -107,8 +109,8 @@ private:
     DeclImplementation(impControl), objcDeclQualifier(OBJC_TQ_None),
     MethodContext(static_cast<NamedDecl*>(contextDecl)),
     SelName(SelInfo), MethodDeclType(T), 
-    ParamInfo(0), NumMethodParams(0),
-    MethodAttrs(M), EndLoc(endLoc), Body(0), SelfDecl(0) {}
+    ParamInfo(0), NumMethodParams(0), MethodAttrs(M), 
+    EndLoc(endLoc), Body(0), SelfDecl(0), CmdDecl(0) {}
 
   virtual ~ObjCMethodDecl();
   
@@ -164,6 +166,11 @@ public:
     ParamInfo[i] = pDecl;
   }  
   void setMethodParams(ParmVarDecl **NewParamInfo, unsigned NumParams);
+
+  ImplicitParamDecl * getSelfDecl() const { return SelfDecl; }
+  void setSelfDecl(ImplicitParamDecl *decl) { SelfDecl = decl; }
+  ImplicitParamDecl * getCmdDecl() const { return CmdDecl; }
+  void setCmdDecl(ImplicitParamDecl *decl) { CmdDecl = decl; }
   
   AttributeList *getMethodAttrs() const {return MethodAttrs;}
   bool isInstance() const { return IsInstance; }
@@ -182,10 +189,6 @@ public:
   const Stmt *getBody() const { return Body; }
   void setBody(Stmt *B) { Body = B; }
 
-  const ParmVarDecl *getSelfDecl() const { return SelfDecl; }
-  ParmVarDecl *getSelfDecl() { return SelfDecl; }
-  void setSelfDecl(ParmVarDecl *PVD) { SelfDecl = PVD; }
-  
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return D->getKind() == ObjCMethod; }
   static bool classof(const ObjCMethodDecl *D) { return true; }
diff --git a/clang/include/clang/Analysis/Visitors/CFGRecStmtDeclVisitor.h b/clang/include/clang/Analysis/Visitors/CFGRecStmtDeclVisitor.h
index fab14c38daae..754bbb4fb9ad 100644
--- a/clang/include/clang/Analysis/Visitors/CFGRecStmtDeclVisitor.h
+++ b/clang/include/clang/Analysis/Visitors/CFGRecStmtDeclVisitor.h
@@ -56,6 +56,7 @@ public:
         DISPATCH_CASE(Function,FunctionDecl)
         DISPATCH_CASE(Var,VarDecl)
         DISPATCH_CASE(ParmVar,ParmVarDecl)       // FIXME: (same)
+        DISPATCH_CASE(ImplicitParam,ImplicitParamDecl)
         DISPATCH_CASE(EnumConstant,EnumConstantDecl)
         DISPATCH_CASE(Typedef,TypedefDecl)
         DISPATCH_CASE(Struct,RecordDecl)    // FIXME: Refine.  VisitStructDecl?
@@ -70,6 +71,7 @@ public:
   DEFAULT_DISPATCH(VarDecl)
   DEFAULT_DISPATCH(FunctionDecl)
   DEFAULT_DISPATCH_VARDECL(ParmVarDecl)
+  DEFAULT_DISPATCH(ImplicitParamDecl)
   DEFAULT_DISPATCH(EnumConstantDecl)
   DEFAULT_DISPATCH(TypedefDecl)
   DEFAULT_DISPATCH(RecordDecl)
diff --git a/clang/lib/AST/Decl.cpp b/clang/lib/AST/Decl.cpp
index dbe476db1f27..a2b39c438d53 100644
--- a/clang/lib/AST/Decl.cpp
+++ b/clang/lib/AST/Decl.cpp
@@ -40,6 +40,12 @@ void NamespaceDecl::Destroy(ASTContext& C) {
 }
 
 
+ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC,
+    SourceLocation L, IdentifierInfo *Id, QualType T, ScopedDecl *PrevDecl) {
+  void *Mem = C.getAllocator().Allocate<ImplicitParamDecl>();
+  return new (Mem) ImplicitParamDecl(ImplicitParam, DC, L, Id, T, PrevDecl);
+}
+
 VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
                          SourceLocation L,
                          IdentifierInfo *Id, QualType T,
diff --git a/clang/lib/AST/DeclBase.cpp b/clang/lib/AST/DeclBase.cpp
index 296304a66dda..89c61aea6a06 100644
--- a/clang/lib/AST/DeclBase.cpp
+++ b/clang/lib/AST/DeclBase.cpp
@@ -206,6 +206,7 @@ void Decl::addDeclKind(Kind k) {
   case ObjCPropertyImpl:    nObjCPropertyImplDecl++; break;
   case LinkageSpec:         nLinkageSpecDecl++; break;
   case FileScopeAsm:        nFileScopeAsmDecl++; break;
+  case ImplicitParam:
   case TranslationUnit:     break;
 
   // FIXME: Statistics for C++ decls.
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 496afd6457fb..e18c27c3b5c6 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -389,10 +389,12 @@ Expr::isLvalueResult Expr::isLvalue() const {
     if (cast<ArraySubscriptExpr>(this)->getBase()->getType()->isVectorType())
       return cast<ArraySubscriptExpr>(this)->getBase()->isLvalue();
     return LV_Valid;
-  case DeclRefExprClass: // C99 6.5.1p2
-    if (isa<VarDecl>(cast<DeclRefExpr>(this)->getDecl()))
+  case DeclRefExprClass: { // C99 6.5.1p2
+    const Decl *RefdDecl = cast<DeclRefExpr>(this)->getDecl();
+    if (isa<VarDecl>(RefdDecl) || isa<ImplicitParamDecl>(RefdDecl))
       return LV_Valid;
     break;
+  }
   case MemberExprClass: { // C99 6.5.2.3p4
     const MemberExpr *m = cast<MemberExpr>(this);
     return m->isArrow() ? LV_Valid : m->getBase()->isLvalue();
diff --git a/clang/lib/Analysis/GRExprEngine.cpp b/clang/lib/Analysis/GRExprEngine.cpp
index ce64875797c6..837d9100914e 100644
--- a/clang/lib/Analysis/GRExprEngine.cpp
+++ b/clang/lib/Analysis/GRExprEngine.cpp
@@ -144,12 +144,18 @@ ValueState* GRExprEngine::getInitialState() {
   
   for (LVDataTy::decl_iterator I=D.begin_decl(), E=D.end_decl(); I != E; ++I) {
     
-    VarDecl* VD = cast<VarDecl>(const_cast<ScopedDecl*>(I->first));
-    
-    if (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD)) {
-      RVal X = RVal::GetSymbolValue(SymMgr, VD);
-      StateMgr.BindVar(StateImpl, VD, X);
+    ScopedDecl *SD = const_cast<ScopedDecl*>(I->first);
+    if (VarDecl* VD = dyn_cast<VarDecl>(SD)) {
+      if (VD->hasGlobalStorage() || isa<ParmVarDecl>(VD)) {
+        RVal X = RVal::GetSymbolValue(SymMgr, VD);
+        StateMgr.BindVar(StateImpl, VD, X);
+      }
+    } else if (ImplicitParamDecl *IPD = dyn_cast<ImplicitParamDecl>(SD)) {
+        RVal X = RVal::GetSymbolValue(SymMgr, IPD);
+        StateMgr.BindVar(StateImpl, IPD, X);
     }
+      
+
   }
   
   return StateMgr.getPersistentState(StateImpl);
diff --git a/clang/lib/Analysis/LiveVariables.cpp b/clang/lib/Analysis/LiveVariables.cpp
index 4148d9e838d1..54e2195a777d 100644
--- a/clang/lib/Analysis/LiveVariables.cpp
+++ b/clang/lib/Analysis/LiveVariables.cpp
@@ -60,6 +60,11 @@ public:
       AD.AlwaysLive(*I, AD) = Alive;      
   }
 
+  void VisitImplicitParamDecl(ImplicitParamDecl* IPD) {
+    // Register the VarDecl for tracking.
+    AD.Register(IPD);
+  }
+
   void VisitVarDecl(VarDecl* VD) {
     // Register the VarDecl for tracking.
     AD.Register(VD);
diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp
index 5856531f4335..9420f95ad1c4 100644
--- a/clang/lib/CodeGen/CGExpr.cpp
+++ b/clang/lib/CodeGen/CGExpr.cpp
@@ -370,7 +370,8 @@ void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
 LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
   const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl());
   
-  if (VD && (VD->isBlockVarDecl() || isa<ParmVarDecl>(VD))) {
+  if (VD && (VD->isBlockVarDecl() || isa<ParmVarDecl>(VD) ||
+        isa<ImplicitParamDecl>(VD))) {
     if (VD->getStorageClass() == VarDecl::Extern)
       return LValue::MakeAddr(CGM.GetAddrOfGlobalVar(VD, false),
                               E->getType().getCVRQualifiers());
@@ -386,6 +387,12 @@ LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
     return LValue::MakeAddr(CGM.GetAddrOfFunctionDecl(FD, false),
                             E->getType().getCVRQualifiers());
   }
+  else if (const ImplicitParamDecl *IPD =
+      dyn_cast<ImplicitParamDecl>(E->getDecl())) {
+    llvm::Value *V = LocalDeclMap[IPD];
+    assert(V && "BlockVarDecl not entered in LocalDeclMap?");
+    return LValue::MakeAddr(V, E->getType().getCVRQualifiers());
+  }
   assert(0 && "Unimp declref");
   //an invalid LValue, but the assert will
   //ensure that this point is never reached.
diff --git a/clang/lib/CodeGen/CGObjC.cpp b/clang/lib/CodeGen/CGObjC.cpp
index d666ab1f9c1d..a080a2260277 100644
--- a/clang/lib/CodeGen/CGObjC.cpp
+++ b/clang/lib/CodeGen/CGObjC.cpp
@@ -16,6 +16,8 @@
 #include "CodeGenModule.h"
 #include "clang/AST/ExprObjC.h"
 #include "llvm/Constant.h"
+#include "llvm/Function.h"
+
 using namespace clang;
 using namespace CodeGen;
 
@@ -24,4 +26,91 @@ llvm::Value *CodeGenFunction::EmitObjCStringLiteral(const ObjCStringLiteral *E){
   return CGM.GetAddrOfConstantCFString(S);
 }
 
+/// Generate an Objective-C method.  An Objective-C method is a C function with
+/// its pointer, name, and types registered in the class struture.  
+void CodeGenFunction::GenerateObjCMethod(const ObjCMethodDecl *OMD) {
+
+  llvm::SmallVector<const llvm::Type *, 16> ParamTypes;
+  for (unsigned i=0 ; i<OMD->param_size() ; i++) {
+    const llvm::Type *Ty = ConvertType(OMD->getParamDecl(i)->getType());
+    if (Ty->isFirstClassType())
+      ParamTypes.push_back(Ty);
+    else
+      ParamTypes.push_back(llvm::PointerType::getUnqual(Ty));
+  }
+  std::string CategoryName = "";
+  if (ObjCCategoryImplDecl *OCD =
+      dyn_cast<ObjCCategoryImplDecl>(OMD->getMethodContext())) {
+    CategoryName = OCD->getName();
+  }
+  const llvm::Type *ReturnTy = CGM.getTypes().ConvertReturnType(OMD->getResultType());
+  CurFn = CGM.getObjCRuntime()->MethodPreamble(
+                                              OMD->getClassInterface()->getName(),
+                                              CategoryName,
+                                              OMD->getSelector().getName(),
+                                              ReturnTy,
+                                              llvm::PointerType::getUnqual(
+                                              llvm::Type::Int32Ty),
+                                              ParamTypes.begin(),
+                                              OMD->param_size(),
+                                              !OMD->isInstance(),
+                                              OMD->isVariadic());
+  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
+  
+  // Create a marker to make it easy to insert allocas into the entryblock
+  // later.  Don't create this with the builder, because we don't want it
+  // folded.
+  llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
+  AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
+                                         EntryBB);
+
+  FnRetTy = OMD->getResultType();
+  CurFuncDecl = OMD;
+
+  Builder.SetInsertPoint(EntryBB);
+  
+  // Emit allocs for param decls.  Give the LLVM Argument nodes names.
+  llvm::Function::arg_iterator AI = CurFn->arg_begin();
+  
+  if (hasAggregateLLVMType(OMD->getResultType())) {
+    ++AI;
+  }
+  // Add implicit parameters to the decl map.
+  // TODO: Add something to AST to let the runtime specify the names and types
+  // of these.
+
+  llvm::Value *&SelfEntry = LocalDeclMap[OMD->getSelfDecl()];
+  const llvm::Type *IPTy = AI->getType();
+  llvm::Value *DeclPtr = new llvm::AllocaInst(IPTy, 0, AI->getName() +
+      ".addr", AllocaInsertPt);
+  // Store the initial value into the alloca.
+  Builder.CreateStore(AI, DeclPtr);
+  SelfEntry = DeclPtr;
+  ++AI;
+  llvm::Value *&CmdEntry = LocalDeclMap[OMD->getCmdDecl()];
+  IPTy = AI->getType();
+  DeclPtr = new llvm::AllocaInst(IPTy, 0, AI->getName() +
+      ".addr", AllocaInsertPt);
+  // Store the initial value into the alloca.
+  Builder.CreateStore(AI, DeclPtr);
+  CmdEntry = DeclPtr;
+
+  for (unsigned i = 0, e = OMD->getNumParams(); i != e; ++i, ++AI) {
+    assert(AI != CurFn->arg_end() && "Argument mismatch!");
+    EmitParmDecl(*OMD->getParamDecl(i), AI);
+  }
+  
+  GenerateFunction(OMD->getBody());
+}
+
+llvm::Value *CodeGenFunction::LoadObjCSelf(void)
+{
+  if (const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurFuncDecl)) {
+    ValueDecl *Decl = OMD->getSelfDecl();
+    llvm::Value *SelfPtr = LocalDeclMap[&(*(Decl))];
+    return Builder.CreateLoad(SelfPtr, "self");
+  }
+  return NULL;
+}
+
 CGObjCRuntime::~CGObjCRuntime() {}
diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp
index c8ef8fcd33b1..ebc1ff500d09 100644
--- a/clang/lib/CodeGen/CodeGenFunction.cpp
+++ b/clang/lib/CodeGen/CodeGenFunction.cpp
@@ -27,7 +27,10 @@ using namespace CodeGen;
 
 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm) 
   : CGM(cgm), Target(CGM.getContext().Target), SwitchInsn(NULL), 
-    CaseRangeBlock(NULL) {}
+    CaseRangeBlock(NULL) {
+    LLVMIntTy = ConvertType(getContext().IntTy);
+    LLVMPointerWidth = Target.getPointerWidth(0);
+}
 
 ASTContext &CodeGenFunction::getContext() const {
   return CGM.getContext();
@@ -51,170 +54,21 @@ const llvm::Type *CodeGenFunction::ConvertType(QualType T) {
   return CGM.getTypes().ConvertType(T);
 }
 
+bool CodeGenFunction::isObjCPointerType(QualType T) {
+  // All Objective-C types are pointers.
+  return T->isObjCInterfaceType() ||
+    T->isObjCQualifiedInterfaceType() || T->isObjCQualifiedIdType();
+}
+
 bool CodeGenFunction::hasAggregateLLVMType(QualType T) {
-  return !T->isRealType() && !T->isPointerLikeType() &&
-         !T->isVoidType() && !T->isVectorType() && !T->isFunctionType();
+  return !isObjCPointerType(T) &&!T->isRealType() && !T->isPointerLikeType() &&
+    !T->isVoidType() && !T->isVectorType() && !T->isFunctionType();
 }
 
-/// Generate an Objective-C method.  An Objective-C method is a C function with
-/// its pointer, name, and types registered in the class struture.  
-// FIXME: This method contains a lot of code copied and pasted from
-// GenerateCode.  This should be factored out.
-void CodeGenFunction::GenerateObjCMethod(const ObjCMethodDecl *OMD) {
-  llvm::SmallVector<const llvm::Type *, 16> ParamTypes;
-  for (unsigned i=0 ; i<OMD->param_size() ; i++) {
-    ParamTypes.push_back(ConvertType(OMD->getParamDecl(i)->getType()));
-  }
-  std::string CategoryName = "";
-  if (ObjCCategoryImplDecl *OCD =
-    dyn_cast<ObjCCategoryImplDecl>(OMD->getMethodContext())) {
-    CategoryName = OCD->getName();
-  }
-
-  CurFn =CGM.getObjCRuntime()->MethodPreamble(
-                            OMD->getClassInterface()->getName(),
-                            CategoryName,
-                            OMD->getSelector().getName(),
-                            ConvertType(OMD->getResultType()),
-                            llvm::PointerType::getUnqual(llvm::Type::Int32Ty),
-                            ParamTypes.begin(),
-                            OMD->param_size(),
-                            !OMD->isInstance(),
-                            OMD->isVariadic());
-  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
-  
-  // Create a marker to make it easy to insert allocas into the entryblock
-  // later.  Don't create this with the builder, because we don't want it
-  // folded.
-  llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
-  AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
-                                         EntryBB);
-
-  FnRetTy = OMD->getResultType();
-
-  Builder.SetInsertPoint(EntryBB);
-  
-  // Emit allocs for param decls.  Give the LLVM Argument nodes names.
-  llvm::Function::arg_iterator AI = CurFn->arg_begin();
-  
-  // Name the struct return argument.
-  // FIXME: Probably should be in the runtime, or it will trample the other
-  // hidden arguments.
-  if (hasAggregateLLVMType(OMD->getResultType())) {
-    AI->setName("agg.result");
-    ++AI;
-  }
-
-  // Add implicit parameters to the decl map.
-  // TODO: Add something to AST to let the runtime specify the names and types
-  // of these.
-  llvm::Value *&DMEntry = LocalDeclMap[&(*OMD->getSelfDecl())];
-  const llvm::Type *SelfTy = AI->getType();
-  llvm::Value *DeclPtr = new llvm::AllocaInst(SelfTy, 0, "self.addr",
-                                   AllocaInsertPt);
-
-  // Store the initial value into the alloca.
-  // FIXME: volatility
-  Builder.CreateStore(AI, DeclPtr);
-  DMEntry = DeclPtr;
-  ++AI; ++AI;
-
-
-  for (unsigned i = 0, e = OMD->getNumParams(); i != e; ++i, ++AI) {
-    assert(AI != CurFn->arg_end() && "Argument mismatch!");
-    EmitParmDecl(*OMD->getParamDecl(i), AI);
-  }
-  
+void CodeGenFunction::GenerateFunction(const Stmt *Body) {
   // Emit the function body.
-  EmitStmt(OMD->getBody());
+  EmitStmt(Body);
   
-  // Emit a return for code that falls off the end. If insert point
-  // is a dummy block with no predecessors then remove the block itself.
-  llvm::BasicBlock *BB = Builder.GetInsertBlock();
-  if (isDummyBlock(BB))
-    BB->eraseFromParent();
-  else {
-    if (CurFn->getReturnType() == llvm::Type::VoidTy)
-      Builder.CreateRetVoid();
-    else
-      Builder.CreateRet(llvm::UndefValue::get(CurFn->getReturnType()));
-  }
-  assert(BreakContinueStack.empty() &&
-         "mismatched push/pop in break/continue stack!");
-  
-  // Remove the AllocaInsertPt instruction, which is just a convenience for us.
-  AllocaInsertPt->eraseFromParent();
-  AllocaInsertPt = 0;
-  // Verify that the function is well formed.
-  assert(!verifyFunction(*CurFn) && "Generated method is not well formed.");
-}
-
-llvm::Value *CodeGenFunction::LoadObjCSelf(void)
-{
-  if(const ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(CurFuncDecl)) {
-    llvm::Value *SelfPtr = LocalDeclMap[&(*OMD->getSelfDecl())];
-    // FIXME: Volatility
-    return Builder.CreateLoad(SelfPtr, "self");
-  }
-  return NULL;
-}
-
-void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
-  LLVMIntTy = ConvertType(getContext().IntTy);
-  LLVMPointerWidth = static_cast<unsigned>(
-    getContext().getTypeSize(getContext().getPointerType(getContext().VoidTy)));
-  
-  CurFuncDecl = FD;
-  FnRetTy = FD->getType()->getAsFunctionType()->getResultType();
-
-  CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));
-  assert(CurFn->isDeclaration() && "Function already has body?");
-
-  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
-  
-  // Create a marker to make it easy to insert allocas into the entryblock
-  // later.  Don't create this with the builder, because we don't want it
-  // folded.
-  llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
-  AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
-                                         EntryBB);
-  
-  Builder.SetInsertPoint(EntryBB);
-
-  CGDebugInfo *DI = CGM.getDebugInfo();
-  if (DI) {
-    CompoundStmt* body = cast<CompoundStmt>(CurFuncDecl->getBody());
-    if (body->getLBracLoc().isValid()) {
-      DI->setLocation(body->getLBracLoc());
-    }
-    DI->EmitFunctionStart(FD, CurFn, Builder);
-  }
-
-  // Emit allocs for param decls.  Give the LLVM Argument nodes names.
-  llvm::Function::arg_iterator AI = CurFn->arg_begin();
-  
-  // Name the struct return argument.
-  if (hasAggregateLLVMType(FD->getResultType())) {
-    AI->setName("agg.result");
-    ++AI;
-  }
-  
-  for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i, ++AI) {
-    assert(AI != CurFn->arg_end() && "Argument mismatch!");
-    EmitParmDecl(*FD->getParamDecl(i), AI);
-  }
-  
-  // Emit the function body.
-  EmitStmt(FD->getBody());
-  
-  if (DI) {
-    CompoundStmt* body = cast<CompoundStmt>(CurFuncDecl->getBody());
-    if (body->getRBracLoc().isValid()) {
-      DI->setLocation(body->getRBracLoc());
-    }
-    DI->EmitRegionEnd(CurFn, Builder);
-  }
-
   // Emit a return for code that falls off the end. If insert point
   // is a dummy block with no predecessors then remove the block itself.
   llvm::BasicBlock *BB = Builder.GetInsertBlock();
@@ -238,6 +92,39 @@ void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
   assert(!verifyFunction(*CurFn) && "Generated function is not well formed.");
 }
 
+void CodeGenFunction::GenerateCode(const FunctionDecl *FD) {
+  CurFuncDecl = FD;
+  FnRetTy = FD->getResultType();
+  CurFn = cast<llvm::Function>(CGM.GetAddrOfFunctionDecl(FD, true));
+  assert(CurFn->isDeclaration() && "Function already has body?");
+
+  llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", CurFn);
+  
+  // Create a marker to make it easy to insert allocas into the entryblock
+  // later.  Don't create this with the builder, because we don't want it
+  // folded.
+  llvm::Value *Undef = llvm::UndefValue::get(llvm::Type::Int32Ty);
+  AllocaInsertPt = new llvm::BitCastInst(Undef, llvm::Type::Int32Ty, "allocapt",
+                                         EntryBB);
+  
+  Builder.SetInsertPoint(EntryBB);
+  
+  // Emit allocs for param decls.  Give the LLVM Argument nodes names.
+  llvm::Function::arg_iterator AI = CurFn->arg_begin();
+  
+  // Name the struct return argument.
+  if (hasAggregateLLVMType(FD->getResultType())) {
+    AI->setName("agg.result");
+    ++AI;
+  }
+  
+  for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i, ++AI) {
+    assert(AI != CurFn->arg_end() && "Argument mismatch!");
+    EmitParmDecl(*FD->getParamDecl(i), AI);
+  }
+  GenerateFunction(FD->getBody());
+}
+
 /// isDummyBlock - Return true if BB is an empty basic block
 /// with no predecessors.
 bool CodeGenFunction::isDummyBlock(const llvm::BasicBlock *BB) {
diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h
index 6712d2f05f17..b62042508cbb 100644
--- a/clang/lib/CodeGen/CodeGenFunction.h
+++ b/clang/lib/CodeGen/CodeGenFunction.h
@@ -232,7 +232,7 @@ public:
   llvm::IRBuilder Builder;
   
   // Holds the Decl for the current function or method
-  const FunctionDecl *CurFuncDecl;
+  const Decl *CurFuncDecl;
   QualType FnRetTy;
   llvm::Function *CurFn;
 
@@ -277,11 +277,16 @@ public:
 
   void GenerateObjCMethod(const ObjCMethodDecl *OMD);
   void GenerateCode(const FunctionDecl *FD);
+  void GenerateFunction(const Stmt *Body);
   
   const llvm::Type *ConvertType(QualType T);
 
   llvm::Value *LoadObjCSelf();
-  
+
+  /// isObjCPointerType - Return true if the specificed AST type will map onto
+  /// some Objective-C pointer type.
+  static bool isObjCPointerType(QualType T);
+
   /// hasAggregateLLVMType - Return true if the specified AST type will map into
   /// an aggregate LLVM type or is void.
   static bool hasAggregateLLVMType(QualType T);
diff --git a/clang/lib/CodeGen/CodeGenTypes.cpp b/clang/lib/CodeGen/CodeGenTypes.cpp
index 2f8784f7d5c4..7dfa2f850c6b 100644
--- a/clang/lib/CodeGen/CodeGenTypes.cpp
+++ b/clang/lib/CodeGen/CodeGenTypes.cpp
@@ -161,6 +161,13 @@ void CodeGenTypes::CollectObjCIvarTypes(ObjCInterfaceDecl *ObjCClass,
   }
 }
 
+const llvm::Type *CodeGenTypes::ConvertReturnType(QualType T) {
+  if (T->isVoidType())
+    return llvm::Type::VoidTy;    // Result of function uses llvm void.
+  else
+    return ConvertType(T);
+}
+
 static const llvm::Type* getTypeForFormat(const llvm::fltSemantics * format) {
   if (format == &llvm::APFloat::IEEEsingle)
     return llvm::Type::FloatTy;
diff --git a/clang/lib/CodeGen/CodeGenTypes.h b/clang/lib/CodeGen/CodeGenTypes.h
index 9bfd6bdb3a49..6c958e65e8db 100644
--- a/clang/lib/CodeGen/CodeGenTypes.h
+++ b/clang/lib/CodeGen/CodeGenTypes.h
@@ -132,6 +132,9 @@ public:
   /// ConvertType - Convert type T into a llvm::Type.  
   const llvm::Type *ConvertType(QualType T);
   const llvm::Type *ConvertTypeRecursive(QualType T);
+  /// ConvertReturnType - Convert T into an llvm::Type assuming that it will be
+  /// used as a function return type.
+  const llvm::Type *ConvertReturnType(QualType T);
   
   /// ConvertTypeForMem - Convert type T into a llvm::Type.  This differs from
   /// ConvertType in that it is used to convert to the memory representation for
@@ -143,6 +146,8 @@ public:
       std::vector<const llvm::Type*> &IvarTypes);
   
   const CGRecordLayout *getCGRecordLayout(const TagDecl*) const;
+  /// Returns a StructType representing an Objective-C object
+  const llvm::Type *ConvertObjCInterfaceToStruct(const ObjCInterfaceDecl *OID);
   
   /// getLLVMFieldNo - Return llvm::StructType element number
   /// that corresponds to the field FD.
diff --git a/clang/lib/Sema/Sema.h b/clang/lib/Sema/Sema.h
index 64ab91173300..b3b5941dc3a1 100644
--- a/clang/lib/Sema/Sema.h
+++ b/clang/lib/Sema/Sema.h
@@ -277,7 +277,7 @@ private:
 
   /// Helpers for dealing with function parameters
   bool CheckParmsForFunctionDef(FunctionDecl *FD);
-  ParmVarDecl *CreateImplicitParameter(Scope *S, IdentifierInfo *Id, 
+  ImplicitParamDecl *CreateImplicitParameter(Scope *S, IdentifierInfo *Id, 
                                        SourceLocation IdLoc, QualType Type);
   void CheckCXXDefaultArguments(FunctionDecl *FD);
   void CheckExtraCXXDefaultArguments(Declarator &D);
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 0bab523043cb..7af557b1a808 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -480,11 +480,11 @@ bool Sema::CheckParmsForFunctionDef(FunctionDecl *FD) {
 /// in the scope S and with the given type. This routine is used, for
 /// example, to create the implicit "self" parameter in an Objective-C
 /// method.
-ParmVarDecl *
+ImplicitParamDecl *
 Sema::CreateImplicitParameter(Scope *S, IdentifierInfo *Id, 
                               SourceLocation IdLoc, QualType Type) {
-  ParmVarDecl *New = ParmVarDecl::Create(Context, CurContext, IdLoc, Id, Type, 
-                                         VarDecl::None, 0, 0);
+  ImplicitParamDecl *New = ImplicitParamDecl::Create(Context, CurContext,
+      IdLoc, Id, Type, 0);
   if (Id)
     PushOnScopeChains(New, S);
 
diff --git a/clang/lib/Sema/SemaDeclObjC.cpp b/clang/lib/Sema/SemaDeclObjC.cpp
index 240e6c7a688d..a688c6e2d058 100644
--- a/clang/lib/Sema/SemaDeclObjC.cpp
+++ b/clang/lib/Sema/SemaDeclObjC.cpp
@@ -53,12 +53,12 @@ void Sema::ObjCActOnStartOfMethodDef(Scope *FnBodyScope, DeclTy *D) {
     }
   } else // we have a factory method.
     selfTy = Context.getObjCClassType();
-  CurMethodDecl->setSelfDecl(CreateImplicitParameter(FnBodyScope, PI.Ident, 
-                                                     PI.IdentLoc, selfTy));
+  CurMethodDecl->setSelfDecl(CreateImplicitParameter(FnBodyScope,
+        PI.Ident, PI.IdentLoc, selfTy));
   
   PI.Ident = &Context.Idents.get("_cmd");
-  CreateImplicitParameter(FnBodyScope, PI.Ident, PI.IdentLoc, 
-                          Context.getObjCSelType());
+  CurMethodDecl->setCmdDecl(CreateImplicitParameter(FnBodyScope,
+        PI.Ident, PI.IdentLoc, Context.getObjCSelType()));
 
   // Introduce all of the other parameters into this scope.
   for (unsigned i = 0, e = MDecl->getNumParams(); i != e; ++i) {