replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

For PR1146: 

Adapt handling of parameter attributes to use the new ParamAttrsList class.

llvm-svn: 35814
This commit is contained in:
Reid Spencer 2007-04-09 06:17:21 +00:00
parent f51a7050dd
commit 71b79e3d99
5 changed files with 116 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -17,6 +17,7 @@
#include "llvm/Constants.h" #include "llvm/Constants.h"
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/Assembly/Parser.h" #include "llvm/Assembly/Parser.h"
@ -231,13 +232,13 @@ struct ValID {
struct TypeWithAttrs { struct TypeWithAttrs {
llvm::PATypeHolder *Ty; llvm::PATypeHolder *Ty;
FunctionType::ParameterAttributes Attrs; uint16_t Attrs;
}; };
typedef std::vector<TypeWithAttrs> TypeWithAttrsList; typedef std::vector<TypeWithAttrs> TypeWithAttrsList;
struct ArgListEntry { struct ArgListEntry {
FunctionType::ParameterAttributes Attrs; uint16_t Attrs;
llvm::PATypeHolder *Ty; llvm::PATypeHolder *Ty;
char *Name; char *Name;
}; };
@ -246,7 +247,7 @@ typedef std::vector<struct ArgListEntry> ArgListType;
struct ValueRefListEntry { struct ValueRefListEntry {
Value *Val; Value *Val;
FunctionType::ParameterAttributes Attrs; uint16_t Attrs;
}; };
typedef std::vector<ValueRefListEntry> ValueRefList; typedef std::vector<ValueRefListEntry> ValueRefList;

121
llvm/lib/AsmParser/llvmAsmParser.y
View File

@ -200,8 +200,6 @@ static struct PerModuleInfo {
} }
return false; return false;
} }
} CurModule; } CurModule;
static struct PerFunctionInfo { static struct PerFunctionInfo {
@ -962,7 +960,7 @@ Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
llvm::GlobalValue::LinkageTypes Linkage; llvm::GlobalValue::LinkageTypes Linkage;
llvm::GlobalValue::VisibilityTypes Visibility; llvm::GlobalValue::VisibilityTypes Visibility;
llvm::FunctionType::ParameterAttributes ParamAttrs; uint16_t ParamAttrs;
llvm::APInt *APIntVal; llvm::APInt *APIntVal;
int64_t SInt64Val; int64_t SInt64Val;
uint64_t UInt64Val; uint64_t UInt64Val;
@ -1191,26 +1189,26 @@ OptCallingConv : /*empty*/ { $$ = CallingConv::C; } |
CHECK_FOR_ERROR CHECK_FOR_ERROR
}; };
ParamAttr : ZEXT { $$ = FunctionType::ZExtAttribute; } ParamAttr : ZEXT { $$ = ZExtAttribute; }
| SEXT { $$ = FunctionType::SExtAttribute; } | SEXT { $$ = SExtAttribute; }
| INREG { $$ = FunctionType::InRegAttribute; } | INREG { $$ = InRegAttribute; }
| SRET { $$ = FunctionType::StructRetAttribute; } | SRET { $$ = StructRetAttribute; }
; ;
OptParamAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; } OptParamAttrs : /* empty */ { $$ = NoAttributeSet; }
| OptParamAttrs ParamAttr { | OptParamAttrs ParamAttr {
$$ = FunctionType::ParameterAttributes($1 | $2); $$ = $1 | $2;
} }
; ;
FuncAttr : NORETURN { $$ = FunctionType::NoReturnAttribute; } FuncAttr : NORETURN { $$ = NoReturnAttribute; }
| NOUNWIND { $$ = FunctionType::NoUnwindAttribute; } | NOUNWIND { $$ = NoUnwindAttribute; }
| ParamAttr | ParamAttr
; ;
OptFuncAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; } OptFuncAttrs : /* empty */ { $$ = NoAttributeSet; }
| OptFuncAttrs FuncAttr { | OptFuncAttrs FuncAttr {
$$ = FunctionType::ParameterAttributes($1 | $2); $$ = $1 | $2;
} }
; ;
@ -1299,18 +1297,25 @@ Types
} }
| Types '(' ArgTypeListI ')' OptFuncAttrs { | Types '(' ArgTypeListI ')' OptFuncAttrs {
std::vector<const Type*> Params; std::vector<const Type*> Params;
std::vector<FunctionType::ParameterAttributes> Attrs; ParamAttrsList Attrs;
Attrs.push_back($5); if ($5 != NoAttributeSet)
for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) { Attrs.addAttributes(0, $5);
unsigned index = 1;
TypeWithAttrsList::iterator I = $3->begin(), E = $3->end();
for (; I != E; ++I, ++index) {
const Type *Ty = I->Ty->get(); const Type *Ty = I->Ty->get();
Params.push_back(Ty); Params.push_back(Ty);
if (Ty != Type::VoidTy) if (Ty != Type::VoidTy)
Attrs.push_back(I->Attrs); if (I->Attrs != NoAttributeSet)
Attrs.addAttributes(index, I->Attrs);
} }
bool isVarArg = Params.size() && Params.back() == Type::VoidTy; bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
if (isVarArg) Params.pop_back(); if (isVarArg) Params.pop_back();
FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, Attrs); ParamAttrsList *ActualAttrs = 0;
if (!Attrs.empty())
ActualAttrs = new ParamAttrsList(Attrs);
FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, ActualAttrs);
delete $3; // Delete the argument list delete $3; // Delete the argument list
delete $1; // Delete the return type handle delete $1; // Delete the return type handle
$$ = new PATypeHolder(HandleUpRefs(FT)); $$ = new PATypeHolder(HandleUpRefs(FT));
@ -1318,18 +1323,26 @@ Types
} }
| VOID '(' ArgTypeListI ')' OptFuncAttrs { | VOID '(' ArgTypeListI ')' OptFuncAttrs {
std::vector<const Type*> Params; std::vector<const Type*> Params;
std::vector<FunctionType::ParameterAttributes> Attrs; ParamAttrsList Attrs;
Attrs.push_back($5); if ($5 != NoAttributeSet)
for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) { Attrs.addAttributes(0, $5);
TypeWithAttrsList::iterator I = $3->begin(), E = $3->end();
unsigned index = 1;
for ( ; I != E; ++I, ++index) {
const Type* Ty = I->Ty->get(); const Type* Ty = I->Ty->get();
Params.push_back(Ty); Params.push_back(Ty);
if (Ty != Type::VoidTy) if (Ty != Type::VoidTy)
Attrs.push_back(I->Attrs); if (I->Attrs != NoAttributeSet)
Attrs.addAttributes(index, I->Attrs);
} }
bool isVarArg = Params.size() && Params.back() == Type::VoidTy; bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
if (isVarArg) Params.pop_back(); if (isVarArg) Params.pop_back();
FunctionType *FT = FunctionType::get($1, Params, isVarArg, Attrs); ParamAttrsList *ActualAttrs = 0;
if (!Attrs.empty())
ActualAttrs = new ParamAttrsList(Attrs);
FunctionType *FT = FunctionType::get($1, Params, isVarArg, ActualAttrs);
delete $3; // Delete the argument list delete $3; // Delete the argument list
$$ = new PATypeHolder(HandleUpRefs(FT)); $$ = new PATypeHolder(HandleUpRefs(FT));
CHECK_FOR_ERROR CHECK_FOR_ERROR
@ -1417,14 +1430,14 @@ ArgTypeListI
: ArgTypeList : ArgTypeList
| ArgTypeList ',' DOTDOTDOT { | ArgTypeList ',' DOTDOTDOT {
$$=$1; $$=$1;
TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet; TypeWithAttrs TWA; TWA.Attrs = NoAttributeSet;
TWA.Ty = new PATypeHolder(Type::VoidTy); TWA.Ty = new PATypeHolder(Type::VoidTy);
$$->push_back(TWA); $$->push_back(TWA);
CHECK_FOR_ERROR CHECK_FOR_ERROR
} }
| DOTDOTDOT { | DOTDOTDOT {
$$ = new TypeWithAttrsList; $$ = new TypeWithAttrsList;
TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet; TypeWithAttrs TWA; TWA.Attrs = NoAttributeSet;
TWA.Ty = new PATypeHolder(Type::VoidTy); TWA.Ty = new PATypeHolder(Type::VoidTy);
$$->push_back(TWA); $$->push_back(TWA);
CHECK_FOR_ERROR CHECK_FOR_ERROR
@ -2087,7 +2100,7 @@ ArgList : ArgListH {
struct ArgListEntry E; struct ArgListEntry E;
E.Ty = new PATypeHolder(Type::VoidTy); E.Ty = new PATypeHolder(Type::VoidTy);
E.Name = 0; E.Name = 0;
E.Attrs = FunctionType::NoAttributeSet; E.Attrs = NoAttributeSet;
$$->push_back(E); $$->push_back(E);
CHECK_FOR_ERROR CHECK_FOR_ERROR
} }
@ -2096,7 +2109,7 @@ ArgList : ArgListH {
struct ArgListEntry E; struct ArgListEntry E;
E.Ty = new PATypeHolder(Type::VoidTy); E.Ty = new PATypeHolder(Type::VoidTy);
E.Name = 0; E.Name = 0;
E.Attrs = FunctionType::NoAttributeSet; E.Attrs = NoAttributeSet;
$$->push_back(E); $$->push_back(E);
CHECK_FOR_ERROR CHECK_FOR_ERROR
} }
@ -2117,24 +2130,31 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')'
GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription()); GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription());
std::vector<const Type*> ParamTypeList; std::vector<const Type*> ParamTypeList;
std::vector<FunctionType::ParameterAttributes> ParamAttrs; ParamAttrsList ParamAttrs;
ParamAttrs.push_back($7); if ($7 != NoAttributeSet)
ParamAttrs.addAttributes(0, $7);
if ($5) { // If there are arguments... if ($5) { // If there are arguments...
for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I) { unsigned index = 1;
for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I, ++index) {
const Type* Ty = I->Ty->get(); const Type* Ty = I->Ty->get();
if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty)) if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
GEN_ERROR("Reference to abstract argument: " + Ty->getDescription()); GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
ParamTypeList.push_back(Ty); ParamTypeList.push_back(Ty);
if (Ty != Type::VoidTy) if (Ty != Type::VoidTy)
ParamAttrs.push_back(I->Attrs); if (I->Attrs != NoAttributeSet)
ParamAttrs.addAttributes(index, I->Attrs);
} }
} }
bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy; bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
if (isVarArg) ParamTypeList.pop_back(); if (isVarArg) ParamTypeList.pop_back();
FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg, ParamAttrsList *ActualAttrs = 0;
ParamAttrs); if (!ParamAttrs.empty())
ActualAttrs = new ParamAttrsList(ParamAttrs);
FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg,
ActualAttrs);
const PointerType *PFT = PointerType::get(FT); const PointerType *PFT = PointerType::get(FT);
delete $2; delete $2;
@ -2465,17 +2485,24 @@ BBTerminatorInst : RET ResolvedVal { // Return with a result...
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
// Pull out the types of all of the arguments... // Pull out the types of all of the arguments...
std::vector<const Type*> ParamTypes; std::vector<const Type*> ParamTypes;
FunctionType::ParamAttrsList ParamAttrs; ParamAttrsList ParamAttrs;
ParamAttrs.push_back($8); if ($8 != NoAttributeSet)
for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) { ParamAttrs.addAttributes(0, $8);
ValueRefList::iterator I = $6->begin(), E = $6->end();
unsigned index = 1;
for (; I != E; ++I, ++index) {
const Type *Ty = I->Val->getType(); const Type *Ty = I->Val->getType();
if (Ty == Type::VoidTy) if (Ty == Type::VoidTy)
GEN_ERROR("Short call syntax cannot be used with varargs"); GEN_ERROR("Short call syntax cannot be used with varargs");
ParamTypes.push_back(Ty); ParamTypes.push_back(Ty);
ParamAttrs.push_back(I->Attrs); if (I->Attrs != NoAttributeSet)
ParamAttrs.addAttributes(index, I->Attrs);
} }
Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs); ParamAttrsList *Attrs = 0;
if (!ParamAttrs.empty())
Attrs = new ParamAttrsList(ParamAttrs);
Ty = FunctionType::get($3->get(), ParamTypes, false, Attrs);
PFTy = PointerType::get(Ty); PFTy = PointerType::get(Ty);
} }
@ -2764,17 +2791,25 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
// Pull out the types of all of the arguments... // Pull out the types of all of the arguments...
std::vector<const Type*> ParamTypes; std::vector<const Type*> ParamTypes;
FunctionType::ParamAttrsList ParamAttrs; ParamAttrsList ParamAttrs;
ParamAttrs.push_back($8); if ($8 != NoAttributeSet)
for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) { ParamAttrs.addAttributes(0, $8);
unsigned index = 1;
ValueRefList::iterator I = $6->begin(), E = $6->end();
for (; I != E; ++I, ++index) {
const Type *Ty = I->Val->getType(); const Type *Ty = I->Val->getType();
if (Ty == Type::VoidTy) if (Ty == Type::VoidTy)
GEN_ERROR("Short call syntax cannot be used with varargs"); GEN_ERROR("Short call syntax cannot be used with varargs");
ParamTypes.push_back(Ty); ParamTypes.push_back(Ty);
ParamAttrs.push_back(I->Attrs); if (I->Attrs != NoAttributeSet)
ParamAttrs.addAttributes(index, I->Attrs);
} }
Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs); ParamAttrsList *Attrs = 0;
if (!ParamAttrs.empty())
Attrs = new ParamAttrsList(ParamAttrs);
Ty = FunctionType::get($3->get(), ParamTypes, false, Attrs);
PFTy = PointerType::get(Ty); PFTy = PointerType::get(Ty);
} }

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

@ -25,6 +25,7 @@
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/Intrinsics.h" #include "llvm/Intrinsics.h"
#include "llvm/IntrinsicInst.h" #include "llvm/IntrinsicInst.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/CodeGen/MachineModuleInfo.h" #include "llvm/CodeGen/MachineModuleInfo.h"
#include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/MachineFrameInfo.h"
@ -802,10 +803,11 @@ void SelectionDAGLowering::visitRet(ReturnInst &I) {
else else
TmpVT = MVT::i32; TmpVT = MVT::i32;
const FunctionType *FTy = I.getParent()->getParent()->getFunctionType(); const FunctionType *FTy = I.getParent()->getParent()->getFunctionType();
const ParamAttrsList *Attrs = FTy->getParamAttrs();
ISD::NodeType ExtendKind = ISD::ANY_EXTEND; ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
if (FTy->paramHasAttr(0, FunctionType::SExtAttribute)) if (Attrs && Attrs->paramHasAttr(0, SExtAttribute))
ExtendKind = ISD::SIGN_EXTEND; ExtendKind = ISD::SIGN_EXTEND;
if (FTy->paramHasAttr(0, FunctionType::ZExtAttribute)) if (Attrs && Attrs->paramHasAttr(0, ZExtAttribute))
ExtendKind = ISD::ZERO_EXTEND; ExtendKind = ISD::ZERO_EXTEND;
RetOp = DAG.getNode(ExtendKind, TmpVT, RetOp); RetOp = DAG.getNode(ExtendKind, TmpVT, RetOp);
} }
@ -2508,6 +2510,7 @@ void SelectionDAGLowering::LowerCallTo(Instruction &I,
SDOperand Callee, unsigned OpIdx) { SDOperand Callee, unsigned OpIdx) {
const PointerType *PT = cast<PointerType>(CalledValueTy); const PointerType *PT = cast<PointerType>(CalledValueTy);
const FunctionType *FTy = cast<FunctionType>(PT->getElementType()); const FunctionType *FTy = cast<FunctionType>(PT->getElementType());
const ParamAttrsList *Attrs = FTy->getParamAttrs();
TargetLowering::ArgListTy Args; TargetLowering::ArgListTy Args;
TargetLowering::ArgListEntry Entry; TargetLowering::ArgListEntry Entry;
@ -2516,16 +2519,16 @@ void SelectionDAGLowering::LowerCallTo(Instruction &I,
Value *Arg = I.getOperand(i); Value *Arg = I.getOperand(i);
SDOperand ArgNode = getValue(Arg); SDOperand ArgNode = getValue(Arg);
Entry.Node = ArgNode; Entry.Ty = Arg->getType(); Entry.Node = ArgNode; Entry.Ty = Arg->getType();
Entry.isSExt = FTy->paramHasAttr(i, FunctionType::SExtAttribute); Entry.isSExt = Attrs && Attrs->paramHasAttr(i, SExtAttribute);
Entry.isZExt = FTy->paramHasAttr(i, FunctionType::ZExtAttribute); Entry.isZExt = Attrs && Attrs->paramHasAttr(i, ZExtAttribute);
Entry.isInReg = FTy->paramHasAttr(i, FunctionType::InRegAttribute); Entry.isInReg = Attrs && Attrs->paramHasAttr(i, InRegAttribute);
Entry.isSRet = FTy->paramHasAttr(i, FunctionType::StructRetAttribute); Entry.isSRet = Attrs && Attrs->paramHasAttr(i, StructRetAttribute);
Args.push_back(Entry); Args.push_back(Entry);
} }
std::pair<SDOperand,SDOperand> Result = std::pair<SDOperand,SDOperand> Result =
TLI.LowerCallTo(getRoot(), I.getType(), TLI.LowerCallTo(getRoot(), I.getType(),
FTy->paramHasAttr(0,FunctionType::SExtAttribute), Attrs && Attrs->paramHasAttr(0, SExtAttribute),
FTy->isVarArg(), CallingConv, IsTailCall, FTy->isVarArg(), CallingConv, IsTailCall,
Callee, Args, DAG); Callee, Args, DAG);
if (I.getType() != Type::VoidTy) if (I.getType() != Type::VoidTy)
@ -3346,6 +3349,7 @@ static SDOperand ExpandScalarFormalArgs(MVT::ValueType VT, SDNode *Arg,
std::vector<SDOperand> std::vector<SDOperand>
TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) { TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
const FunctionType *FTy = F.getFunctionType(); const FunctionType *FTy = F.getFunctionType();
const ParamAttrsList *Attrs = FTy->getParamAttrs();
// Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node. // Add CC# and isVararg as operands to the FORMAL_ARGUMENTS node.
std::vector<SDOperand> Ops; std::vector<SDOperand> Ops;
Ops.push_back(DAG.getRoot()); Ops.push_back(DAG.getRoot());
@ -3364,13 +3368,13 @@ TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
// FIXME: Distinguish between a formal with no [sz]ext attribute from one // FIXME: Distinguish between a formal with no [sz]ext attribute from one
// that is zero extended! // that is zero extended!
if (FTy->paramHasAttr(j, FunctionType::ZExtAttribute)) if (Attrs && Attrs->paramHasAttr(j, ZExtAttribute))
Flags &= ~(ISD::ParamFlags::SExt); Flags &= ~(ISD::ParamFlags::SExt);
if (FTy->paramHasAttr(j, FunctionType::SExtAttribute)) if (Attrs && Attrs->paramHasAttr(j, SExtAttribute))
Flags |= ISD::ParamFlags::SExt; Flags |= ISD::ParamFlags::SExt;
if (FTy->paramHasAttr(j, FunctionType::InRegAttribute)) if (Attrs && Attrs->paramHasAttr(j, InRegAttribute))
Flags |= ISD::ParamFlags::InReg; Flags |= ISD::ParamFlags::InReg;
if (FTy->paramHasAttr(j, FunctionType::StructRetAttribute)) if (Attrs && Attrs->paramHasAttr(j, StructRetAttribute))
Flags |= ISD::ParamFlags::StructReturn; Flags |= ISD::ParamFlags::StructReturn;
Flags |= (OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs); Flags |= (OriginalAlignment << ISD::ParamFlags::OrigAlignmentOffs);
@ -3444,10 +3448,10 @@ TargetLowering::LowerArguments(Function &F, SelectionDAG &DAG) {
case Promote: { case Promote: {
SDOperand Op(Result, i++); SDOperand Op(Result, i++);
if (MVT::isInteger(VT)) { if (MVT::isInteger(VT)) {
if (FTy->paramHasAttr(Idx, FunctionType::SExtAttribute)) if (Attrs && Attrs->paramHasAttr(Idx, SExtAttribute))
Op = DAG.getNode(ISD::AssertSext, Op.getValueType(), Op, Op = DAG.getNode(ISD::AssertSext, Op.getValueType(), Op,
DAG.getValueType(VT)); DAG.getValueType(VT));
else if (FTy->paramHasAttr(Idx, FunctionType::ZExtAttribute)) else if (Attrs && Attrs->paramHasAttr(Idx, ZExtAttribute))
Op = DAG.getNode(ISD::AssertZext, Op.getValueType(), Op, Op = DAG.getNode(ISD::AssertZext, Op.getValueType(), Op,
DAG.getValueType(VT)); DAG.getValueType(VT));
Op = DAG.getNode(ISD::TRUNCATE, VT, Op); Op = DAG.getNode(ISD::TRUNCATE, VT, Op);

21
llvm/lib/Target/CBackend/CBackend.cpp
View File

@ -18,6 +18,7 @@
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/PassManager.h" #include "llvm/PassManager.h"
#include "llvm/TypeSymbolTable.h" #include "llvm/TypeSymbolTable.h"
@ -350,11 +351,12 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end(); FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
const Type *RetTy = cast<PointerType>(I->get())->getElementType(); const Type *RetTy = cast<PointerType>(I->get())->getElementType();
unsigned Idx = 1; unsigned Idx = 1;
const ParamAttrsList *Attrs = FTy->getParamAttrs();
for (++I; I != E; ++I) { for (++I; I != E; ++I) {
if (PrintedType) if (PrintedType)
FunctionInnards << ", "; FunctionInnards << ", ";
printType(FunctionInnards, *I, printType(FunctionInnards, *I,
/*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), ""); /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), "");
PrintedType = true; PrintedType = true;
} }
if (FTy->isVarArg()) { if (FTy->isVarArg()) {
@ -366,7 +368,7 @@ void CWriter::printStructReturnPointerFunctionType(std::ostream &Out,
FunctionInnards << ')'; FunctionInnards << ')';
std::string tstr = FunctionInnards.str(); std::string tstr = FunctionInnards.str();
printType(Out, RetTy, printType(Out, RetTy,
/*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr); /*isSigned=*/Attrs && Attrs->paramHasAttr(0, SExtAttribute), tstr);
} }
std::ostream & std::ostream &
@ -421,13 +423,14 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
const FunctionType *FTy = cast<FunctionType>(Ty); const FunctionType *FTy = cast<FunctionType>(Ty);
std::stringstream FunctionInnards; std::stringstream FunctionInnards;
FunctionInnards << " (" << NameSoFar << ") ("; FunctionInnards << " (" << NameSoFar << ") (";
const ParamAttrsList *Attrs = FTy->getParamAttrs();
unsigned Idx = 1; unsigned Idx = 1;
for (FunctionType::param_iterator I = FTy->param_begin(), for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I) { E = FTy->param_end(); I != E; ++I) {
if (I != FTy->param_begin()) if (I != FTy->param_begin())
FunctionInnards << ", "; FunctionInnards << ", ";
printType(FunctionInnards, *I, printType(FunctionInnards, *I,
/*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute), ""); /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute), "");
++Idx; ++Idx;
} }
if (FTy->isVarArg()) { if (FTy->isVarArg()) {
@ -439,7 +442,7 @@ std::ostream &CWriter::printType(std::ostream &Out, const Type *Ty,
FunctionInnards << ')'; FunctionInnards << ')';
std::string tstr = FunctionInnards.str(); std::string tstr = FunctionInnards.str();
printType(Out, FTy->getReturnType(), printType(Out, FTy->getReturnType(),
/*isSigned=*/FTy->paramHasAttr(0, FunctionType::SExtAttribute), tstr); /*isSigned=*/Attrs && Attrs->paramHasAttr(0, SExtAttribute), tstr);
return Out; return Out;
} }
case Type::StructTyID: { case Type::StructTyID: {
@ -1801,6 +1804,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
// Loop over the arguments, printing them... // Loop over the arguments, printing them...
const FunctionType *FT = cast<FunctionType>(F->getFunctionType()); const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
const ParamAttrsList *Attrs = FT->getParamAttrs();
std::stringstream FunctionInnards; std::stringstream FunctionInnards;
@ -1828,7 +1832,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
else else
ArgName = ""; ArgName = "";
printType(FunctionInnards, I->getType(), printType(FunctionInnards, I->getType(),
/*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute), /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute),
ArgName); ArgName);
PrintedArg = true; PrintedArg = true;
++Idx; ++Idx;
@ -1849,7 +1853,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
for (; I != E; ++I) { for (; I != E; ++I) {
if (PrintedArg) FunctionInnards << ", "; if (PrintedArg) FunctionInnards << ", ";
printType(FunctionInnards, *I, printType(FunctionInnards, *I,
/*isSigned=*/FT->paramHasAttr(Idx, FunctionType::SExtAttribute)); /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute));
PrintedArg = true; PrintedArg = true;
++Idx; ++Idx;
} }
@ -1877,7 +1881,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
// Print out the return type and the signature built above. // Print out the return type and the signature built above.
printType(Out, RetTy, printType(Out, RetTy,
/*isSigned=*/FT->paramHasAttr(0, FunctionType::SExtAttribute), /*isSigned=*/ Attrs && Attrs->paramHasAttr(0, SExtAttribute),
FunctionInnards.str()); FunctionInnards.str());
} }
@ -2573,6 +2577,7 @@ void CWriter::visitCallInst(CallInst &I) {
++ArgNo; ++ArgNo;
} }
const ParamAttrsList *Attrs = FTy->getParamAttrs();
bool PrintedArg = false; bool PrintedArg = false;
unsigned Idx = 1; unsigned Idx = 1;
for (; AI != AE; ++AI, ++ArgNo, ++Idx) { for (; AI != AE; ++AI, ++ArgNo, ++Idx) {
@ -2581,7 +2586,7 @@ void CWriter::visitCallInst(CallInst &I) {
(*AI)->getType() != FTy->getParamType(ArgNo)) { (*AI)->getType() != FTy->getParamType(ArgNo)) {
Out << '('; Out << '(';
printType(Out, FTy->getParamType(ArgNo), printType(Out, FTy->getParamType(ArgNo),
/*isSigned=*/FTy->paramHasAttr(Idx, FunctionType::SExtAttribute)); /*isSigned=*/Attrs && Attrs->paramHasAttr(Idx, SExtAttribute));
Out << ')'; Out << ')';
} }
writeOperand(*AI); writeOperand(*AI);

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

@ -16,6 +16,7 @@
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/Intrinsics.h" #include "llvm/Intrinsics.h"
#include "llvm/IntrinsicInst.h" #include "llvm/IntrinsicInst.h"
#include "llvm/ParameterAttributes.h"
#include "llvm/TypeSymbolTable.h" #include "llvm/TypeSymbolTable.h"
#include "llvm/Analysis/ConstantsScanner.h" #include "llvm/Analysis/ConstantsScanner.h"
#include "llvm/Support/CallSite.h" #include "llvm/Support/CallSite.h"
@ -1131,7 +1132,8 @@ void MSILWriter::printStaticInitializerList() {
void MSILWriter::printFunction(const Function& F) { void MSILWriter::printFunction(const Function& F) {
const FunctionType* FTy = F.getFunctionType(); const FunctionType* FTy = F.getFunctionType();
bool isSigned = FTy->paramHasAttr(0,FunctionType::SExtAttribute); const ParamAttrsList *Attrs = FTy->getParamAttrs();
bool isSigned = Attrs && Attrs->paramHasAttr(0, SExtAttribute);
Out << "\n.method static "; Out << "\n.method static ";
Out << (F.hasInternalLinkage() ? "private " : "public "); Out << (F.hasInternalLinkage() ? "private " : "public ");
if (F.isVarArg()) Out << "vararg "; if (F.isVarArg()) Out << "vararg ";
@ -1142,7 +1144,7 @@ void MSILWriter::printFunction(const Function& F) {
unsigned ArgIdx = 1; unsigned ArgIdx = 1;
for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I!=E; for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end(); I!=E;
++I, ++ArgIdx) { ++I, ++ArgIdx) {
isSigned = FTy->paramHasAttr(ArgIdx,FunctionType::SExtAttribute); isSigned = Attrs && Attrs->paramHasAttr(ArgIdx, SExtAttribute);
if (I!=F.arg_begin()) Out << ", "; if (I!=F.arg_begin()) Out << ", ";
Out << getTypeName(I->getType(),isSigned) << getValueName(I); Out << getTypeName(I->getType(),isSigned) << getValueName(I);
} }