maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

s/ParameterAttributes/Attributes/g 

llvm-svn: 56513
This commit is contained in:
Devang Patel 2008-09-23 23:03:40 +00:00
parent 82fed6702b
commit ba3fa6c6e1
28 changed files with 105 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
llvm/include/llvm/Argument.h
View File

@ -15,7 +15,7 @@
#define LLVM_ARGUMENT_H
#include "llvm/Value.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/ADT/ilist_node.h"
namespace llvm {
@ -61,10 +61,10 @@ public:
bool hasStructRetAttr() const;
/// addAttr - Add a ParamAttr to an argument
void addAttr(ParameterAttributes);
void addAttr(Attributes);
/// removeAttr - Remove a ParamAttr from an argument
void removeAttr(ParameterAttributes);
void removeAttr(Attributes);
/// classof - Methods for support type inquiry through isa, cast, and
/// dyn_cast:

29
llvm/include/llvm/ParameterAttributes.h → llvm/include/llvm/Attributes.h
View File

@ -1,4 +1,4 @@
//===-- llvm/ParameterAttributes.h - Container for ParamAttrs ---*- C++ -*-===//
//===-- llvm/Attributes.h - Container for ParamAttrs ---*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
@ -20,8 +20,8 @@
namespace llvm {
class Type;
/// ParameterAttributes - A bitset of attributes for a parameter.
typedef unsigned ParameterAttributes;
/// Attributes - A bitset of attributes for a parameter.
typedef unsigned Attributes;
namespace ParamAttr {
@ -30,7 +30,6 @@ namespace ParamAttr {
/// lists the attributes that can be associated with parameters or function
/// results.
/// @brief Function parameter attributes.
typedef ParameterAttributes Attributes;
const Attributes None = 0; ///< No attributes have been set
const Attributes ZExt = 1<<0; ///< Zero extended before/after call
@ -74,26 +73,26 @@ const Attributes MutuallyIncompatible[3] = {
Attributes typeIncompatible(const Type *Ty);
/// This turns an int alignment (a power of 2, normally) into the
/// form used internally in ParameterAttributes.
inline ParamAttr::Attributes constructAlignmentFromInt(unsigned i) {
/// form used internally in Attributes.
inline Attributes constructAlignmentFromInt(unsigned i) {
return (i << 16);
}
/// The set of ParameterAttributes set in Attributes is converted to a
/// The set of Attributes set in Attributes is converted to a
/// string of equivalent mnemonics. This is, presumably, for writing out
/// the mnemonics for the assembly writer.
/// @brief Convert parameter attribute bits to text
std::string getAsString(ParameterAttributes Attrs);
std::string getAsString(Attributes Attrs);
} // end namespace ParamAttr
/// This is just a pair of values to associate a set of parameter attributes
/// with a parameter index.
struct ParamAttrsWithIndex {
ParameterAttributes Attrs; ///< The attributes that are set, or'd together.
Attributes Attrs; ///< The attributes that are set, or'd together.
unsigned Index; ///< Index of the parameter for which the attributes apply.
static ParamAttrsWithIndex get(unsigned Idx, ParameterAttributes Attrs) {
static ParamAttrsWithIndex get(unsigned Idx, Attributes Attrs) {
ParamAttrsWithIndex P;
P.Index = Idx;
P.Attrs = Attrs;
@ -137,12 +136,12 @@ public:
/// addAttr - Add the specified attribute at the specified index to this
/// attribute list. Since parameter attribute lists are immutable, this
/// returns the new list.
PAListPtr addAttr(unsigned Idx, ParameterAttributes Attrs) const;
PAListPtr addAttr(unsigned Idx, Attributes Attrs) const;
/// removeAttr - Remove the specified attribute at the specified index from
/// this attribute list. Since parameter attribute lists are immutable, this
/// returns the new list.
PAListPtr removeAttr(unsigned Idx, ParameterAttributes Attrs) const;
PAListPtr removeAttr(unsigned Idx, Attributes Attrs) const;
//===--------------------------------------------------------------------===//
// Parameter Attribute List Accessors
@ -150,11 +149,11 @@ public:
/// getParamAttrs - The parameter attributes for the specified parameter are
/// returned. Parameters for the result are denoted with Idx = 0.
ParameterAttributes getParamAttrs(unsigned Idx) const;
Attributes getParamAttrs(unsigned Idx) const;
/// paramHasAttr - Return true if the specified parameter index has the
/// specified attribute set.
bool paramHasAttr(unsigned Idx, ParameterAttributes Attr) const {
bool paramHasAttr(unsigned Idx, Attributes Attr) const {
return getParamAttrs(Idx) & Attr;
}
@ -166,7 +165,7 @@ public:
/// hasAttrSomewhere - Return true if the specified attribute is set for at
/// least one parameter or for the return value.
bool hasAttrSomewhere(ParameterAttributes Attr) const;
bool hasAttrSomewhere(Attributes Attr) const;
/// operator==/!= - Provide equality predicates.
bool operator==(const PAListPtr &RHS) const { return PAList == RHS.PAList; }

12
llvm/include/llvm/Function.h
View File

@ -22,7 +22,7 @@
#include "llvm/BasicBlock.h"
#include "llvm/Argument.h"
#include "llvm/Support/Annotation.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
namespace llvm {
@ -150,14 +150,14 @@ public:
/// hasNote - Return true if this function has given note.
bool hasNote(ParameterAttributes N) const {
bool hasNote(Attributes N) const {
// Notes are stored at ~0 index in parameter attribute list
return (!isDeclaration() && paramHasAttr(~0, N));
}
/// setNotes - Set notes for this function
///
void setNotes(const ParameterAttributes N) {
void setNotes(const Attributes N) {
// Notes are stored at ~0 index in parameter attribute list
addParamAttr(~0, N);
}
@ -170,15 +170,15 @@ public:
void clearGC();
/// @brief Determine whether the function has the given attribute.
bool paramHasAttr(unsigned i, ParameterAttributes attr) const {
bool paramHasAttr(unsigned i, Attributes attr) const {
return ParamAttrs.paramHasAttr(i, attr);
}
/// addParamAttr - adds the attribute to the list of attributes.
void addParamAttr(unsigned i, ParameterAttributes attr);
void addParamAttr(unsigned i, Attributes attr);
/// removeParamAttr - removes the attribute from the list of attributes.
void removeParamAttr(unsigned i, ParameterAttributes attr);
void removeParamAttr(unsigned i, Attributes attr);
/// @brief Extract the alignment for a call or parameter (0=unknown).
unsigned getParamAlignment(unsigned i) const {

12
llvm/include/llvm/Instructions.h
View File

@ -20,7 +20,7 @@
#include "llvm/InstrTypes.h"
#include "llvm/DerivedTypes.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/BasicBlock.h"
#include "llvm/ADT/SmallVector.h"
@ -1081,10 +1081,10 @@ public:
void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; }
/// addParamAttr - adds the attribute to the list of attributes.
void addParamAttr(unsigned i, ParameterAttributes attr);
void addParamAttr(unsigned i, Attributes attr);
/// removeParamAttr - removes the attribute from the list of attributes.
void removeParamAttr(unsigned i, ParameterAttributes attr);
void removeParamAttr(unsigned i, Attributes attr);
/// @brief Determine whether the call or the callee has the given attribute.
bool paramHasAttr(unsigned i, unsigned attr) const;
@ -2440,13 +2440,13 @@ public:
void setParamAttrs(const PAListPtr &Attrs) { ParamAttrs = Attrs; }
/// @brief Determine whether the call or the callee has the given attribute.
bool paramHasAttr(unsigned i, ParameterAttributes attr) const;
bool paramHasAttr(unsigned i, Attributes attr) const;
/// addParamAttr - adds the attribute to the list of attributes.
void addParamAttr(unsigned i, ParameterAttributes attr);
void addParamAttr(unsigned i, Attributes attr);
/// removeParamAttr - removes the attribute from the list of attributes.
void removeParamAttr(unsigned i, ParameterAttributes attr);
void removeParamAttr(unsigned i, Attributes attr);
/// @brief Extract the alignment for a call or parameter (0=unknown).
unsigned getParamAlignment(unsigned i) const {

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

@ -22,7 +22,7 @@
#include "llvm/Instruction.h"
#include "llvm/BasicBlock.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
namespace llvm {
@ -68,7 +68,7 @@ public:
void setParamAttrs(const PAListPtr &PAL);
/// paramHasAttr - whether the call or the callee has the given attribute.
bool paramHasAttr(uint16_t i, ParameterAttributes attr) const;
bool paramHasAttr(uint16_t i, Attributes attr) const;
/// @brief Extract the alignment for a call or parameter (0=unknown).
uint16_t getParamAlignment(uint16_t i) const;

1
llvm/lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -18,7 +18,6 @@
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/GlobalVariable.h"
#include "llvm/Instructions.h"
#include "llvm/IntrinsicInst.h"

8
llvm/lib/AsmParser/ParserInternals.h
View File

@ -17,7 +17,7 @@
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/Function.h"
#include "llvm/Instructions.h"
#include "llvm/Assembly/Parser.h"
@ -232,13 +232,13 @@ struct ValID {
struct TypeWithAttrs {
llvm::PATypeHolder *Ty;
ParameterAttributes Attrs;
Attributes Attrs;
};
typedef std::vector<TypeWithAttrs> TypeWithAttrsList;
struct ArgListEntry {
ParameterAttributes Attrs;
Attributes Attrs;
llvm::PATypeHolder *Ty;
std::string *Name;
};
@ -247,7 +247,7 @@ typedef std::vector<struct ArgListEntry> ArgListType;
struct ParamListEntry {
Value *Val;
ParameterAttributes Attrs;
Attributes Attrs;
};
typedef std::vector<ParamListEntry> ParamList;

2
llvm/lib/Bitcode/Reader/BitcodeReader.h
View File

@ -15,7 +15,7 @@
#define BITCODE_READER_H
#include "llvm/ModuleProvider.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/Type.h"
#include "llvm/OperandTraits.h"
#include "llvm/Bitcode/BitstreamReader.h"

2
llvm/lib/Bitcode/Writer/ValueEnumerator.h
View File

@ -15,7 +15,7 @@
#define VALUE_ENUMERATOR_H
#include "llvm/ADT/DenseMap.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include <vector>
namespace llvm {

1
llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuild.cpp
View File

@ -25,7 +25,6 @@
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/CodeGen/FastISel.h"
#include "llvm/CodeGen/GCStrategy.h"
#include "llvm/CodeGen/GCMetadata.h"

1
llvm/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -25,7 +25,6 @@
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/CodeGen/FastISel.h"
#include "llvm/CodeGen/GCStrategy.h"
#include "llvm/CodeGen/GCMetadata.h"

1
llvm/lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -16,7 +16,6 @@
#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/Instructions.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/CodeGen/IntrinsicLowering.h"
#include "llvm/Support/GetElementPtrTypeIterator.h"
#include "llvm/ADT/APInt.h"

2
llvm/lib/Target/CppBackend/CPPBackend.cpp
View File

@ -438,7 +438,7 @@ namespace {
Out << "ParamAttrsWithIndex PAWI;"; nl(Out);
for (unsigned i = 0; i < PAL.getNumSlots(); ++i) {
uint16_t index = PAL.getSlot(i).Index;
ParameterAttributes attrs = PAL.getSlot(i).Attrs;
Attributes attrs = PAL.getSlot(i).Attrs;
Out << "PAWI.Index = " << index << "; PAWI.Attrs = 0 ";
if (attrs & ParamAttr::SExt)
Out << " | ParamAttr::SExt";

1
llvm/lib/Target/MSIL/MSILWriter.cpp
View File

@ -16,7 +16,6 @@
#include "llvm/DerivedTypes.h"
#include "llvm/Intrinsics.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/TypeSymbolTable.h"
#include "llvm/Analysis/ConstantsScanner.h"
#include "llvm/Support/CallSite.h"

1
llvm/lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -29,7 +29,6 @@
#include "llvm/Constants.h"
#include "llvm/Function.h"
#include "llvm/Intrinsics.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/CommandLine.h"

10
llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
View File

@ -508,7 +508,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
const PAListPtr &PAL = F->getParamAttrs();
// Add any return attributes.
if (ParameterAttributes attrs = PAL.getParamAttrs(0))
if (Attributes attrs = PAL.getParamAttrs(0))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(0, attrs));
// First, determine the new argument list
@ -525,7 +525,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
} else if (!ArgsToPromote.count(I)) {
// Unchanged argument
Params.push_back(I->getType());
if (ParameterAttributes attrs = PAL.getParamAttrs(ArgIndex))
if (Attributes attrs = PAL.getParamAttrs(ArgIndex))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Params.size(), attrs));
} else if (I->use_empty()) {
// Dead argument (which are always marked as promotable)
@ -621,7 +621,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
const PAListPtr &CallPAL = CS.getParamAttrs();
// Add any return attributes.
if (ParameterAttributes attrs = CallPAL.getParamAttrs(0))
if (Attributes attrs = CallPAL.getParamAttrs(0))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(0, attrs));
// Loop over the operands, inserting GEP and loads in the caller as
@ -633,7 +633,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
if (!ArgsToPromote.count(I) && !ByValArgsToTransform.count(I)) {
Args.push_back(*AI); // Unmodified argument
if (ParameterAttributes Attrs = CallPAL.getParamAttrs(ArgIndex))
if (Attributes Attrs = CallPAL.getParamAttrs(ArgIndex))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs));
} else if (ByValArgsToTransform.count(I)) {
@ -688,7 +688,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
// Push any varargs arguments on the list
for (; AI != CS.arg_end(); ++AI, ++ArgIndex) {
Args.push_back(*AI);
if (ParameterAttributes Attrs = CallPAL.getParamAttrs(ArgIndex))
if (Attributes Attrs = CallPAL.getParamAttrs(ArgIndex))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs));
}

10
llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
View File

@ -593,7 +593,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
const PAListPtr &PAL = F->getParamAttrs();
// The existing function return attributes.
ParameterAttributes RAttrs = PAL.getParamAttrs(0);
Attributes RAttrs = PAL.getParamAttrs(0);
// Find out the new return value.
@ -678,7 +678,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
// Get the original parameter attributes (skipping the first one, that is
// for the return value.
if (ParameterAttributes Attrs = PAL.getParamAttrs(i + 1))
if (Attributes Attrs = PAL.getParamAttrs(i + 1))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Params.size(), Attrs));
} else {
++NumArgumentsEliminated;
@ -730,7 +730,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
const PAListPtr &CallPAL = CS.getParamAttrs();
// The call return attributes.
ParameterAttributes RAttrs = CallPAL.getParamAttrs(0);
Attributes RAttrs = CallPAL.getParamAttrs(0);
// Adjust in case the function was changed to return void.
RAttrs &= ~ParamAttr::typeIncompatible(NF->getReturnType());
if (RAttrs)
@ -746,7 +746,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
if (ArgAlive[i]) {
Args.push_back(*I);
// Get original parameter attributes, but skip return attributes.
if (ParameterAttributes Attrs = CallPAL.getParamAttrs(i + 1))
if (Attributes Attrs = CallPAL.getParamAttrs(i + 1))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs));
}
@ -756,7 +756,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
// Push any varargs arguments on the list. Don't forget their attributes.
for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) {
Args.push_back(*I);
if (ParameterAttributes Attrs = CallPAL.getParamAttrs(i + 1))
if (Attributes Attrs = CallPAL.getParamAttrs(i + 1))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(Args.size(), Attrs));
}

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

@ -125,7 +125,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) {
ParameterAttributes NewAttributes = ParamAttr::None;
Attributes NewAttributes = ParamAttr::None;
if (!SCCMightUnwind)
NewAttributes |= ParamAttr::NoUnwind;

8
llvm/lib/Transforms/IPO/StructRetPromotion.cpp
View File

@ -210,7 +210,7 @@ Function *SRETPromotion::cloneFunctionBody(Function *F,
const PAListPtr &PAL = F->getParamAttrs();
// Add any return attributes.
if (ParameterAttributes attrs = PAL.getParamAttrs(0))
if (Attributes attrs = PAL.getParamAttrs(0))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(0, attrs));
// Skip first argument.
@ -221,7 +221,7 @@ Function *SRETPromotion::cloneFunctionBody(Function *F,
unsigned ParamIndex = 2;
while (I != E) {
Params.push_back(I->getType());
if (ParameterAttributes Attrs = PAL.getParamAttrs(ParamIndex))
if (Attributes Attrs = PAL.getParamAttrs(ParamIndex))
ParamAttrsVec.push_back(ParamAttrsWithIndex::get(ParamIndex - 1, Attrs));
++I;
++ParamIndex;
@ -264,7 +264,7 @@ void SRETPromotion::updateCallSites(Function *F, Function *NF) {
const PAListPtr &PAL = F->getParamAttrs();
// Add any return attributes.
if (ParameterAttributes attrs = PAL.getParamAttrs(0))
if (Attributes attrs = PAL.getParamAttrs(0))
ArgAttrsVec.push_back(ParamAttrsWithIndex::get(0, attrs));
// Copy arguments, however skip first one.
@ -276,7 +276,7 @@ void SRETPromotion::updateCallSites(Function *F, Function *NF) {
unsigned ParamIndex = 2;
while (AI != AE) {
Args.push_back(*AI);
if (ParameterAttributes Attrs = PAL.getParamAttrs(ParamIndex))
if (Attributes Attrs = PAL.getParamAttrs(ParamIndex))
ArgAttrsVec.push_back(ParamAttrsWithIndex::get(ParamIndex - 1, Attrs));
++ParamIndex;
++AI;

16
llvm/lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -9127,7 +9127,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
return false; // Cannot transform this return value.
if (!CallerPAL.isEmpty() && !Caller->use_empty()) {
ParameterAttributes RAttrs = CallerPAL.getParamAttrs(0);
Attributes RAttrs = CallerPAL.getParamAttrs(0);
if (RAttrs & ParamAttr::typeIncompatible(NewRetTy))
return false; // Attribute not compatible with transformed value.
}
@ -9180,7 +9180,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
for (unsigned i = CallerPAL.getNumSlots(); i; --i) {
if (CallerPAL.getSlot(i - 1).Index <= FT->getNumParams())
break;
ParameterAttributes PAttrs = CallerPAL.getSlot(i - 1).Attrs;
Attributes PAttrs = CallerPAL.getSlot(i - 1).Attrs;
if (PAttrs & ParamAttr::VarArgsIncompatible)
return false;
}
@ -9193,7 +9193,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
attrVec.reserve(NumCommonArgs);
// Get any return attributes.
ParameterAttributes RAttrs = CallerPAL.getParamAttrs(0);
Attributes RAttrs = CallerPAL.getParamAttrs(0);
// If the return value is not being used, the type may not be compatible
// with the existing attributes. Wipe out any problematic attributes.
@ -9216,7 +9216,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
}
// Add any parameter attributes.
if (ParameterAttributes PAttrs = CallerPAL.getParamAttrs(i + 1))
if (Attributes PAttrs = CallerPAL.getParamAttrs(i + 1))
attrVec.push_back(ParamAttrsWithIndex::get(i + 1, PAttrs));
}
@ -9246,7 +9246,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) {
}
// Add any parameter attributes.
if (ParameterAttributes PAttrs = CallerPAL.getParamAttrs(i + 1))
if (Attributes PAttrs = CallerPAL.getParamAttrs(i + 1))
attrVec.push_back(ParamAttrsWithIndex::get(i + 1, PAttrs));
}
}
@ -9329,7 +9329,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
if (!NestAttrs.isEmpty()) {
unsigned NestIdx = 1;
const Type *NestTy = 0;
ParameterAttributes NestAttr = ParamAttr::None;
Attributes NestAttr = ParamAttr::None;
// Look for a parameter marked with the 'nest' attribute.
for (FunctionType::param_iterator I = NestFTy->param_begin(),
@ -9353,7 +9353,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
// mean appending it. Likewise for attributes.
// Add any function result attributes.
if (ParameterAttributes Attr = Attrs.getParamAttrs(0))
if (Attributes Attr = Attrs.getParamAttrs(0))
NewAttrs.push_back(ParamAttrsWithIndex::get(0, Attr));
{
@ -9374,7 +9374,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
// Add the original argument and attributes.
NewArgs.push_back(*I);
if (ParameterAttributes Attr = Attrs.getParamAttrs(Idx))
if (Attributes Attr = Attrs.getParamAttrs(Idx))
NewAttrs.push_back
(ParamAttrsWithIndex::get(Idx + (Idx >= NestIdx), Attr));

1
llvm/lib/Transforms/Scalar/MemCpyOptimizer.cpp
View File

@ -16,7 +16,6 @@
#include "llvm/Transforms/Scalar.h"
#include "llvm/IntrinsicInst.h"
#include "llvm/Instructions.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/Dominators.h"

2
llvm/lib/Transforms/Scalar/SimplifyCFGPass.cpp
View File

@ -27,7 +27,7 @@
#include "llvm/Constants.h"
#include "llvm/Instructions.h"
#include "llvm/Module.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Pass.h"

2
llvm/lib/Transforms/Utils/InlineFunction.cpp
View File

@ -18,7 +18,7 @@
#include "llvm/Module.h"
#include "llvm/Instructions.h"
#include "llvm/Intrinsics.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/Analysis/CallGraph.h"
#include "llvm/Target/TargetData.h"
#include "llvm/ADT/SmallVector.h"

12
llvm/lib/VMCore/AsmWriter.cpp
View File

@ -1006,7 +1006,7 @@ public:
void write(const Type *Ty) { printType(Ty); }
void writeOperand(const Value *Op, bool PrintType);
void writeParamOperand(const Value *Operand, ParameterAttributes Attrs);
void writeParamOperand(const Value *Operand, Attributes Attrs);
const Module* getModule() { return TheModule; }
@ -1016,7 +1016,7 @@ private:
void printGlobal(const GlobalVariable *GV);
void printAlias(const GlobalAlias *GV);
void printFunction(const Function *F);
void printArgument(const Argument *FA, ParameterAttributes Attrs);
void printArgument(const Argument *FA, Attributes Attrs);
void printBasicBlock(const BasicBlock *BB);
void printInstruction(const Instruction &I);
@ -1126,7 +1126,7 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
}
void AssemblyWriter::writeParamOperand(const Value *Operand,
ParameterAttributes Attrs) {
Attributes Attrs) {
if (Operand == 0) {
Out << "<null operand!>";
} else {
@ -1386,7 +1386,7 @@ void AssemblyWriter::printFunction(const Function *F) {
// Output type...
printType(FT->getParamType(i));
ParameterAttributes ArgAttrs = Attrs.getParamAttrs(i+1);
Attributes ArgAttrs = Attrs.getParamAttrs(i+1);
if (ArgAttrs != ParamAttr::None)
Out << ' ' << ParamAttr::getAsString(ArgAttrs);
}
@ -1398,7 +1398,7 @@ void AssemblyWriter::printFunction(const Function *F) {
Out << "..."; // Output varargs portion of signature!
}
Out << ')';
ParameterAttributes RetAttrs = Attrs.getParamAttrs(0);
Attributes RetAttrs = Attrs.getParamAttrs(0);
if (RetAttrs != ParamAttr::None)
Out << ' ' << ParamAttr::getAsString(Attrs.getParamAttrs(0));
if (F->hasSection())
@ -1454,7 +1454,7 @@ void AssemblyWriter::printFunction(const Function *F) {
/// the function. Simply print it out
///
void AssemblyWriter::printArgument(const Argument *Arg,
ParameterAttributes Attrs) {
Attributes Attrs) {
// Output type...
printType(Arg->getType());

30
llvm/lib/VMCore/ParameterAttributes.cpp → llvm/lib/VMCore/Attributes.cpp
View File

@ -1,4 +1,4 @@
//===-- ParameterAttributes.cpp - Implement ParamAttrsList ----------------===//
//===-- Attributes.cpp - Implement ParamAttrsList ----------------===//
//
// The LLVM Compiler Infrastructure
//
@ -11,7 +11,7 @@
//
//===----------------------------------------------------------------------===//
#include "llvm/ParameterAttributes.h"
#include "llvm/Attributes.h"
#include "llvm/Type.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/FoldingSet.h"
@ -23,7 +23,7 @@ using namespace llvm;
// ParamAttr Function Definitions
//===----------------------------------------------------------------------===//
std::string ParamAttr::getAsString(ParameterAttributes Attrs) {
std::string ParamAttr::getAsString(Attributes Attrs) {
std::string Result;
if (Attrs & ParamAttr::ZExt)
Result += "zeroext ";
@ -57,8 +57,8 @@ std::string ParamAttr::getAsString(ParameterAttributes Attrs) {
return Result;
}
ParameterAttributes ParamAttr::typeIncompatible(const Type *Ty) {
ParameterAttributes Incompatible = None;
Attributes ParamAttr::typeIncompatible(const Type *Ty) {
Attributes Incompatible = None;
if (!Ty->isInteger())
// Attributes that only apply to integers.
@ -187,7 +187,7 @@ const ParamAttrsWithIndex &PAListPtr::getSlot(unsigned Slot) const {
/// getParamAttrs - The parameter attributes for the specified parameter are
/// returned. Parameters for the result are denoted with Idx = 0.
/// Function notes are denoted with idx = ~0.
ParameterAttributes PAListPtr::getParamAttrs(unsigned Idx) const {
Attributes PAListPtr::getParamAttrs(unsigned Idx) const {
if (PAList == 0) return ParamAttr::None;
const SmallVector<ParamAttrsWithIndex, 4> &Attrs = PAList->Attrs;
@ -199,7 +199,7 @@ ParameterAttributes PAListPtr::getParamAttrs(unsigned Idx) const {
/// hasAttrSomewhere - Return true if the specified attribute is set for at
/// least one parameter or for the return value.
bool PAListPtr::hasAttrSomewhere(ParameterAttributes Attr) const {
bool PAListPtr::hasAttrSomewhere(Attributes Attr) const {
if (PAList == 0) return false;
const SmallVector<ParamAttrsWithIndex, 4> &Attrs = PAList->Attrs;
@ -210,18 +210,18 @@ bool PAListPtr::hasAttrSomewhere(ParameterAttributes Attr) const {
}
PAListPtr PAListPtr::addAttr(unsigned Idx, ParameterAttributes Attrs) const {
ParameterAttributes OldAttrs = getParamAttrs(Idx);
PAListPtr PAListPtr::addAttr(unsigned Idx, Attributes Attrs) const {
Attributes OldAttrs = getParamAttrs(Idx);
#ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't change a known alignment.
ParameterAttributes OldAlign = OldAttrs & ParamAttr::Alignment;
ParameterAttributes NewAlign = Attrs & ParamAttr::Alignment;
Attributes OldAlign = OldAttrs & ParamAttr::Alignment;
Attributes NewAlign = Attrs & ParamAttr::Alignment;
assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
"Attempt to change alignment!");
#endif
ParameterAttributes NewAttrs = OldAttrs | Attrs;
Attributes NewAttrs = OldAttrs | Attrs;
if (NewAttrs == OldAttrs)
return *this;
@ -251,7 +251,7 @@ PAListPtr PAListPtr::addAttr(unsigned Idx, ParameterAttributes Attrs) const {
return get(&NewAttrList[0], NewAttrList.size());
}
PAListPtr PAListPtr::removeAttr(unsigned Idx, ParameterAttributes Attrs) const {
PAListPtr PAListPtr::removeAttr(unsigned Idx, Attributes Attrs) const {
#ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment.
// For now, say we can't pass in alignment, which no current use does.
@ -259,8 +259,8 @@ PAListPtr PAListPtr::removeAttr(unsigned Idx, ParameterAttributes Attrs) const {
#endif
if (PAList == 0) return PAListPtr();
ParameterAttributes OldAttrs = getParamAttrs(Idx);
ParameterAttributes NewAttrs = OldAttrs & ~Attrs;
Attributes OldAttrs = getParamAttrs(Idx);
Attributes NewAttrs = OldAttrs & ~Attrs;
if (NewAttrs == OldAttrs)
return *this;

10
llvm/lib/VMCore/Function.cpp
View File

@ -112,12 +112,12 @@ bool Argument::hasStructRetAttr() const {
}
/// addAttr - Add a ParamAttr to an argument
void Argument::addAttr(ParameterAttributes attr) {
void Argument::addAttr(Attributes attr) {
getParent()->addParamAttr(getArgNo() + 1, attr);
}
/// removeAttr - Remove a ParamAttr from an argument
void Argument::removeAttr(ParameterAttributes attr) {
void Argument::removeAttr(Attributes attr) {
getParent()->removeParamAttr(getArgNo() + 1, attr);
}
@ -229,13 +229,13 @@ void Function::dropAllReferences() {
BasicBlocks.clear(); // Delete all basic blocks...
}
void Function::addParamAttr(unsigned i, ParameterAttributes attr) {
void Function::addParamAttr(unsigned i, Attributes attr) {
PAListPtr PAL = getParamAttrs();
PAL = PAL.addAttr(i, attr);
setParamAttrs(PAL);
}
void Function::removeParamAttr(unsigned i, ParameterAttributes attr) {
void Function::removeParamAttr(unsigned i, Attributes attr) {
PAListPtr PAL = getParamAttrs();
PAL = PAL.removeAttr(i, attr);
setParamAttrs(PAL);
@ -356,7 +356,7 @@ const FunctionType *Intrinsic::getType(ID id, const Type **Tys,
}
PAListPtr Intrinsic::getParamAttrs(ID id) {
ParameterAttributes Attr = ParamAttr::None;
Attributes Attr = ParamAttr::None;
#define GET_INTRINSIC_ATTRIBUTES
#include "llvm/Intrinsics.gen"

14
llvm/lib/VMCore/Instructions.cpp
View File

@ -53,7 +53,7 @@ void CallSite::setParamAttrs(const PAListPtr &PAL) {
else
cast<InvokeInst>(I)->setParamAttrs(PAL);
}
bool CallSite::paramHasAttr(uint16_t i, ParameterAttributes attr) const {
bool CallSite::paramHasAttr(uint16_t i, Attributes attr) const {
if (CallInst *CI = dyn_cast<CallInst>(I))
return CI->paramHasAttr(i, attr);
else
@ -402,19 +402,19 @@ CallInst::CallInst(const CallInst &CI)
OL[i] = InOL[i];
}
void CallInst::addParamAttr(unsigned i, ParameterAttributes attr) {
void CallInst::addParamAttr(unsigned i, Attributes attr) {
PAListPtr PAL = getParamAttrs();
PAL = PAL.addAttr(i, attr);
setParamAttrs(PAL);
}
void CallInst::removeParamAttr(unsigned i, ParameterAttributes attr) {
void CallInst::removeParamAttr(unsigned i, Attributes attr) {
PAListPtr PAL = getParamAttrs();
PAL = PAL.removeAttr(i, attr);
setParamAttrs(PAL);
}
bool CallInst::paramHasAttr(unsigned i, ParameterAttributes attr) const {
bool CallInst::paramHasAttr(unsigned i, Attributes attr) const {
if (ParamAttrs.paramHasAttr(i, attr))
return true;
if (const Function *F = getCalledFunction())
@ -473,7 +473,7 @@ void InvokeInst::setSuccessorV(unsigned idx, BasicBlock *B) {
return setSuccessor(idx, B);
}
bool InvokeInst::paramHasAttr(unsigned i, ParameterAttributes attr) const {
bool InvokeInst::paramHasAttr(unsigned i, Attributes attr) const {
if (ParamAttrs.paramHasAttr(i, attr))
return true;
if (const Function *F = getCalledFunction())
@ -481,13 +481,13 @@ bool InvokeInst::paramHasAttr(unsigned i, ParameterAttributes attr) const {
return false;
}
void InvokeInst::addParamAttr(unsigned i, ParameterAttributes attr) {
void InvokeInst::addParamAttr(unsigned i, Attributes attr) {
PAListPtr PAL = getParamAttrs();
PAL = PAL.addAttr(i, attr);
setParamAttrs(PAL);
}
void InvokeInst::removeParamAttr(unsigned i, ParameterAttributes attr) {
void InvokeInst::removeParamAttr(unsigned i, Attributes attr) {
PAListPtr PAL = getParamAttrs();
PAL = PAL.removeAttr(i, attr);
setParamAttrs(PAL);

18
llvm/lib/VMCore/Verifier.cpp
View File

@ -268,7 +268,7 @@ namespace {
void VerifyCallSite(CallSite CS);
void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
unsigned Count, ...);
void VerifyAttrs(ParameterAttributes Attrs, const Type *Ty,
void VerifyAttrs(Attributes Attrs, const Type *Ty,
bool isReturnValue, const Value *V);
void VerifyFunctionAttrs(const FunctionType *FT, const PAListPtr &Attrs,
const Value *V);
@ -406,33 +406,33 @@ 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(ParameterAttributes Attrs, const Type *Ty,
void Verifier::VerifyAttrs(Attributes Attrs, const Type *Ty,
bool isReturnValue, const Value *V) {
if (Attrs == ParamAttr::None)
return;
if (isReturnValue) {
ParameterAttributes RetI = Attrs & ParamAttr::ParameterOnly;
Attributes RetI = Attrs & ParamAttr::ParameterOnly;
Assert1(!RetI, "Attribute " + ParamAttr::getAsString(RetI) +
" does not apply to return values!", V);
} else {
ParameterAttributes ParmI = Attrs & ParamAttr::ReturnOnly;
Attributes ParmI = Attrs & ParamAttr::ReturnOnly;
Assert1(!ParmI, "Attribute " + ParamAttr::getAsString(ParmI) +
" only applies to return values!", V);
}
for (unsigned i = 0;
i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) {
ParameterAttributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i];
Attributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i];
Assert1(!(MutI & (MutI - 1)), "Attributes " +
ParamAttr::getAsString(MutI) + " are incompatible!", V);
}
ParameterAttributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty);
Attributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty);
Assert1(!TypeI, "Wrong type for attribute " +
ParamAttr::getAsString(TypeI), V);
ParameterAttributes ByValI = Attrs & ParamAttr::ByVal;
Attributes ByValI = Attrs & ParamAttr::ByVal;
if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
Assert1(!ByValI || PTy->getElementType()->isSized(),
"Attribute " + ParamAttr::getAsString(ByValI) +
@ -976,11 +976,11 @@ void Verifier::VerifyCallSite(CallSite CS) {
if (FTy->isVarArg())
// Check attributes on the varargs part.
for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) {
ParameterAttributes Attr = Attrs.getParamAttrs(Idx);
Attributes Attr = Attrs.getParamAttrs(Idx);
VerifyAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I);
ParameterAttributes VArgI = Attr & ParamAttr::VarArgsIncompatible;
Attributes VArgI = Attr & ParamAttr::VarArgsIncompatible;
Assert1(!VArgI, "Attribute " + ParamAttr::getAsString(VArgI) +
" cannot be used for vararg call arguments!", I);
}