From 697ba1a507f0e248652165c4d3f84bed9660bbb2 Mon Sep 17 00:00:00 2001 From: Reid Spencer Date: Fri, 26 Jan 2007 17:13:53 +0000 Subject: [PATCH] Remove the SignedType class and other dead code. Improve comments. llvm-svn: 33538 --- llvm/tools/llvm-upgrade/UpgradeInternals.h | 41 ++---- llvm/tools/llvm-upgrade/UpgradeParser.y | 138 +-------------------- 2 files changed, 13 insertions(+), 166 deletions(-) diff --git a/llvm/tools/llvm-upgrade/UpgradeInternals.h b/llvm/tools/llvm-upgrade/UpgradeInternals.h index 4fe0ed07564b..5057e70be42c 100644 --- a/llvm/tools/llvm-upgrade/UpgradeInternals.h +++ b/llvm/tools/llvm-upgrade/UpgradeInternals.h @@ -38,30 +38,6 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in, bool debug, bool addAttrs); -class SignedType : public IntegerType { - const IntegerType *base_type; - static SignedType *SByteTy; - static SignedType *SShortTy; - static SignedType *SIntTy; - static SignedType *SLongTy; - SignedType(const IntegerType* ITy); -public: - static const SignedType *get(const IntegerType* ITy); - - bool isSigned() const { return true; } - const IntegerType* getBaseType() const { - return base_type; - } - const IntegerType* resolve() const { - ForwardType = base_type; - return base_type; - } - - // Methods for support type inquiry through isa, cast, and dyn_cast: - static inline bool classof(const SignedType *T) { return true; } - static inline bool classof(const Type *T); -}; - extern std::istream* LexInput; // UnEscapeLexed - Run through the specified buffer and change \xx codes to the @@ -206,14 +182,9 @@ struct ValID { } }; - -// This structure is used to keep track of obsolete opcodes. The lexer will -// retain the ability to parse obsolete opcode mnemonics. In this case it will -// set "obsolete" to true and the opcode will be the replacement opcode. For -// example if "rem" is encountered then opcode will be set to "urem" and the -// "obsolete" flag will be true. If the opcode is not obsolete then "obsolete" -// will be false. - +/// The following enums are used to keep track of prior opcodes. The lexer will +/// retain the ability to parse obsolete opcode mnemonics and generates semantic +/// values containing one of these enumerators. enum TermOps { RetOp, BrOp, SwitchOp, InvokeOp, UnwindOp, UnreachableOp }; @@ -242,8 +213,14 @@ enum CastOps { UIToFPOp, SIToFPOp, PtrToIntOp, IntToPtrOp, BitCastOp }; +/// An enumeration for defining the Signedness of a type or value. Signless +/// means the signedness is not relevant to the type or value. enum Signedness { Signless, Unsigned, Signed }; +/// These structures are used as the semantic values returned from various +/// productions in the grammar. They simply bundle an LLVM IR object with +/// its Signedness value. These help track signedness through the various +/// productions. struct TypeInfo { const llvm::Type *T; Signedness S; diff --git a/llvm/tools/llvm-upgrade/UpgradeParser.y b/llvm/tools/llvm-upgrade/UpgradeParser.y index ca6e7cd515e1..e42ebc758be7 100644 --- a/llvm/tools/llvm-upgrade/UpgradeParser.y +++ b/llvm/tools/llvm-upgrade/UpgradeParser.y @@ -48,132 +48,6 @@ static void warning(const std::string& WarningMsg); namespace llvm { - -SignedType *SignedType::SByteTy = 0; -SignedType *SignedType::SShortTy = 0; -SignedType *SignedType::SIntTy = 0; -SignedType *SignedType::SLongTy = 0; - -inline bool SignedType::classof(const Type *T) { - if (T->getTypeID() != IntegerTyID) - return false; - return (T == SByteTy || T == SShortTy || T == SIntTy || T == SLongTy ); -} - -SignedType::SignedType(const IntegerType* ITy) - : IntegerType(ITy->getBitWidth()), base_type(ITy) -{ -} - -const SignedType *SignedType::get(const IntegerType* ITy) { - if (ITy == Type::Int8Ty) { - if (!SByteTy) - SByteTy = new SignedType(IntegerType::get(8)); - return SByteTy; - } else if (ITy == Type::Int16Ty) { - if (!SShortTy) - SShortTy = new SignedType(IntegerType::get(16)); - return SShortTy; - } else if (ITy == Type::Int32Ty) { - if (!SIntTy) - SIntTy = new SignedType(IntegerType::get(32)); - return SIntTy; - } else if (ITy == Type::Int64Ty) { - if (!SLongTy) - SLongTy = new SignedType(IntegerType::get(64)); - return SLongTy; - } else - assert(0 && "Invalid integer type for SignedType::get"); -} - -static inline Signedness getSign(const Type *&Ty) { - if (const SignedType *STy = dyn_cast(Ty)) { - Ty = STy->getBaseType(); - return Signed; - } else if (isa(Ty)) - return Unsigned; - return Signless; -} - -static const Type* -resolveTypeImpl(const Type* Ty, std::vector& TyStack) -{ - // Nothing to resolve if it isn't a derived type - if (!Ty->isDerivedType()) - return Ty; - - // Prevent infinite recursion for recursive types - for (std::vector::const_iterator I = TyStack.begin(), - E = TyStack.end(); I != E; ++I) - if (Ty == *I) - return Ty; - - // Okay, haven't seen this derived type yet, push it on the stack. - const Type* Result = Ty; - TyStack.push_back(Ty); - - // Process the type - switch (Ty->getTypeID()) { - default: assert(0 && "Invalid derived type"); - case Type::IntegerTyID: - break; - case Type::FunctionTyID: { - const FunctionType* FTy = cast(Ty); - const Type* RetTy = resolveTypeImpl(FTy->getReturnType(), TyStack); - std::vector Types; - FunctionType::ParamAttrsList Attrs; - Attrs.push_back(FTy->getParamAttrs(0)); - for (unsigned i = 0; i < FTy->getNumParams(); ++i) { - Types.push_back(resolveTypeImpl(FTy->getParamType(i), TyStack)); - Attrs.push_back(FTy->getParamAttrs(i+1)); - } - Result = FunctionType::get(RetTy, Types, FTy->isVarArg(), Attrs); - break; - } - case Type::StructTyID: - case Type::PackedStructTyID: { - const StructType *STy = cast(Ty); - std::vector FieldTypes; - for (unsigned i = 0; i < STy->getNumElements(); ++i) - FieldTypes.push_back(resolveTypeImpl(STy->getElementType(i), TyStack)); - Result = StructType::get(FieldTypes, STy->isPacked()); - break; - } - case Type::ArrayTyID: { - const ArrayType *ATy = cast(Ty); - uint64_t NElems = ATy->getNumElements(); - const Type *ElemTy = resolveTypeImpl(ATy->getElementType(), TyStack); - Result = ArrayType::get(ElemTy, NElems); - break; - } - case Type::PointerTyID: { - const PointerType *PTy = cast(Ty); - const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack); - Result = PointerType::get(ElemTy); - break; - } - case Type::PackedTyID: { - const PackedType *PTy = cast(Ty); - unsigned NElems = PTy->getNumElements(); - const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack); - Result = PackedType::get(ElemTy, NElems); - break; - } - } - // Done with it, pop it off. - TyStack.pop_back(); - return Result; -} - -static inline const Type* resolveType(const Type* Ty) { - if (!Ty) - return 0; - if (const SignedType* STy = dyn_cast(Ty)) - return STy->getBaseType(); - std::vector TyStack; - return resolveTypeImpl(Ty, TyStack); -} - std::istream* LexInput; static std::string CurFilename; @@ -187,8 +61,6 @@ static bool NewVarArgs; static BasicBlock *CurBB; static GlobalVariable *CurGV; - - // This contains info used when building the body of a function. It is // destroyed when the function is completed. // @@ -299,7 +171,6 @@ static struct PerFunctionInfo { std::map > BBForwardRefs; std::vector NumberedBlocks; RenameMapType RenameMap; - std::set SignedValues; unsigned NextBBNum; inline PerFunctionInfo() { @@ -328,7 +199,6 @@ static struct PerFunctionInfo { Values.clear(); // Clear out function local definitions RenameMap.clear(); - SignedValues.clear(); CurrentFunction = 0; isDeclare = false; Linkage = GlobalValue::ExternalLinkage; @@ -352,7 +222,7 @@ static int InsertValue(Value *V, return List.size()-1; } -static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) { +static const Type *getType(const ValID &D, bool DoNotImprovise = false) { switch (D.Type) { case ValID::NumberVal: // Is it a numbered definition? // Module constants occupy the lowest numbered slots... @@ -540,7 +410,6 @@ static Value *getVal(const Type *Ty, const ValID &ID) { // If we reached here, we referenced either a symbol that we don't know about // or an id number that hasn't been read yet. We may be referencing something // forward, so just create an entry to be resolved later and get to it... - assert(!isa(Ty) && "Can't create value with SignedType"); V = new Argument(Ty); // Remember where this forward reference came from. FIXME, shouldn't we try @@ -722,7 +591,6 @@ static void setValueName(Value *V, char *NameStr) { return; } - assert(!isa(V->getType()) && "Shouldn't have SignedType Value"); assert(inFunctionScope() && "Must be in function scope"); // Search the function's symbol table for an existing value of this name @@ -1532,6 +1400,7 @@ using namespace llvm; // ValueRef - Unresolved reference to a definition or BB %type ValueRef ConstValueRef SymbolicValueRef %type ResolvedVal // pair + // Tokens and types for handling constant integer values // // ESINT64VAL - A negative number within long long range @@ -1588,6 +1457,7 @@ using namespace llvm; %token EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR %token VAARG_old VANEXT_old //OBSOLETE +// Support for ICmp/FCmp Predicates, which is 1.9++ but not 2.0 %type IPredicates %type FPredicates %token EQ NE SLT SGT SLE SGE ULT UGT ULE UGE @@ -1818,7 +1688,7 @@ UpRTypes $$.S = Signless; } | SymbolicValueRef { // Named types are also simple types... - const Type* tmp = getTypeVal($1); + const Type* tmp = getType($1); $$.T = new PATypeHolder(tmp); $$.S = Signless; // FIXME: what if its signed? }