diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index 5856531..9420f95 100644
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -370,7 +370,8 @@
 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 @@
     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/lib/CodeGen/CGObjC.cpp b/lib/CodeGen/CGObjC.cpp
index d666ab1..a080a22 100644
--- a/lib/CodeGen/CGObjC.cpp
+++ b/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 @@
   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/lib/CodeGen/CodeGenFunction.cpp b/lib/CodeGen/CodeGenFunction.cpp
index c8ef8fc..ebc1ff5 100644
--- a/lib/CodeGen/CodeGenFunction.cpp
+++ b/lib/CodeGen/CodeGenFunction.cpp
@@ -27,7 +27,10 @@
 
 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,82 +54,20 @@
   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.
@@ -134,93 +75,6 @@
   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();
-  if (isDummyBlock(BB))
-    BB->eraseFromParent();
-  else {
     // FIXME: if this is C++ main, this should return 0.
     if (CurFn->getReturnType() == llvm::Type::VoidTy)
       Builder.CreateRetVoid();
@@ -238,6 +92,39 @@
   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/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index 6712d2f..b620425 100644
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -232,7 +232,7 @@
   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 @@
 
   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/lib/CodeGen/CodeGenTypes.cpp b/lib/CodeGen/CodeGenTypes.cpp
index 2f8784f..7dfa2f8 100644
--- a/lib/CodeGen/CodeGenTypes.cpp
+++ b/lib/CodeGen/CodeGenTypes.cpp
@@ -161,6 +161,13 @@
   }
 }
 
+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/lib/CodeGen/CodeGenTypes.h b/lib/CodeGen/CodeGenTypes.h
index 9bfd6bd..6c958e6 100644
--- a/lib/CodeGen/CodeGenTypes.h
+++ b/lib/CodeGen/CodeGenTypes.h
@@ -132,6 +132,9 @@
   /// 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 @@
       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.