From 8c98acc07f7bbbfa9cb1b2c14830e632b82c6561 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Fri, 29 Mar 2002 03:51:11 +0000 Subject: [PATCH] s/Method/Function llvm-svn: 2035 --- include/llvm/Bytecode/Format.h | 2 +- lib/Bytecode/Reader/ConstantReader.cpp | 4 ++-- lib/Bytecode/Reader/Reader.cpp | 32 +++++++++++++------------- lib/Bytecode/Reader/ReaderInternals.h | 12 +++++----- lib/Bytecode/Writer/ConstantWriter.cpp | 6 ++--- lib/Bytecode/Writer/Writer.cpp | 2 +- lib/Target/Sparc/SparcInternals.h | 3 ++- 7 files changed, 31 insertions(+), 30 deletions(-) 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(PMTy->getElementType()); + const FunctionType *MTy = dyn_cast(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(MethPHolder) && "Not a method?"); + assert(isa(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(Ty) || - !isa(cast(Ty)->getElementType())) { - Error = "Method not ptr to meth type! Ty = " + Ty->getDescription(); + !isa(cast(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(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(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(Ty), true) { + : Function(cast(Ty), true) { } }; @@ -155,9 +155,9 @@ typedef PlaceholderDef 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(T); + case Type::FunctionTyID: { + const FunctionType *MT = cast(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/Sparc/SparcInternals.h b/lib/Target/Sparc/SparcInternals.h index 41ad8a911ee..1de5496cbfe 100644 --- a/lib/Target/Sparc/SparcInternals.h +++ b/lib/Target/Sparc/SparcInternals.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