[llvm-commits] [llvm-gcc-4.2] r56624 - in /llvm-gcc-4.2/trunk/gcc: config/i386/llvm-i386-target.h llvm-abi.h llvm-backend.cpp llvm-convert.cpp llvm-internal.h llvm-types.cpp
Devang Patel
dpatel at apple.com
Thu Sep 25 14:05:14 PDT 2008
Author: dpatel
Date: Thu Sep 25 16:05:14 2008
New Revision: 56624
URL: http://llvm.org/viewvc/llvm-project?rev=56624&view=rev
Log:
Large mechanical patch.
s/ParamAttr/Attribute/g
s/PAList/AttrList/g
s/FnAttributeWithIndex/AttributeWithIndex/g
s/FnAttr/Attribute/g
This sets the stage
- to implement function notes as function attributes and
- to distinguish between function attributes and return value attributes.
Modified:
llvm-gcc-4.2/trunk/gcc/config/i386/llvm-i386-target.h
llvm-gcc-4.2/trunk/gcc/llvm-abi.h
llvm-gcc-4.2/trunk/gcc/llvm-backend.cpp
llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp
llvm-gcc-4.2/trunk/gcc/llvm-internal.h
llvm-gcc-4.2/trunk/gcc/llvm-types.cpp
Modified: llvm-gcc-4.2/trunk/gcc/config/i386/llvm-i386-target.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/config/i386/llvm-i386-target.h?rev=56624&r1=56623&r2=56624&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/config/i386/llvm-i386-target.h (original)
+++ llvm-gcc-4.2/trunk/gcc/config/i386/llvm-i386-target.h Thu Sep 25 16:05:14 2008
@@ -59,7 +59,7 @@
local_fp_regparm = 3; \
}
-#define LLVM_ADJUST_REGPARM_ATTRIBUTE(Attribute, Type, Size, \
+#define LLVM_ADJUST_REGPARM_ATTRIBUTE(PAttribute, Type, Size, \
local_regparm, \
local_fp_regparm) \
{ \
@@ -69,7 +69,7 @@
TYPE_PRECISION(Type)==64)) { \
local_fp_regparm -= 1; \
if (local_fp_regparm >= 0) \
- Attribute |= ParamAttr::InReg; \
+ PAttribute |= Attribute::InReg; \
else \
local_fp_regparm = 0; \
} else if (TREE_CODE(Type) == INTEGER_TYPE || \
@@ -78,7 +78,7 @@
(Size + BITS_PER_WORD - 1) / BITS_PER_WORD; \
local_regparm -= words; \
if (local_regparm>=0) \
- Attribute |= ParamAttr::InReg; \
+ PAttribute |= Attribute::InReg; \
else \
local_regparm = 0; \
} \
Modified: llvm-gcc-4.2/trunk/gcc/llvm-abi.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-abi.h?rev=56624&r1=56623&r2=56624&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-abi.h (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-abi.h Thu Sep 25 16:05:14 2008
@@ -430,9 +430,9 @@
} else if (LLVM_SHOULD_PASS_VECTOR_USING_BYVAL_ATTR(type)) {
C.HandleByValArgument(Ty, type);
if (Attributes) {
- *Attributes |= ParamAttr::ByVal;
+ *Attributes |= Attribute::ByVal;
*Attributes |=
- ParamAttr::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type));
+ Attribute::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type));
}
} else {
C.HandleScalarArgument(Ty, type);
@@ -447,17 +447,17 @@
else {
C.HandleByValArgument(Ty, type);
if (Attributes) {
- *Attributes |= ParamAttr::ByVal;
+ *Attributes |= Attribute::ByVal;
*Attributes |=
- ParamAttr::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type));
+ Attribute::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type));
}
}
} else if (LLVM_SHOULD_PASS_AGGREGATE_USING_BYVAL_ATTR(type, Ty)) {
C.HandleByValArgument(Ty, type);
if (Attributes) {
- *Attributes |= ParamAttr::ByVal;
+ *Attributes |= Attribute::ByVal;
*Attributes |=
- ParamAttr::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type));
+ Attribute::constructAlignmentFromInt(LLVM_BYVAL_ALIGNMENT(type));
}
} else if (LLVM_SHOULD_PASS_AGGREGATE_IN_INTEGER_REGS(type, &Size,
&DontCheckAlignment)) {
Modified: llvm-gcc-4.2/trunk/gcc/llvm-backend.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-backend.cpp?rev=56624&r1=56623&r2=56624&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-backend.cpp (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-backend.cpp Thu Sep 25 16:05:14 2008
@@ -386,7 +386,7 @@
// marked as always_inline.
for (Module::iterator I = TheModule->begin(), E = TheModule->end();
I != E; ++I)
- if (I->hasNote(FnAttr::AlwaysInline)) {
+ if (I->hasNote(Attribute::AlwaysInline)) {
NeedAlwaysInliner = true;
break;
}
@@ -1239,13 +1239,13 @@
Function *FnEntry = TheModule->getFunction(Name);
if (FnEntry == 0) {
unsigned CC;
- PAListPtr PAL;
+ AttrListPtr PAL;
const FunctionType *Ty =
TheTypeConverter->ConvertFunctionType(TREE_TYPE(decl), decl, NULL,
CC, PAL);
FnEntry = Function::Create(Ty, Function::ExternalLinkage, Name, TheModule);
FnEntry->setCallingConv(CC);
- FnEntry->setParamAttrs(PAL);
+ FnEntry->setAttributes(PAL);
// Check for external weak linkage
if (DECL_EXTERNAL(decl) && DECL_WEAK(decl))
Modified: llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp?rev=56624&r1=56623&r2=56624&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-convert.cpp Thu Sep 25 16:05:14 2008
@@ -560,7 +560,7 @@
tree static_chain = cfun->static_chain_decl;
const FunctionType *FTy;
unsigned CallingConv;
- PAListPtr PAL;
+ AttrListPtr PAL;
// If the function has no arguments and is varargs (...), turn it into a
// non-varargs function by scanning the param list for the function. This
@@ -609,7 +609,7 @@
Fn = Function::Create(FTy, Function::ExternalLinkage, Name, TheModule);
assert(Fn->getName() == Name && "Preexisting fn with the same name!");
Fn->setCallingConv(CallingConv);
- Fn->setParamAttrs(PAL);
+ Fn->setAttributes(PAL);
// If a previous proto existed with the wrong type, replace any uses of it
// with the actual function and delete the proto.
@@ -652,7 +652,7 @@
// Handle noinline Functions
if (lookup_attribute ("noinline", DECL_ATTRIBUTES (FnDecl)))
- Fn->setNotes(FnAttr::NoInline);
+ Fn->setNotes(Attribute::NoInline);
/* FIXME: Remove llvm.noinline related code.
{
const Type *SBP= PointerType::getUnqual(Type::Int8Ty);
@@ -663,10 +663,10 @@
// Handle always_inline attribute
if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (FnDecl)))
- Fn->setNotes(FnAttr::AlwaysInline);
+ Fn->setNotes(Attribute::AlwaysInline);
if (optimize_size)
- Fn->setNotes(FnAttr::OptimizeForSize);
+ Fn->setNotes(Attribute::OptimizeForSize);
// Handle annotate attributes
if (DECL_ATTRIBUTES(FnDecl))
@@ -2352,7 +2352,7 @@
&& "Not calling a function pointer?");
tree function_type = TREE_TYPE(TREE_TYPE (TREE_OPERAND (exp, 0)));
unsigned CallingConv;
- PAListPtr PAL;
+ AttrListPtr PAL;
const Type *Ty = TheTypeConverter->ConvertFunctionType(function_type,
fndecl,
@@ -2616,19 +2616,19 @@
/// in the CALL_EXP 'exp'. If the result of the call is a scalar, return the
/// result, otherwise store it in DestLoc.
Value *TreeToLLVM::EmitCallOf(Value *Callee, tree exp, const MemRef *DestLoc,
- const PAListPtr &InPAL) {
+ const AttrListPtr &InPAL) {
BasicBlock *LandingPad = 0; // Non-zero indicates an invoke.
- PAListPtr PAL = InPAL;
+ AttrListPtr PAL = InPAL;
if (PAL.isEmpty() && isa<Function>(Callee))
- PAL = cast<Function>(Callee)->getParamAttrs();
+ PAL = cast<Function>(Callee)->getAttributes();
// Work out whether to use an invoke or an ordinary call.
if (!tree_could_throw_p(exp))
// This call does not throw - mark it 'nounwind'.
- PAL = PAL.addAttr(0, ParamAttr::NoUnwind);
+ PAL = PAL.addAttr(0, Attribute::NoUnwind);
- if (!PAL.paramHasAttr(0, ParamAttr::NoUnwind)) {
+ if (!PAL.paramHasAttr(0, Attribute::NoUnwind)) {
// This call may throw. Determine if we need to generate
// an invoke rather than a simple call.
int RegionNo = lookup_stmt_eh_region(exp);
@@ -2696,10 +2696,10 @@
Client.pushAddress(ArgVal.Ptr);
}
- Attributes Attrs = ParamAttr::None;
+ Attributes Attrs = Attribute::None;
ABIConverter.HandleArgument(TREE_TYPE(TREE_VALUE(arg)), ScalarArgs,
&Attrs);
- if (Attrs != ParamAttr::None)
+ if (Attrs != Attribute::None)
PAL = PAL.addAttr(CallOperands.size(), Attrs);
Client.clear();
@@ -2732,13 +2732,13 @@
if (!LandingPad) {
Call = Builder.CreateCall(Callee, CallOperands.begin(), CallOperands.end());
cast<CallInst>(Call)->setCallingConv(CallingConvention);
- cast<CallInst>(Call)->setParamAttrs(PAL);
+ cast<CallInst>(Call)->setAttributes(PAL);
} else {
BasicBlock *NextBlock = BasicBlock::Create("invcont");
Call = Builder.CreateInvoke(Callee, NextBlock, LandingPad,
CallOperands.begin(), CallOperands.end());
cast<InvokeInst>(Call)->setCallingConv(CallingConvention);
- cast<InvokeInst>(Call)->setParamAttrs(PAL);
+ cast<InvokeInst>(Call)->setAttributes(PAL);
EmitBlock(NextBlock);
}
@@ -4422,7 +4422,7 @@
Intrinsic::getDeclaration(TheModule, IntrinsicID);
}
- Result = EmitCallOf(TargetBuiltinCache[FnCode], exp, DestLoc, PAListPtr());
+ Result = EmitCallOf(TargetBuiltinCache[FnCode], exp, DestLoc, AttrListPtr());
return true;
}
Modified: llvm-gcc-4.2/trunk/gcc/llvm-internal.h
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-internal.h?rev=56624&r1=56623&r2=56624&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-internal.h (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-internal.h Thu Sep 25 16:05:14 2008
@@ -164,7 +164,7 @@
tree_node *decl,
tree_node *static_chain,
unsigned &CallingConv,
- PAListPtr &PAL);
+ AttrListPtr &PAL);
/// ConvertArgListToFnType - Given a DECL_ARGUMENTS list on an GCC tree,
/// return the LLVM type corresponding to the function. This is useful for
@@ -173,7 +173,7 @@
tree_node *arglist,
tree_node *static_chain,
unsigned &CallingConv,
- PAListPtr &PAL);
+ AttrListPtr &PAL);
private:
const Type *ConvertRECORD(tree_node *type, tree_node *orig_type);
@@ -486,7 +486,7 @@
Value *EmitOBJ_TYPE_REF(tree_node *exp);
Value *EmitCALL_EXPR(tree_node *exp, const MemRef *DestLoc);
Value *EmitCallOf(Value *Callee, tree_node *exp, const MemRef *DestLoc,
- const PAListPtr &PAL);
+ const AttrListPtr &PAL);
Value *EmitMODIFY_EXPR(tree_node *exp, const MemRef *DestLoc);
Value *EmitNOP_EXPR(tree_node *exp, const MemRef *DestLoc);
Value *EmitCONVERT_EXPR(tree_node *exp, const MemRef *DestLoc);
Modified: llvm-gcc-4.2/trunk/gcc/llvm-types.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm-gcc-4.2/trunk/gcc/llvm-types.cpp?rev=56624&r1=56623&r2=56624&view=diff
==============================================================================
--- llvm-gcc-4.2/trunk/gcc/llvm-types.cpp (original)
+++ llvm-gcc-4.2/trunk/gcc/llvm-types.cpp Thu Sep 25 16:05:14 2008
@@ -866,7 +866,7 @@
// No declaration to pass through, passing NULL.
unsigned CallingConv;
- PAListPtr PAL;
+ AttrListPtr PAL;
return TypeDB.setType(type, ConvertFunctionType(type, NULL, NULL,
CallingConv, PAL));
}
@@ -1028,16 +1028,16 @@
static Attributes HandleArgumentExtension(tree ArgTy) {
if (TREE_CODE(ArgTy) == BOOLEAN_TYPE) {
if (TREE_INT_CST_LOW(TYPE_SIZE(ArgTy)) < INT_TYPE_SIZE)
- return ParamAttr::ZExt;
+ return Attribute::ZExt;
} else if (TREE_CODE(ArgTy) == INTEGER_TYPE &&
TREE_INT_CST_LOW(TYPE_SIZE(ArgTy)) < INT_TYPE_SIZE) {
if (TYPE_UNSIGNED(ArgTy))
- return ParamAttr::ZExt;
+ return Attribute::ZExt;
else
- return ParamAttr::SExt;
+ return Attribute::SExt;
}
- return ParamAttr::None;
+ return Attribute::None;
}
/// ConvertParamListToLLVMSignature - This method is used to build the argument
@@ -1048,7 +1048,7 @@
/// specified result type for the function.
const FunctionType *TypeConverter::
ConvertArgListToFnType(tree ReturnType, tree Args, tree static_chain,
- unsigned &CallingConv, PAListPtr &PAL) {
+ unsigned &CallingConv, AttrListPtr &PAL) {
std::vector<PATypeHolder> ArgTys;
PATypeHolder RetTy(Type::VoidTy);
@@ -1058,51 +1058,51 @@
// Builtins are always prototyped, so this isn't one.
ABIConverter.HandleReturnType(ReturnType, current_function_decl, false);
- SmallVector<FnAttributeWithIndex, 8> Attrs;
+ SmallVector<AttributeWithIndex, 8> Attrs;
// Compute whether the result needs to be zext or sext'd.
Attributes RAttributes = HandleArgumentExtension(ReturnType);
- if (RAttributes != ParamAttr::None)
- Attrs.push_back(FnAttributeWithIndex::get(0, RAttributes));
+ if (RAttributes != Attribute::None)
+ Attrs.push_back(AttributeWithIndex::get(0, RAttributes));
// If this function returns via a shadow argument, the dest loc is passed
// in as a pointer. Mark that pointer as struct-ret and noalias.
if (ABIConverter.isShadowReturn())
- Attrs.push_back(FnAttributeWithIndex::get(ArgTys.size(),
- ParamAttr::StructRet | ParamAttr::NoAlias));
+ Attrs.push_back(AttributeWithIndex::get(ArgTys.size(),
+ Attribute::StructRet | Attribute::NoAlias));
std::vector<const Type*> ScalarArgs;
if (static_chain) {
// Pass the static chain as the first parameter.
ABIConverter.HandleArgument(TREE_TYPE(static_chain), ScalarArgs);
// Mark it as the chain argument.
- Attrs.push_back(FnAttributeWithIndex::get(ArgTys.size(),
- ParamAttr::Nest));
+ Attrs.push_back(AttributeWithIndex::get(ArgTys.size(),
+ Attribute::Nest));
}
for (; Args && TREE_TYPE(Args) != void_type_node; Args = TREE_CHAIN(Args)) {
tree ArgTy = TREE_TYPE(Args);
// Determine if there are any attributes for this param.
- Attributes Attributes = ParamAttr::None;
+ Attributes PAttributes = Attribute::None;
- ABIConverter.HandleArgument(ArgTy, ScalarArgs, &Attributes);
+ ABIConverter.HandleArgument(ArgTy, ScalarArgs, &PAttributes);
// Compute zext/sext attributes.
- Attributes |= HandleArgumentExtension(ArgTy);
+ PAttributes |= HandleArgumentExtension(ArgTy);
- if (Attributes != ParamAttr::None)
- Attrs.push_back(FnAttributeWithIndex::get(ArgTys.size(), Attributes));
+ if (PAttributes != Attribute::None)
+ Attrs.push_back(AttributeWithIndex::get(ArgTys.size(), PAttributes));
}
- PAL = PAListPtr::get(Attrs.begin(), Attrs.end());
+ PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
return GetFunctionType(RetTy, ArgTys, false);
}
const FunctionType *TypeConverter::
ConvertFunctionType(tree type, tree decl, tree static_chain,
- unsigned &CallingConv, PAListPtr &PAL) {
+ unsigned &CallingConv, AttrListPtr &PAL) {
PATypeHolder RetTy = Type::VoidTy;
std::vector<PATypeHolder> ArgTypes;
bool isVarArg = false;
@@ -1118,18 +1118,18 @@
#endif
// Compute attributes for return type (and function attributes).
- SmallVector<FnAttributeWithIndex, 8> Attrs;
- Attributes RAttributes = ParamAttr::None;
+ SmallVector<AttributeWithIndex, 8> Attrs;
+ Attributes RAttributes = Attribute::None;
int flags = flags_from_decl_or_type(decl ? decl : type);
// Check for 'noreturn' function attribute.
if (flags & ECF_NORETURN)
- RAttributes |= ParamAttr::NoReturn;
+ RAttributes |= Attribute::NoReturn;
// Check for 'nounwind' function attribute.
if (flags & ECF_NOTHROW)
- RAttributes |= ParamAttr::NoUnwind;
+ RAttributes |= Attribute::NoUnwind;
// Check for 'readnone' function attribute.
// Both PURE and CONST will be set if the user applied
@@ -1140,43 +1140,43 @@
// accepts it). But llvm IR does not allow both, so
// set only ReadNone.
if (flags & ECF_CONST)
- RAttributes |= ParamAttr::ReadNone;
+ RAttributes |= Attribute::ReadNone;
// Check for 'readonly' function attribute.
if (flags & ECF_PURE && !(flags & ECF_CONST))
- RAttributes |= ParamAttr::ReadOnly;
+ RAttributes |= Attribute::ReadOnly;
// Since they write the return value through a pointer,
// 'sret' functions cannot be 'readnone' or 'readonly'.
if (ABIConverter.isShadowReturn())
- RAttributes &= ~(ParamAttr::ReadNone|ParamAttr::ReadOnly);
+ RAttributes &= ~(Attribute::ReadNone|Attribute::ReadOnly);
// Demote 'readnone' nested functions to 'readonly' since
// they may need to read through the static chain.
- if (static_chain && (RAttributes & ParamAttr::ReadNone)) {
- RAttributes &= ~ParamAttr::ReadNone;
- RAttributes |= ParamAttr::ReadOnly;
+ if (static_chain && (RAttributes & Attribute::ReadNone)) {
+ RAttributes &= ~Attribute::ReadNone;
+ RAttributes |= Attribute::ReadOnly;
}
// Compute whether the result needs to be zext or sext'd.
RAttributes |= HandleArgumentExtension(TREE_TYPE(type));
- if (RAttributes != ParamAttr::None)
- Attrs.push_back(FnAttributeWithIndex::get(0, RAttributes));
+ if (RAttributes != Attribute::None)
+ Attrs.push_back(AttributeWithIndex::get(0, RAttributes));
// If this function returns via a shadow argument, the dest loc is passed
// in as a pointer. Mark that pointer as struct-ret and noalias.
if (ABIConverter.isShadowReturn())
- Attrs.push_back(FnAttributeWithIndex::get(ArgTypes.size(),
- ParamAttr::StructRet | ParamAttr::NoAlias));
+ Attrs.push_back(AttributeWithIndex::get(ArgTypes.size(),
+ Attribute::StructRet | Attribute::NoAlias));
std::vector<const Type*> ScalarArgs;
if (static_chain) {
// Pass the static chain as the first parameter.
ABIConverter.HandleArgument(TREE_TYPE(static_chain), ScalarArgs);
// Mark it as the chain argument.
- Attrs.push_back(FnAttributeWithIndex::get(ArgTypes.size(),
- ParamAttr::Nest));
+ Attrs.push_back(AttributeWithIndex::get(ArgTypes.size(),
+ Attribute::Nest));
}
// If the target has regparam parameters, allow it to inspect the function
@@ -1211,12 +1211,12 @@
}
// Determine if there are any attributes for this param.
- Attributes Attributes = ParamAttr::None;
+ Attributes PAttributes = Attribute::None;
- ABIConverter.HandleArgument(ArgTy, ScalarArgs, &Attributes);
+ ABIConverter.HandleArgument(ArgTy, ScalarArgs, &PAttributes);
// Compute zext/sext attributes.
- Attributes |= HandleArgumentExtension(ArgTy);
+ PAttributes |= HandleArgumentExtension(ArgTy);
// Compute noalias attributes. If we have a decl for the function
// inspect it for restrict qualifiers, otherwise try the argument
@@ -1226,21 +1226,21 @@
TREE_CODE(RestrictArgTy) == REFERENCE_TYPE ||
TREE_CODE(RestrictArgTy) == BLOCK_POINTER_TYPE) {
if (TYPE_RESTRICT(RestrictArgTy))
- Attributes |= ParamAttr::NoAlias;
+ PAttributes |= Attribute::NoAlias;
}
#ifdef LLVM_TARGET_ENABLE_REGPARM
// Allow the target to mark this as inreg.
if (TREE_CODE(ArgTy) == INTEGER_TYPE || TREE_CODE(ArgTy) == POINTER_TYPE ||
TREE_CODE(ArgTy) == REAL_TYPE)
- LLVM_ADJUST_REGPARM_ATTRIBUTE(Attributes, ArgTy,
+ LLVM_ADJUST_REGPARM_ATTRIBUTE(PAttributes, ArgTy,
TREE_INT_CST_LOW(TYPE_SIZE(ArgTy)),
local_regparam, local_fp_regparam);
#endif // LLVM_TARGET_ENABLE_REGPARM
- if (Attributes != ParamAttr::None) {
- HasByVal |= Attributes & ParamAttr::ByVal;
- Attrs.push_back(FnAttributeWithIndex::get(ArgTypes.size(), Attributes));
+ if (PAttributes != Attribute::None) {
+ HasByVal |= PAttributes & Attribute::ByVal;
+ Attrs.push_back(AttributeWithIndex::get(ArgTypes.size(), PAttributes));
}
if (DeclArgs)
@@ -1254,8 +1254,8 @@
// readonly/readnone functions.
if (HasByVal && Attrs[0].Index == 0) {
Attributes &RAttrs = Attrs[0].Attrs;
- RAttrs &= ~(ParamAttr::ReadNone | ParamAttr::ReadOnly);
- if (RAttrs == ParamAttr::None)
+ RAttrs &= ~(Attribute::ReadNone | Attribute::ReadOnly);
+ if (RAttrs == Attribute::None)
Attrs.erase(Attrs.begin());
}
@@ -1264,7 +1264,7 @@
assert(RetTy && "Return type not specified!");
// Finally, make the function type and result attributes.
- PAL = PAListPtr::get(Attrs.begin(), Attrs.end());
+ PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
return GetFunctionType(RetTy, ArgTypes, isVarArg);
}
More information about the llvm-commits
mailing list