From: Anton Korobeynikov Date: Sun, 28 Jan 2007 13:36:18 +0000 (+0000) Subject: Drop CSRET CC X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=c4c87a30d22ef6b6bcc690d28807ccedc0e8d3e6 Drop CSRET CC git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33598 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y index cec366df592..ec21cee5013 100644 --- a/tools/llvm-upgrade/UpgradeParser.y +++ b/tools/llvm-upgrade/UpgradeParser.y @@ -570,7 +570,6 @@ static void ResolveTypeTo(char *Name, const Type *ToTy) { } } -/// @brief This just makes any name given to it unique, up to MAX_UINT times. static std::string makeNameUnique(const std::string& Name) { static unsigned UniqueNameCounter = 1; std::string Result(Name); @@ -578,57 +577,6 @@ static std::string makeNameUnique(const std::string& Name) { return Result; } -/// This is the implementation portion of TypeHasInteger. It traverses the -/// type given, avoiding recursive types, and returns true as soon as it finds -/// an integer type. If no integer type is found, it returns false. -static bool TypeHasIntegerI(const Type *Ty, std::vector Stack) { - // Handle some easy cases - if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID)) - return false; - if (Ty->isInteger()) - return true; - if (const SequentialType *STy = dyn_cast(Ty)) - return STy->getElementType()->isInteger(); - - // Avoid type structure recursion - for (std::vector::iterator I = Stack.begin(), E = Stack.end(); - I != E; ++I) - if (Ty == *I) - return false; - - // Push us on the type stack - Stack.push_back(Ty); - - if (const FunctionType *FTy = dyn_cast(Ty)) { - if (TypeHasIntegerI(FTy->getReturnType(), Stack)) - return true; - FunctionType::param_iterator I = FTy->param_begin(); - FunctionType::param_iterator E = FTy->param_end(); - for (; I != E; ++I) - if (TypeHasIntegerI(*I, Stack)) - return true; - return false; - } else if (const StructType *STy = dyn_cast(Ty)) { - StructType::element_iterator I = STy->element_begin(); - StructType::element_iterator E = STy->element_end(); - for (; I != E; ++I) { - if (TypeHasIntegerI(*I, Stack)) - return true; - } - return false; - } - // There shouldn't be anything else, but its definitely not integer - assert(0 && "What type is this?"); - return false; -} - -/// This is the interface to TypeHasIntegerI. It just provides the type stack, -/// to avoid recursion, and then calls TypeHasIntegerI. -static inline bool TypeHasInteger(const Type *Ty) { - std::vector TyStack; - return TypeHasIntegerI(Ty, TyStack); -} - // setValueName - Set the specified value to the name given. The name may be // null potentially, in which case this is a noop. The string passed in is // assumed to be a malloc'd string buffer, and is free'd by this function. @@ -657,16 +605,16 @@ static void setValueName(Value *V, char *NameStr) { } } if (Existing) { - // An existing value of the same name was found. This might have happened - // because of the integer type planes collapsing in LLVM 2.0. - if (Existing->getType() == V->getType() && - !TypeHasInteger(Existing->getType())) { - // If the type does not contain any integers in them then this can't be - // a type plane collapsing issue. It truly is a redefinition and we - // should error out as the assembly is invalid. - error("Redefinition of value named '" + Name + "' of type '" + - V->getType()->getDescription() + "'"); - return; + if (Existing->getType() == V->getType()) { + // The type of the Existing value and the new one are the same. This + // is probably a type plane collapsing error. If the types involved + // are both integer, just rename it. Otherwise it + // is a redefinition error. + if (!Existing->getType()->isInteger()) { + error("Redefinition of value named '" + Name + "' in the '" + + V->getType()->getDescription() + "' type plane"); + return; + } } // In LLVM 2.0 we don't allow names to be re-used for any values in a // function, regardless of Type. Previously re-use of names was okay as @@ -1628,7 +1576,7 @@ OptLinkage OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CCC_TOK { $$ = CallingConv::C; } - | CSRETCC_TOK { $$ = CallingConv::CSRet; } + | CSRETCC_TOK { $$ = CallingConv::C; } | FASTCC_TOK { $$ = CallingConv::Fast; } | COLDCC_TOK { $$ = CallingConv::Cold; } | X86_STDCALLCC_TOK { $$ = CallingConv::X86_StdCall; } diff --git a/tools/llvm-upgrade/UpgradeParser.y.cvs b/tools/llvm-upgrade/UpgradeParser.y.cvs index cec366df592..ec21cee5013 100644 --- a/tools/llvm-upgrade/UpgradeParser.y.cvs +++ b/tools/llvm-upgrade/UpgradeParser.y.cvs @@ -570,7 +570,6 @@ static void ResolveTypeTo(char *Name, const Type *ToTy) { } } -/// @brief This just makes any name given to it unique, up to MAX_UINT times. static std::string makeNameUnique(const std::string& Name) { static unsigned UniqueNameCounter = 1; std::string Result(Name); @@ -578,57 +577,6 @@ static std::string makeNameUnique(const std::string& Name) { return Result; } -/// This is the implementation portion of TypeHasInteger. It traverses the -/// type given, avoiding recursive types, and returns true as soon as it finds -/// an integer type. If no integer type is found, it returns false. -static bool TypeHasIntegerI(const Type *Ty, std::vector Stack) { - // Handle some easy cases - if (Ty->isPrimitiveType() || (Ty->getTypeID() == Type::OpaqueTyID)) - return false; - if (Ty->isInteger()) - return true; - if (const SequentialType *STy = dyn_cast(Ty)) - return STy->getElementType()->isInteger(); - - // Avoid type structure recursion - for (std::vector::iterator I = Stack.begin(), E = Stack.end(); - I != E; ++I) - if (Ty == *I) - return false; - - // Push us on the type stack - Stack.push_back(Ty); - - if (const FunctionType *FTy = dyn_cast(Ty)) { - if (TypeHasIntegerI(FTy->getReturnType(), Stack)) - return true; - FunctionType::param_iterator I = FTy->param_begin(); - FunctionType::param_iterator E = FTy->param_end(); - for (; I != E; ++I) - if (TypeHasIntegerI(*I, Stack)) - return true; - return false; - } else if (const StructType *STy = dyn_cast(Ty)) { - StructType::element_iterator I = STy->element_begin(); - StructType::element_iterator E = STy->element_end(); - for (; I != E; ++I) { - if (TypeHasIntegerI(*I, Stack)) - return true; - } - return false; - } - // There shouldn't be anything else, but its definitely not integer - assert(0 && "What type is this?"); - return false; -} - -/// This is the interface to TypeHasIntegerI. It just provides the type stack, -/// to avoid recursion, and then calls TypeHasIntegerI. -static inline bool TypeHasInteger(const Type *Ty) { - std::vector TyStack; - return TypeHasIntegerI(Ty, TyStack); -} - // setValueName - Set the specified value to the name given. The name may be // null potentially, in which case this is a noop. The string passed in is // assumed to be a malloc'd string buffer, and is free'd by this function. @@ -657,16 +605,16 @@ static void setValueName(Value *V, char *NameStr) { } } if (Existing) { - // An existing value of the same name was found. This might have happened - // because of the integer type planes collapsing in LLVM 2.0. - if (Existing->getType() == V->getType() && - !TypeHasInteger(Existing->getType())) { - // If the type does not contain any integers in them then this can't be - // a type plane collapsing issue. It truly is a redefinition and we - // should error out as the assembly is invalid. - error("Redefinition of value named '" + Name + "' of type '" + - V->getType()->getDescription() + "'"); - return; + if (Existing->getType() == V->getType()) { + // The type of the Existing value and the new one are the same. This + // is probably a type plane collapsing error. If the types involved + // are both integer, just rename it. Otherwise it + // is a redefinition error. + if (!Existing->getType()->isInteger()) { + error("Redefinition of value named '" + Name + "' in the '" + + V->getType()->getDescription() + "' type plane"); + return; + } } // In LLVM 2.0 we don't allow names to be re-used for any values in a // function, regardless of Type. Previously re-use of names was okay as @@ -1628,7 +1576,7 @@ OptLinkage OptCallingConv : /*empty*/ { $$ = CallingConv::C; } | CCC_TOK { $$ = CallingConv::C; } - | CSRETCC_TOK { $$ = CallingConv::CSRet; } + | CSRETCC_TOK { $$ = CallingConv::C; } | FASTCC_TOK { $$ = CallingConv::Fast; } | COLDCC_TOK { $$ = CallingConv::Cold; } | X86_STDCALLCC_TOK { $$ = CallingConv::X86_StdCall; }