diff --git a/include/llvm/Bytecode/Format.h b/include/llvm/Bytecode/Format.h
index a87f8d18a62..19f4e1990a3 100644
--- a/include/llvm/Bytecode/Format.h
+++ b/include/llvm/Bytecode/Format.h
@@ -18,7 +18,7 @@ public:
     Module = 0x01,
 
     // Module subtypes:
-    Method = 0x11,
+    Function = 0x11,
     ConstantPool,
     SymbolTable,
     ModuleGlobalInfo,
diff --git a/lib/Bytecode/Reader/ConstantReader.cpp b/lib/Bytecode/Reader/ConstantReader.cpp
index d5833dbeed5..79bb68f5559 100644
--- a/lib/Bytecode/Reader/ConstantReader.cpp
+++ b/lib/Bytecode/Reader/ConstantReader.cpp
@@ -28,7 +28,7 @@ const Type *BytecodeParser::parseTypeConstant(const uchar *&Buf,
     return Val;
   
   switch (PrimType) {
-  case Type::MethodTyID: {
+  case Type::FunctionTyID: {
     unsigned Typ;
     if (read_vbr(Buf, EndBuf, Typ)) return failure(Val);
     const Type *RetType = getType(Typ);
@@ -48,7 +48,7 @@ const Type *BytecodeParser::parseTypeConstant(const uchar *&Buf,
     bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
     if (isVarArg) Params.pop_back();
 
-    return MethodType::get(RetType, Params, isVarArg);
+    return FunctionType::get(RetType, Params, isVarArg);
   }
   case Type::ArrayTyID: {
     unsigned ElTyp;
diff --git a/lib/Bytecode/Reader/Reader.cpp b/lib/Bytecode/Reader/Reader.cpp
index 0b2e935ed4e..d7c8af3de7d 100644
--- a/lib/Bytecode/Reader/Reader.cpp
+++ b/lib/Bytecode/Reader/Reader.cpp
@@ -116,7 +116,7 @@ Value *BytecodeParser::getValue(const Type *Ty, unsigned oNum, bool Create) {
   Value *d = 0;
   switch (Ty->getPrimitiveID()) {
   case Type::LabelTyID: d = new    BBPHolder(Ty, oNum); break;
-  case Type::MethodTyID:
+  case Type::FunctionTyID:
     cerr << "Creating method pholder! : " << type << ":" << oNum << " " 
 	 << Ty->getName() << "\n";
     d = new MethPHolder(Ty, oNum);
@@ -260,12 +260,12 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
   // Clear out the local values table...
   Values.clear();
   if (MethodSignatureList.empty()) {
-    Error = "Method found, but MethodSignatureList empty!";
+    Error = "Function found, but FunctionSignatureList empty!";
     return failure(true);  // Unexpected method!
   }
 
   const PointerType *PMTy = MethodSignatureList.front().first; // PtrMeth
-  const MethodType  *MTy  = dyn_cast<const MethodType>(PMTy->getElementType());
+  const FunctionType *MTy  = dyn_cast<FunctionType>(PMTy->getElementType());
   if (MTy == 0) return failure(true);  // Not ptr to method!
 
   unsigned isInternal;
@@ -273,12 +273,12 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
 
   unsigned MethSlot = MethodSignatureList.front().second;
   MethodSignatureList.pop_front();
-  Method *M = new Method(MTy, isInternal != 0);
+  Function *M = new Function(MTy, isInternal != 0);
 
   BCR_TRACE(2, "METHOD TYPE: " << MTy << "\n");
 
-  const MethodType::ParamTypes &Params = MTy->getParamTypes();
-  for (MethodType::ParamTypes::const_iterator It = Params.begin();
+  const FunctionType::ParamTypes &Params = MTy->getParamTypes();
+  for (FunctionType::ParamTypes::const_iterator It = Params.begin();
        It != Params.end(); ++It) {
     FunctionArgument *FA = new FunctionArgument(*It);
     if (insertValue(FA, Values) == -1) {
@@ -292,7 +292,7 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
     unsigned Type, Size;
     const uchar *OldBuf = Buf;
     if (readBlock(Buf, EndBuf, Type, Size)) {
-      Error = "Error reading Method level block!";
+      Error = "Error reading Function level block!";
       delete M; return failure(true); 
     }
 
@@ -332,7 +332,7 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
     BCR_TRACE(2, "} end block\n");
 
     if (align32(Buf, EndBuf)) {
-      Error = "Error aligning Method level block!";
+      Error = "Error aligning Function level block!";
       delete M;    // Malformed bc file, read past end of block.
       return failure(true);
     }
@@ -346,7 +346,7 @@ bool BytecodeParser::ParseMethod(const uchar *&Buf, const uchar *EndBuf,
 
   Value *MethPHolder = getValue(PMTy, MethSlot, false);
   assert(MethPHolder && "Something is broken no placeholder found!");
-  assert(isa<Method>(MethPHolder) && "Not a method?");
+  assert(isa<Function>(MethPHolder) && "Not a function?");
 
   unsigned type;  // Type slot
   assert(!getTypeSlot(MTy, type) && "How can meth type not exist?");
@@ -433,12 +433,12 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
   while (MethSignature != Type::VoidTyID) { // List is terminated by Void
     const Type *Ty = getType(MethSignature);
     if (!Ty || !isa<PointerType>(Ty) ||
-        !isa<MethodType>(cast<PointerType>(Ty)->getElementType())) { 
-      Error = "Method not ptr to meth type!  Ty = " + Ty->getDescription();
+        !isa<FunctionType>(cast<PointerType>(Ty)->getElementType())) { 
+      Error = "Function not ptr to func type!  Ty = " + Ty->getDescription();
       return failure(true); 
     }
     
-    // We create methods by passing the underlying MethodType to create...
+    // We create methods by passing the underlying FunctionType to create...
     Ty = cast<PointerType>(Ty)->getElementType();
 
     // When the ModuleGlobalInfo section is read, we load the type of each 
@@ -462,7 +462,7 @@ bool BytecodeParser::ParseModuleGlobalInfo(const uchar *&Buf, const uchar *End,
     MethodSignatureList.push_back(
            make_pair(cast<const PointerType>(Val->getType()), SlotNo));
     if (read_vbr(Buf, End, MethSignature)) return failure(true);
-    BCR_TRACE(2, "Method of type: " << Ty << "\n");
+    BCR_TRACE(2, "Function of type: " << Ty << "\n");
   }
 
   if (align32(Buf, End)) return failure(true);
@@ -512,8 +512,8 @@ bool BytecodeParser::ParseModule(const uchar *Buf, const uchar *EndBuf,
       }
       break;
 
-    case BytecodeFormat::Method: {
-      BCR_TRACE(1, "BLOCK BytecodeFormat::Method: {\n");
+    case BytecodeFormat::Function: {
+      BCR_TRACE(1, "BLOCK BytecodeFormat::Function: {\n");
       if (ParseMethod(Buf, Buf+Size, C)) {
 	delete C; return failure(true);               // Error parsing method
       }
@@ -538,7 +538,7 @@ bool BytecodeParser::ParseModule(const uchar *Buf, const uchar *EndBuf,
   }
 
   if (!MethodSignatureList.empty()) {     // Expected more methods!
-    Error = "Method expected, but bytecode stream at end!";
+    Error = "Function expected, but bytecode stream at end!";
     return failure(true);
   }
 
diff --git a/lib/Bytecode/Reader/ReaderInternals.h b/lib/Bytecode/Reader/ReaderInternals.h
index 54cda44a6b4..d36ea6def62 100644
--- a/lib/Bytecode/Reader/ReaderInternals.h
+++ b/lib/Bytecode/Reader/ReaderInternals.h
@@ -9,7 +9,7 @@
 
 #include "llvm/Bytecode/Primitives.h"
 #include "llvm/SymTabValue.h"
-#include "llvm/Method.h"
+#include "llvm/Function.h"
 #include "llvm/BasicBlock.h"
 #include "llvm/Instruction.h"
 #include "llvm/DerivedTypes.h"
@@ -143,9 +143,9 @@ struct BBPlaceHolderHelper : public BasicBlock {
   }
 };
 
-struct MethPlaceHolderHelper : public Method {
+struct MethPlaceHolderHelper : public Function {
   MethPlaceHolderHelper(const Type *Ty) 
-    : Method(cast<const MethodType>(Ty), true) {
+    : Function(cast<const FunctionType>(Ty), true) {
   }
 };
 
@@ -155,9 +155,9 @@ typedef PlaceholderDef<MethPlaceHolderHelper>  MethPHolder;
 
 static inline unsigned getValueIDNumberFromPlaceHolder(Value *Def) {
   switch (Def->getType()->getPrimitiveID()) {
-  case Type::LabelTyID:  return ((BBPHolder*)Def)->getID();
-  case Type::MethodTyID: return ((MethPHolder*)Def)->getID();
-  default:               return ((DefPHolder*)Def)->getID();
+  case Type::LabelTyID:    return ((BBPHolder*)Def)->getID();
+  case Type::FunctionTyID: return ((MethPHolder*)Def)->getID();
+  default:                 return ((DefPHolder*)Def)->getID();
   }
 }
 
diff --git a/lib/Bytecode/Writer/ConstantWriter.cpp b/lib/Bytecode/Writer/ConstantWriter.cpp
index 73130f3ee87..296e326445a 100644
--- a/lib/Bytecode/Writer/ConstantWriter.cpp
+++ b/lib/Bytecode/Writer/ConstantWriter.cpp
@@ -24,8 +24,8 @@ void BytecodeWriter::outputType(const Type *T) {
     return;     // We might do this if we alias a prim type: %x = type int
   
   switch (T->getPrimitiveID()) {   // Handle derived types now.
-  case Type::MethodTyID: {
-    const MethodType *MT = cast<const MethodType>(T);
+  case Type::FunctionTyID: {
+    const FunctionType *MT = cast<const FunctionType>(T);
     int Slot = Table.getValSlot(MT->getReturnType());
     assert(Slot != -1 && "Type used but not available!!");
     output_vbr((unsigned)Slot, Out);
@@ -34,7 +34,7 @@ void BytecodeWriter::outputType(const Type *T) {
     output_vbr(MT->getParamTypes().size()+MT->isVarArg(), Out);
 
     // Output all of the arguments...
-    MethodType::ParamTypes::const_iterator I = MT->getParamTypes().begin();
+    FunctionType::ParamTypes::const_iterator I = MT->getParamTypes().begin();
     for (; I != MT->getParamTypes().end(); ++I) {
       Slot = Table.getValSlot(*I);
       assert(Slot != -1 && "Type used but not available!!");
diff --git a/lib/Bytecode/Writer/Writer.cpp b/lib/Bytecode/Writer/Writer.cpp
index a83bd1642cc..af53ee5c0e1 100644
--- a/lib/Bytecode/Writer/Writer.cpp
+++ b/lib/Bytecode/Writer/Writer.cpp
@@ -150,7 +150,7 @@ void BytecodeWriter::outputModuleInfoBlock(const Module *M) {
 }
 
 void BytecodeWriter::processMethod(const Function *M) {
-  BytecodeBlock FunctionBlock(BytecodeFormat::Method, Out);
+  BytecodeBlock FunctionBlock(BytecodeFormat::Function, Out);
   output_vbr((unsigned)M->hasInternalLinkage(), Out);
   // Only output the constant pool and other goodies if needed...
   if (!M->isExternal()) {
diff --git a/lib/Target/SparcV9/SparcV9Internals.h b/lib/Target/SparcV9/SparcV9Internals.h
index 41ad8a911ee..1de5496cbfe 100644
--- a/lib/Target/SparcV9/SparcV9Internals.h
+++ b/lib/Target/SparcV9/SparcV9Internals.h
@@ -304,8 +304,9 @@ public:
     Type::PrimitiveID ty = type->getPrimitiveID();
     unsigned res;
     
+    // FIXME: Comparing types like this isn't very safe...
     if ((ty && ty <= Type::LongTyID) || (ty == Type::LabelTyID) ||
-	(ty == Type::MethodTyID) ||  (ty == Type::PointerTyID) )
+	(ty == Type::FunctionTyID) ||  (ty == Type::PointerTyID) )
       res = IntRegClassID;             // sparc int reg (ty=0: void)
     else if (ty <= Type::DoubleTyID)
       res = FloatRegClassID;           // sparc float reg class