From 0d51e7ec0d2dcbea9e304fd58deb05f37eb75635 Mon Sep 17 00:00:00 2001 From: Dale Johannesen Date: Tue, 19 Feb 2008 21:38:47 +0000 Subject: [PATCH] Expand ParameterAttributes to 32 bits (in preparation for adding alignment info, not there yet). Clean up interfaces to reference ParameterAttributes consistently. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@47342 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Function.h | 3 +- include/llvm/Instructions.h | 3 +- include/llvm/ParameterAttributes.h | 62 ++++++++++--------- include/llvm/Support/CallSite.h | 3 +- lib/AsmParser/llvmAsmParser.y | 2 +- lib/Bitcode/Writer/BitcodeWriter.cpp | 2 +- lib/Transforms/IPO/ArgumentPromotion.cpp | 14 +++-- .../IPO/DeadArgumentElimination.cpp | 13 ++-- lib/Transforms/IPO/PruneEH.cpp | 2 +- .../Scalar/InstructionCombining.cpp | 21 ++++--- lib/VMCore/AsmWriter.cpp | 23 ++++--- lib/VMCore/Function.cpp | 6 +- lib/VMCore/Instructions.cpp | 18 +++--- lib/VMCore/ParameterAttributes.cpp | 22 ++++--- lib/VMCore/Verifier.cpp | 22 +++---- tools/llvm2cpp/CppWriter.cpp | 2 +- 16 files changed, 122 insertions(+), 96 deletions(-) diff --git a/include/llvm/Function.h b/include/llvm/Function.h index 2c4f9d9e27d..e2b41fe25da 100644 --- a/include/llvm/Function.h +++ b/include/llvm/Function.h @@ -22,6 +22,7 @@ #include "llvm/BasicBlock.h" #include "llvm/Argument.h" #include "llvm/Support/Annotation.h" +#include "llvm/ParameterAttributes.h" namespace llvm { @@ -163,7 +164,7 @@ public: void clearCollector(); /// @brief Determine whether the function has the given attribute. - bool paramHasAttr(uint16_t i, unsigned attr) const; + bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; /// @brief Determine if the function cannot return. bool doesNotReturn() const; diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 49ec4f54fd5..2de8c57d8ed 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -20,6 +20,7 @@ #include "llvm/InstrTypes.h" #include "llvm/DerivedTypes.h" +#include "llvm/ParameterAttributes.h" namespace llvm { @@ -1735,7 +1736,7 @@ public: void setParamAttrs(const ParamAttrsList *attrs); /// @brief Determine whether the call or the callee has the given attribute. - bool paramHasAttr(uint16_t i, unsigned attr) const; + bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; /// @brief Determine if the call does not access memory. bool doesNotAccessMemory() const; diff --git a/include/llvm/ParameterAttributes.h b/include/llvm/ParameterAttributes.h index 31f9eb4a080..270ff6501fd 100644 --- a/include/llvm/ParameterAttributes.h +++ b/include/llvm/ParameterAttributes.h @@ -31,50 +31,55 @@ namespace ParamAttr { /// lists the attributes that can be associated with parameters or function /// results. /// @brief Function parameter attributes. -enum Attributes { - None = 0, ///< No attributes have been set - ZExt = 1 << 0, ///< Zero extended before/after call - SExt = 1 << 1, ///< Sign extended before/after call - NoReturn = 1 << 2, ///< Mark the function as not returning - InReg = 1 << 3, ///< Force argument to be passed in register - StructRet = 1 << 4, ///< Hidden pointer to structure to return - NoUnwind = 1 << 5, ///< Function doesn't unwind stack - NoAlias = 1 << 6, ///< Considered to not alias after call - ByVal = 1 << 7, ///< Pass structure by value - Nest = 1 << 8, ///< Nested function static chain - ReadNone = 1 << 9, ///< Function does not access memory - ReadOnly = 1 << 10 ///< Function only reads from memory -}; + +/// @brief A more friendly way to reference the attributes. +typedef uint32_t Attributes; + +const Attributes None = 0; ///< No attributes have been set +const Attributes ZExt = 1<<0; ///< Zero extended before/after call +const Attributes SExt = 1<<1; ///< Sign extended before/after call +const Attributes NoReturn = 1<<2; ///< Mark the function as not returning +const Attributes InReg = 1<<3; ///< Force argument to be passed in register +const Attributes StructRet = 1<<4; ///< Hidden pointer to structure to return +const Attributes NoUnwind = 1<<5; ///< Function doesn't unwind stack +const Attributes NoAlias = 1<<6; ///< Considered to not alias after call +const Attributes ByVal = 1<<7; ///< Pass structure by value +const Attributes Nest = 1<<8; ///< Nested function static chain +const Attributes ReadNone = 1<<9; ///< Function does not access memory +const Attributes ReadOnly = 1<<10; ///< Function only reads from memory /// @brief Attributes that only apply to function parameters. -const uint16_t ParameterOnly = ByVal | InReg | Nest | StructRet; +const Attributes ParameterOnly = ByVal | InReg | Nest | StructRet; /// @brief Attributes that only apply to function return values. -const uint16_t ReturnOnly = NoReturn | NoUnwind | ReadNone | ReadOnly; +const Attributes ReturnOnly = NoReturn | NoUnwind | ReadNone | ReadOnly; /// @brief Parameter attributes that do not apply to vararg call arguments. -const uint16_t VarArgsIncompatible = StructRet; +const Attributes VarArgsIncompatible = StructRet; /// @brief Attributes that are mutually incompatible. -const uint16_t MutuallyIncompatible[3] = { +const Attributes MutuallyIncompatible[3] = { ByVal | InReg | Nest | StructRet, ZExt | SExt, ReadNone | ReadOnly }; /// @brief Which attributes cannot be applied to a type. -uint16_t typeIncompatible (const Type *Ty); +Attributes typeIncompatible (const Type *Ty); } // end namespace ParamAttr +/// @brief A more friendly way to reference the attributes. +typedef ParamAttr::Attributes ParameterAttributes; + /// This is just a pair of values to associate a set of parameter attributes /// with a parameter index. /// @brief ParameterAttributes with a parameter index. struct ParamAttrsWithIndex { - uint16_t attrs; ///< The attributes that are set, or'd together + ParameterAttributes attrs; ///< The attributes that are set, or'd together uint16_t index; ///< Index of the parameter for which the attributes apply - static ParamAttrsWithIndex get(uint16_t idx, uint16_t attrs) { + static ParamAttrsWithIndex get(uint16_t idx, ParameterAttributes attrs) { ParamAttrsWithIndex P; P.index = idx; P.attrs = attrs; @@ -85,9 +90,6 @@ struct ParamAttrsWithIndex { /// @brief A vector of attribute/index pairs. typedef SmallVector ParamAttrsVector; -/// @brief A more friendly way to reference the attributes. -typedef ParamAttr::Attributes ParameterAttributes; - /// This class represents a list of attribute/index pairs for parameter /// attributes. Each entry in the list contains the index of a function /// parameter and the associated ParameterAttributes. If a parameter's index is @@ -143,11 +145,13 @@ class ParamAttrsList : public FoldingSetNode { /// @brief Add the specified attributes to those in PAL at index idx. static const ParamAttrsList *includeAttrs(const ParamAttrsList *PAL, - uint16_t idx, uint16_t attrs); + uint16_t idx, + ParameterAttributes attrs); /// @brief Remove the specified attributes from those in PAL at index idx. static const ParamAttrsList *excludeAttrs(const ParamAttrsList *PAL, - uint16_t idx, uint16_t attrs); + uint16_t idx, + ParameterAttributes attrs); /// @} /// @name Accessors @@ -161,7 +165,7 @@ class ParamAttrsList : public FoldingSetNode { /// @returns The all the ParameterAttributes for the \p indexth parameter /// as a uint16_t of enumeration values OR'd together. /// @brief Get the attributes for a parameter - uint16_t getParamAttrs(uint16_t param_index) const; + ParameterAttributes getParamAttrs(uint16_t param_index) const; /// This checks to see if the \p ith function parameter has the parameter /// attribute given by \p attr set. @@ -181,7 +185,7 @@ class ParamAttrsList : public FoldingSetNode { /// string of equivalent mnemonics. This is, presumably, for writing out /// the mnemonics for the assembly writer. /// @brief Convert parameter attribute bits to text - static std::string getParamAttrsText(uint16_t Attributes); + static std::string getParamAttrsText(ParameterAttributes Attributes); /// The \p Indexth parameter attribute is converted to string. /// @brief Get the text for the parmeter attributes for one parameter. @@ -218,7 +222,7 @@ class ParamAttrsList : public FoldingSetNode { return attrs[attr_index].index; } - uint16_t getParamAttrsAtIndex(unsigned attr_index) const { + ParameterAttributes getParamAttrsAtIndex(unsigned attr_index) const { return attrs[attr_index].attrs; } diff --git a/include/llvm/Support/CallSite.h b/include/llvm/Support/CallSite.h index cbb6548fc47..401e5588db1 100644 --- a/include/llvm/Support/CallSite.h +++ b/include/llvm/Support/CallSite.h @@ -22,6 +22,7 @@ #include "llvm/Instruction.h" #include "llvm/BasicBlock.h" +#include "llvm/ParameterAttributes.h" namespace llvm { @@ -65,7 +66,7 @@ public: void setParamAttrs(const ParamAttrsList *PAL); /// paramHasAttr - whether the call or the callee has the given attribute. - bool paramHasAttr(uint16_t i, unsigned attr) const; + bool paramHasAttr(uint16_t i, ParameterAttributes attr) const; /// @brief Determine if the call does not access memory. bool doesNotAccessMemory() const; diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y index ccfe44ab82f..2848945648e 100644 --- a/lib/AsmParser/llvmAsmParser.y +++ b/lib/AsmParser/llvmAsmParser.y @@ -974,7 +974,7 @@ Module *llvm::RunVMAsmParser(llvm::MemoryBuffer *MB) { llvm::GlobalValue::LinkageTypes Linkage; llvm::GlobalValue::VisibilityTypes Visibility; - uint16_t ParamAttrs; + llvm::ParameterAttributes ParamAttrs; llvm::APInt *APIntVal; int64_t SInt64Val; uint64_t UInt64Val; diff --git a/lib/Bitcode/Writer/BitcodeWriter.cpp b/lib/Bitcode/Writer/BitcodeWriter.cpp index fe013e81569..3f7cfcc2095 100644 --- a/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -119,7 +119,7 @@ static void WriteParamAttrTable(const ValueEnumerator &VE, const ParamAttrsList *A = Attrs[i]; for (unsigned op = 0, e = A->size(); op != e; ++op) { Record.push_back(A->getParamIndex(op)); - Record.push_back(A->getParamAttrsAtIndex(op)); + Record.push_back((uint16_t)A->getParamAttrsAtIndex(op)); } Stream.EmitRecord(bitc::PARAMATTR_CODE_ENTRY, Record); diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index 4486677e630..894e6ba564b 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -405,7 +405,7 @@ Function *ArgPromotion::DoPromotion(Function *F, const ParamAttrsList *PAL = F->getParamAttrs(); // Add any return attributes. - if (unsigned attrs = PAL ? PAL->getParamAttrs(0) : 0) + if (ParameterAttributes attrs = PAL ? PAL->getParamAttrs(0) : ParamAttr::None) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(0, attrs)); unsigned ArgIndex = 1; @@ -420,7 +420,8 @@ Function *ArgPromotion::DoPromotion(Function *F, ++NumByValArgsPromoted; } else if (!ArgsToPromote.count(I)) { Params.push_back(I->getType()); - if (unsigned attrs = PAL ? PAL->getParamAttrs(ArgIndex) : 0) + if (ParameterAttributes attrs = PAL ? PAL->getParamAttrs(ArgIndex) : + ParamAttr::None) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Params.size(), attrs)); } else if (I->use_empty()) { ++NumArgumentsDead; @@ -496,7 +497,8 @@ Function *ArgPromotion::DoPromotion(Function *F, PAL = CS.getParamAttrs(); // Add any return attributes. - if (unsigned attrs = PAL ? PAL->getParamAttrs(0) : 0) + if (ParameterAttributes attrs = PAL ? PAL->getParamAttrs(0) : + ParamAttr::None) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(0, attrs)); // Loop over the operands, inserting GEP and loads in the caller as @@ -508,7 +510,8 @@ Function *ArgPromotion::DoPromotion(Function *F, if (!ArgsToPromote.count(I) && !ByValArgsToTransform.count(I)) { Args.push_back(*AI); // Unmodified argument - if (unsigned Attrs = PAL ? PAL->getParamAttrs(ArgIndex) : 0) + if (ParameterAttributes Attrs = PAL ? PAL->getParamAttrs(ArgIndex) : + ParamAttr::None) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs)); } else if (ByValArgsToTransform.count(I)) { @@ -547,7 +550,8 @@ Function *ArgPromotion::DoPromotion(Function *F, // Push any varargs arguments on the list for (; AI != CS.arg_end(); ++AI, ++ArgIndex) { Args.push_back(*AI); - if (unsigned Attrs = PAL ? PAL->getParamAttrs(ArgIndex) : 0) + if (ParameterAttributes Attrs = PAL ? PAL->getParamAttrs(ArgIndex) : + ParamAttr::None) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs)); } diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index 3a4c36f87f1..fe2db6d4e9a 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -512,7 +512,7 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) { const ParamAttrsList *PAL = F->getParamAttrs(); // The existing function return attributes. - uint16_t RAttrs = PAL ? PAL->getParamAttrs(0) : 0; + ParameterAttributes RAttrs = PAL ? PAL->getParamAttrs(0) : ParamAttr::None; // Make the function return void if the return value is dead. const Type *RetTy = FTy->getReturnType(); @@ -532,7 +532,8 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) { ++I, ++index) if (!DeadArguments.count(I)) { Params.push_back(I->getType()); - uint16_t Attrs = PAL ? PAL->getParamAttrs(index) : 0; + ParameterAttributes Attrs = PAL ? PAL->getParamAttrs(index) : + ParamAttr::None; if (Attrs) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Params.size(), Attrs)); } @@ -572,7 +573,7 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) { PAL = CS.getParamAttrs(); // The call return attributes. - uint16_t RAttrs = PAL ? PAL->getParamAttrs(0) : 0; + ParameterAttributes RAttrs = PAL ? PAL->getParamAttrs(0) : ParamAttr::None; // Adjust in case the function was changed to return void. RAttrs &= ~ParamAttr::typeIncompatible(NF->getReturnType()); if (RAttrs) @@ -585,7 +586,8 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) { I != E; ++I, ++AI, ++index) if (!DeadArguments.count(I)) { // Remove operands for dead arguments Args.push_back(*AI); - uint16_t Attrs = PAL ? PAL->getParamAttrs(index) : 0; + ParameterAttributes Attrs = PAL ? PAL->getParamAttrs(index) : + ParamAttr::None; if (Attrs) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs)); } @@ -596,7 +598,8 @@ void DAE::RemoveDeadArgumentsFromFunction(Function *F) { // Push any varargs arguments on the list. Don't forget their attributes. for (; AI != CS.arg_end(); ++AI) { Args.push_back(*AI); - uint16_t Attrs = PAL ? PAL->getParamAttrs(index++) : 0; + ParameterAttributes Attrs = PAL ? PAL->getParamAttrs(index++) : + ParamAttr::None; if (Attrs) ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs)); } diff --git a/lib/Transforms/IPO/PruneEH.cpp b/lib/Transforms/IPO/PruneEH.cpp index 4fe139a3800..26ca2f6200b 100644 --- a/lib/Transforms/IPO/PruneEH.cpp +++ b/lib/Transforms/IPO/PruneEH.cpp @@ -123,7 +123,7 @@ bool PruneEH::runOnSCC(const std::vector &SCC) { // If the SCC doesn't unwind or doesn't throw, note this fact. if (!SCCMightUnwind || !SCCMightReturn) for (unsigned i = 0, e = SCC.size(); i != e; ++i) { - uint16_t NewAttributes = ParamAttr::None; + ParameterAttributes NewAttributes = ParamAttr::None; if (!SCCMightUnwind) NewAttributes |= ParamAttr::NoUnwind; diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp index 9957bc19c69..ba9ce568f33 100644 --- a/lib/Transforms/Scalar/InstructionCombining.cpp +++ b/lib/Transforms/Scalar/InstructionCombining.cpp @@ -8384,7 +8384,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { return false; // Cannot transform this return value. if (CallerPAL && !Caller->use_empty()) { - uint16_t RAttrs = CallerPAL->getParamAttrs(0); + ParameterAttributes RAttrs = CallerPAL->getParamAttrs(0); if (RAttrs & ParamAttr::typeIncompatible(FT->getReturnType())) return false; // Attribute not compatible with transformed value. } @@ -8415,7 +8415,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { return false; // Cannot transform this parameter value. if (CallerPAL) { - uint16_t PAttrs = CallerPAL->getParamAttrs(i + 1); + ParameterAttributes PAttrs = CallerPAL->getParamAttrs(i + 1); if (PAttrs & ParamAttr::typeIncompatible(ParamTy)) return false; // Attribute not compatible with transformed value. } @@ -8443,7 +8443,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { for (unsigned i = CallerPAL->size(); i; --i) { if (CallerPAL->getParamIndex(i - 1) <= FT->getNumParams()) break; - uint16_t PAttrs = CallerPAL->getParamAttrsAtIndex(i - 1); + ParameterAttributes PAttrs = CallerPAL->getParamAttrsAtIndex(i - 1); if (PAttrs & ParamAttr::VarArgsIncompatible) return false; } @@ -8456,7 +8456,8 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { attrVec.reserve(NumCommonArgs); // Get any return attributes. - uint16_t RAttrs = CallerPAL ? CallerPAL->getParamAttrs(0) : 0; + ParameterAttributes RAttrs = CallerPAL ? CallerPAL->getParamAttrs(0) : + ParamAttr::None; // If the return value is not being used, the type may not be compatible // with the existing attributes. Wipe out any problematic attributes. @@ -8479,7 +8480,8 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } // Add any parameter attributes. - uint16_t PAttrs = CallerPAL ? CallerPAL->getParamAttrs(i + 1) : 0; + ParameterAttributes PAttrs = CallerPAL ? CallerPAL->getParamAttrs(i + 1) : + ParamAttr::None; if (PAttrs) attrVec.push_back(ParamAttrsWithIndex::get(i + 1, PAttrs)); } @@ -8510,7 +8512,9 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } // Add any parameter attributes. - uint16_t PAttrs = CallerPAL ? CallerPAL->getParamAttrs(i + 1) : 0; + ParameterAttributes PAttrs = CallerPAL ? + CallerPAL->getParamAttrs(i + 1) : + ParamAttr::None; if (PAttrs) attrVec.push_back(ParamAttrsWithIndex::get(i + 1, PAttrs)); } @@ -8593,7 +8597,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) { if (const ParamAttrsList *NestAttrs = NestF->getParamAttrs()) { unsigned NestIdx = 1; const Type *NestTy = 0; - uint16_t NestAttr = 0; + ParameterAttributes NestAttr = ParamAttr::None; // Look for a parameter marked with the 'nest' attribute. for (FunctionType::param_iterator I = NestFTy->param_begin(), @@ -8617,7 +8621,8 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) { // mean appending it. Likewise for attributes. // Add any function result attributes. - uint16_t Attr = Attrs ? Attrs->getParamAttrs(0) : 0; + ParameterAttributes Attr = Attrs ? Attrs->getParamAttrs(0) : + ParamAttr::None; if (Attr) NewAttrs.push_back (ParamAttrsWithIndex::get(0, Attr)); diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index 94477bab252..6e1652c4c7f 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -742,7 +742,7 @@ public: inline void write(const Type *Ty) { printType(Ty); } void writeOperand(const Value *Op, bool PrintType); - void writeParamOperand(const Value *Operand, uint16_t Attrs); + void writeParamOperand(const Value *Operand, ParameterAttributes Attrs); const Module* getModule() { return TheModule; } @@ -752,7 +752,7 @@ private: void printGlobal(const GlobalVariable *GV); void printAlias(const GlobalAlias *GV); void printFunction(const Function *F); - void printArgument(const Argument *FA, uint16_t ParamAttrs); + void printArgument(const Argument *FA, ParameterAttributes Attrs); void printBasicBlock(const BasicBlock *BB); void printInstruction(const Instruction &I); @@ -839,7 +839,8 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) { } } -void AssemblyWriter::writeParamOperand(const Value *Operand, uint16_t Attrs) { +void AssemblyWriter::writeParamOperand(const Value *Operand, + ParameterAttributes Attrs) { if (Operand == 0) { Out << ""; } else { @@ -1092,7 +1093,7 @@ void AssemblyWriter::printFunction(const Function *F) { // Insert commas as we go... the first arg doesn't get a comma if (I != F->arg_begin()) Out << ", "; printArgument(I, (Attrs ? Attrs->getParamAttrs(Idx) - : uint16_t(ParamAttr::None))); + : ParamAttr::None)); Idx++; } } else { @@ -1104,7 +1105,7 @@ void AssemblyWriter::printFunction(const Function *F) { // Output type... printType(FT->getParamType(i)); - unsigned ArgAttrs = ParamAttr::None; + ParameterAttributes ArgAttrs = ParamAttr::None; if (Attrs) ArgAttrs = Attrs->getParamAttrs(i+1); if (ArgAttrs != ParamAttr::None) Out << ' ' << ParamAttrsList::getParamAttrsText(ArgAttrs); @@ -1144,7 +1145,8 @@ void AssemblyWriter::printFunction(const Function *F) { /// printArgument - This member is called for every argument that is passed into /// the function. Simply print it out /// -void AssemblyWriter::printArgument(const Argument *Arg, uint16_t Attrs) { +void AssemblyWriter::printArgument(const Argument *Arg, + ParameterAttributes Attrs) { // Output type... printType(Arg->getType()); @@ -1323,7 +1325,8 @@ void AssemblyWriter::printInstruction(const Instruction &I) { for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) { if (op > 1) Out << ','; - writeParamOperand(I.getOperand(op), PAL ? PAL->getParamAttrs(op) : 0); + writeParamOperand(I.getOperand(op), PAL ? PAL->getParamAttrs(op) : + ParamAttr::None); } Out << " )"; if (PAL && PAL->getParamAttrs(0) != ParamAttr::None) @@ -1361,7 +1364,8 @@ void AssemblyWriter::printInstruction(const Instruction &I) { for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) { if (op > 3) Out << ','; - writeParamOperand(I.getOperand(op), PAL ? PAL->getParamAttrs(op-2) : 0); + writeParamOperand(I.getOperand(op), PAL ? PAL->getParamAttrs(op-2) : + ParamAttr::None); } Out << " )"; @@ -1515,9 +1519,10 @@ ParamAttrsList::dump() const { cerr << "PAL[ "; for (unsigned i = 0; i < attrs.size(); ++i) { uint16_t index = getParamIndex(i); - uint16_t attrs = getParamAttrs(index); + ParameterAttributes attrs = getParamAttrs(index); cerr << "{" << index << "," << attrs << "} "; } + cerr << "]\n"; } diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp index ec34abc1067..cbe11f0b6c5 100644 --- a/lib/VMCore/Function.cpp +++ b/lib/VMCore/Function.cpp @@ -139,8 +139,8 @@ void Function::eraseFromParent() { } /// @brief Determine whether the function has the given attribute. -bool Function::paramHasAttr(uint16_t i, unsigned attr) const { - return ParamAttrs && ParamAttrs->paramHasAttr(i, (ParameterAttributes)attr); +bool Function::paramHasAttr(uint16_t i, ParameterAttributes attr) const { + return ParamAttrs && ParamAttrs->paramHasAttr(i, attr); } /// @brief Determine if the function cannot return. @@ -365,7 +365,7 @@ const FunctionType *Intrinsic::getType(ID id, const Type **Tys, const ParamAttrsList *Intrinsic::getParamAttrs(ID id) { ParamAttrsVector Attrs; - uint16_t Attr = ParamAttr::None; + ParameterAttributes Attr = ParamAttr::None; #define GET_INTRINSIC_ATTRIBUTES #include "llvm/Intrinsics.gen" diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index 1a4a5ce7258..863f011cd07 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -55,11 +55,11 @@ void CallSite::setParamAttrs(const ParamAttrsList *PAL) { else cast(I)->setParamAttrs(PAL); } -bool CallSite::paramHasAttr(uint16_t i, unsigned attr) const { +bool CallSite::paramHasAttr(uint16_t i, ParameterAttributes attr) const { if (CallInst *CI = dyn_cast(I)) - return CI->paramHasAttr(i, (ParameterAttributes)attr); + return CI->paramHasAttr(i, attr); else - return cast(I)->paramHasAttr(i, (ParameterAttributes)attr); + return cast(I)->paramHasAttr(i, attr); } bool CallSite::doesNotAccessMemory() const { if (CallInst *CI = dyn_cast(I)) @@ -374,11 +374,11 @@ void CallInst::setParamAttrs(const ParamAttrsList *newAttrs) { ParamAttrs = newAttrs; } -bool CallInst::paramHasAttr(uint16_t i, unsigned attr) const { - if (ParamAttrs && ParamAttrs->paramHasAttr(i, (ParameterAttributes)attr)) +bool CallInst::paramHasAttr(uint16_t i, ParameterAttributes attr) const { + if (ParamAttrs && ParamAttrs->paramHasAttr(i, attr)) return true; if (const Function *F = getCalledFunction()) - return F->paramHasAttr(i, (ParameterAttributes)attr); + return F->paramHasAttr(i, attr); return false; } @@ -498,11 +498,11 @@ void InvokeInst::setParamAttrs(const ParamAttrsList *newAttrs) { ParamAttrs = newAttrs; } -bool InvokeInst::paramHasAttr(uint16_t i, unsigned attr) const { - if (ParamAttrs && ParamAttrs->paramHasAttr(i, (ParameterAttributes)attr)) +bool InvokeInst::paramHasAttr(uint16_t i, ParameterAttributes attr) const { + if (ParamAttrs && ParamAttrs->paramHasAttr(i, attr)) return true; if (const Function *F = getCalledFunction()) - return F->paramHasAttr(i, (ParameterAttributes)attr); + return F->paramHasAttr(i, attr); return false; } diff --git a/lib/VMCore/ParameterAttributes.cpp b/lib/VMCore/ParameterAttributes.cpp index 344e52c59a4..d78068df113 100644 --- a/lib/VMCore/ParameterAttributes.cpp +++ b/lib/VMCore/ParameterAttributes.cpp @@ -27,7 +27,7 @@ ParamAttrsList::~ParamAttrsList() { ParamAttrsLists->RemoveNode(this); } -uint16_t +ParameterAttributes ParamAttrsList::getParamAttrs(uint16_t Index) const { unsigned limit = attrs.size(); for (unsigned i = 0; i < limit && attrs[i].index <= Index; ++i) @@ -44,7 +44,7 @@ bool ParamAttrsList::hasAttrSomewhere(ParameterAttributes attr) const { } std::string -ParamAttrsList::getParamAttrsText(uint16_t Attrs) { +ParamAttrsList::getParamAttrsText(ParameterAttributes Attrs) { std::string Result; if (Attrs & ParamAttr::ZExt) Result += "zeroext "; @@ -170,9 +170,10 @@ ParamAttrsList::getModified(const ParamAttrsList *PAL, const ParamAttrsList * ParamAttrsList::includeAttrs(const ParamAttrsList *PAL, - uint16_t idx, uint16_t attrs) { - uint16_t OldAttrs = PAL ? PAL->getParamAttrs(idx) : 0; - uint16_t NewAttrs = OldAttrs | attrs; + uint16_t idx, ParameterAttributes attrs) { + ParameterAttributes OldAttrs = PAL ? PAL->getParamAttrs(idx) : + ParamAttr::None; + ParameterAttributes NewAttrs = OldAttrs | attrs; if (NewAttrs == OldAttrs) return PAL; @@ -183,9 +184,10 @@ ParamAttrsList::includeAttrs(const ParamAttrsList *PAL, const ParamAttrsList * ParamAttrsList::excludeAttrs(const ParamAttrsList *PAL, - uint16_t idx, uint16_t attrs) { - uint16_t OldAttrs = PAL ? PAL->getParamAttrs(idx) : 0; - uint16_t NewAttrs = OldAttrs & ~attrs; + uint16_t idx, ParameterAttributes attrs) { + ParameterAttributes OldAttrs = PAL ? PAL->getParamAttrs(idx) : + ParamAttr::None; + ParameterAttributes NewAttrs = OldAttrs & ~attrs; if (NewAttrs == OldAttrs) return PAL; @@ -194,8 +196,8 @@ ParamAttrsList::excludeAttrs(const ParamAttrsList *PAL, return getModified(PAL, modVec); } -uint16_t ParamAttr::typeIncompatible (const Type *Ty) { - uint16_t Incompatible = None; +ParameterAttributes ParamAttr::typeIncompatible (const Type *Ty) { + ParameterAttributes Incompatible = None; if (!Ty->isInteger()) // Attributes that only apply to integers. diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 3c7ce7a5a29..98f421e95ea 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -261,8 +261,8 @@ namespace { // Anonymous namespace for class void VerifyCallSite(CallSite CS); void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, unsigned Count, ...); - void VerifyAttrs(uint16_t Attrs, const Type *Ty, bool isReturnValue, - const Value *V); + void VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, + bool isReturnValue, const Value *V); void VerifyFunctionAttrs(const FunctionType *FT, const ParamAttrsList *Attrs, const Value *V); @@ -386,29 +386,29 @@ void Verifier::verifyTypeSymbolTable(TypeSymbolTable &ST) { // VerifyAttrs - Check the given parameter attributes for an argument or return // value of the specified type. The value V is printed in error messages. -void Verifier::VerifyAttrs(uint16_t Attrs, const Type *Ty, bool isReturnValue, - const Value *V) { +void Verifier::VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, + bool isReturnValue, const Value *V) { if (Attrs == ParamAttr::None) return; if (isReturnValue) { - uint16_t RetI = Attrs & ParamAttr::ParameterOnly; + ParameterAttributes RetI = Attrs & ParamAttr::ParameterOnly; Assert1(!RetI, "Attribute " + ParamAttrsList::getParamAttrsText(RetI) + "does not apply to return values!", V); } else { - uint16_t ParmI = Attrs & ParamAttr::ReturnOnly; + ParameterAttributes ParmI = Attrs & ParamAttr::ReturnOnly; Assert1(!ParmI, "Attribute " + ParamAttrsList::getParamAttrsText(ParmI) + "only applies to return values!", V); } for (unsigned i = 0; i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) { - uint16_t MutI = Attrs & ParamAttr::MutuallyIncompatible[i]; + ParameterAttributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i]; Assert1(!(MutI & (MutI - 1)), "Attributes " + ParamAttrsList::getParamAttrsText(MutI) + "are incompatible!", V); } - uint16_t TypeI = Attrs & ParamAttr::typeIncompatible(Ty); + ParameterAttributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty); Assert1(!TypeI, "Wrong type for attribute " + ParamAttrsList::getParamAttrsText(TypeI), V); } @@ -424,7 +424,7 @@ void Verifier::VerifyFunctionAttrs(const FunctionType *FT, bool SawNest = false; for (unsigned Idx = 0; Idx <= FT->getNumParams(); ++Idx) { - uint16_t Attr = Attrs->getParamAttrs(Idx); + ParameterAttributes Attr = Attrs->getParamAttrs(Idx); VerifyAttrs(Attr, FT->getParamType(Idx-1), !Idx, V); @@ -873,11 +873,11 @@ void Verifier::VerifyCallSite(CallSite CS) { if (Attrs && FTy->isVarArg()) // Check attributes on the varargs part. for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) { - uint16_t Attr = Attrs->getParamAttrs(Idx); + ParameterAttributes Attr = Attrs->getParamAttrs(Idx); VerifyAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I); - uint16_t VArgI = Attr & ParamAttr::VarArgsIncompatible; + ParameterAttributes VArgI = Attr & ParamAttr::VarArgsIncompatible; Assert1(!VArgI, "Attribute " + ParamAttrsList::getParamAttrsText(VArgI) + "cannot be used for vararg call arguments!", I); } diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp index d30968e3c8f..81911fd2975 100644 --- a/tools/llvm2cpp/CppWriter.cpp +++ b/tools/llvm2cpp/CppWriter.cpp @@ -447,7 +447,7 @@ CppWriter::printParamAttrs(const ParamAttrsList* PAL, const std::string &name) { Out << "ParamAttrsWithIndex PAWI;"; nl(Out); for (unsigned i = 0; i < PAL->size(); ++i) { uint16_t index = PAL->getParamIndex(i); - uint16_t attrs = PAL->getParamAttrs(index); + ParameterAttributes attrs = PAL->getParamAttrs(index); Out << "PAWI.index = " << index << "; PAWI.attrs = 0 "; if (attrs & ParamAttr::SExt) Out << " | ParamAttr::SExt";