6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-22 09:29:31 +00:00
Code Issues 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";