RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-18 16:03:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Expand ParameterAttributes to 32 bits (in preparation

Browse Source 
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
This commit is contained in:
Dale Johannesen 2008-02-19 21:38:47 +00:00
parent a795aca96a
commit 0d51e7ec0d
16 changed files with 122 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/llvm/Function.h
View File

@ -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;

3
include/llvm/Instructions.h
View File

@ -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;

62
include/llvm/ParameterAttributes.h
View File

@ -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<ParamAttrsWithIndex,4> 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;
}

3
include/llvm/Support/CallSite.h
View File

@ -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;

2
lib/AsmParser/llvmAsmParser.y
View File

@ -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;

2
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -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);

14
lib/Transforms/IPO/ArgumentPromotion.cpp
View File

@ -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));
}

13
lib/Transforms/IPO/DeadArgumentElimination.cpp
View File

@ -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));
}

2
lib/Transforms/IPO/PruneEH.cpp
View File

@ -123,7 +123,7 @@ bool PruneEH::runOnSCC(const std::vector<CallGraphNode *> &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;

21
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -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));

23
lib/VMCore/AsmWriter.cpp
View File

@ -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 << "<null operand!>";
} 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";
}

6
lib/VMCore/Function.cpp
View File

@ -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"

18
lib/VMCore/Instructions.cpp
View File

@ -55,11 +55,11 @@ void CallSite::setParamAttrs(const ParamAttrsList *PAL) {
else
cast<InvokeInst>(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<CallInst>(I))
return CI->paramHasAttr(i, (ParameterAttributes)attr);
return CI->paramHasAttr(i, attr);
else
return cast<InvokeInst>(I)->paramHasAttr(i, (ParameterAttributes)attr);
return cast<InvokeInst>(I)->paramHasAttr(i, attr);
}
bool CallSite::doesNotAccessMemory() const {
if (CallInst *CI = dyn_cast<CallInst>(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;
}

22
lib/VMCore/ParameterAttributes.cpp
View File

@ -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.

22
lib/VMCore/Verifier.cpp
View File

@ -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);
}

2
tools/llvm2cpp/CppWriter.cpp
View File

@ -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";