// optional leading prefixes, the production is:
// GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
// OptionalAddrSpace ('constant'|'global') ...
+ case lltok::kw_private: // OptionalLinkage
case lltok::kw_internal: // OptionalLinkage
case lltok::kw_weak: // OptionalLinkage
case lltok::kw_linkonce: // OptionalLinkage
IsConstant = true;
else if (Lex.getKind() == lltok::kw_global)
IsConstant = false;
- else
+ else {
+ IsConstant = false;
return TokError("expected 'global' or 'constant'");
+ }
Lex.Lex();
return false;
}
if (Linkage != GlobalValue::ExternalLinkage &&
Linkage != GlobalValue::WeakLinkage &&
- Linkage != GlobalValue::InternalLinkage)
+ Linkage != GlobalValue::InternalLinkage &&
+ Linkage != GlobalValue::PrivateLinkage)
return Error(LinkageLoc, "invalid linkage type for alias");
Constant *Aliasee;
return true;
}
- if (isa<FunctionType>(Ty) || Ty == Type::LabelTy)
- return Error(TyLoc, "invald type for global variable");
+ if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || Ty == Type::VoidTy)
+ return Error(TyLoc, "invalid type for global variable");
GlobalVariable *GV = 0;
// See if the global was forward referenced, if so, use the global.
- if (!Name.empty() && (GV = M->getGlobalVariable(Name, true))) {
- if (!ForwardRefVals.erase(Name))
+ if (!Name.empty()) {
+ if ((GV = M->getGlobalVariable(Name, true)) &&
+ !ForwardRefVals.erase(Name))
return Error(NameLoc, "redefinition of global '@" + Name + "'");
} else {
std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
// Otherwise, create a new forward reference for this value and remember it.
GlobalValue *FwdVal;
- if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType()))
+ if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
+ // Function types can return opaque but functions can't.
+ if (isa<OpaqueType>(FT->getReturnType())) {
+ Error(Loc, "function may not return opaque type");
+ return 0;
+ }
+
FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
- else
+ } else {
FwdVal = new GlobalVariable(PTy->getElementType(), false,
GlobalValue::ExternalWeakLinkage, 0, Name, M);
+ }
ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
return FwdVal;
if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
// Function types can return opaque but functions can't.
if (isa<OpaqueType>(FT->getReturnType())) {
- Error(Loc, "function may not return return opaque type");
+ Error(Loc, "function may not return opaque type");
return 0;
}
FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M);
/// ParseOptionalLinkage
/// ::= /*empty*/
+/// ::= 'private'
/// ::= 'internal'
/// ::= 'weak'
/// ::= 'linkonce'
HasLinkage = false;
switch (Lex.getKind()) {
default: Res = GlobalValue::ExternalLinkage; return false;
+ case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break;
case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break;
case lltok::kw_weak: Res = GlobalValue::WeakLinkage; break;
case lltok::kw_linkonce: Res = GlobalValue::LinkOnceLinkage; break;
case lltok::star:
if (Result.get() == Type::LabelTy)
return TokError("basic block pointers are invalid");
+ if (Result.get() == Type::VoidTy)
+ return TokError("pointers to void are invalid; use i8* instead");
Result = HandleUpRefs(PointerType::getUnqual(Result.get()));
Lex.Lex();
break;
case lltok::kw_addrspace: {
if (Result.get() == Type::LabelTy)
return TokError("basic block pointers are invalid");
+ if (Result.get() == Type::VoidTy)
+ return TokError("pointers to void are invalid; use i8* instead");
unsigned AddrSpace;
if (ParseOptionalAddrSpace(AddrSpace) ||
ParseToken(lltok::star, "expected '*' in address space"))
return true;
if (isVector) {
+ if (Size == 0)
+ return Error(SizeLoc, "zero element vector is illegal");
if ((unsigned)Size != Size)
return Error(SizeLoc, "size too large for vector");
if (!EltTy->isFloatingPoint() && !EltTy->isInteger())
V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc);
else if (ID.Kind == ValID::t_LocalName)
V = PFS.GetVal(ID.StrVal, Ty, ID.Loc);
- else if (ID.Kind == ValID::ValID::t_InlineAsm) {
+ else if (ID.Kind == ValID::t_InlineAsm) {
const PointerType *PTy = dyn_cast<PointerType>(Ty);
const FunctionType *FTy =
PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
if (isDefine)
return Error(LinkageLoc, "invalid linkage for function definition");
break;
+ case GlobalValue::PrivateLinkage:
case GlobalValue::InternalLinkage:
case GlobalValue::LinkOnceLinkage:
case GlobalValue::WeakLinkage:
isa<OpaqueType>(RetType))
return Error(RetTypeLoc, "invalid function return type");
- if (Lex.getKind() != lltok::GlobalVar)
+ LocTy NameLoc = Lex.getLoc();
+
+ std::string FunctionName;
+ if (Lex.getKind() == lltok::GlobalVar) {
+ FunctionName = Lex.getStrVal();
+ } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok.
+ unsigned NameID = Lex.getUIntVal();
+
+ if (NameID != NumberedVals.size())
+ return TokError("function expected to be numbered '%" +
+ utostr(NumberedVals.size()) + "'");
+ } else {
return TokError("expected function name");
+ }
- LocTy NameLoc = Lex.getLoc();
- std::string FunctionName = Lex.getStrVal();
Lex.Lex();
if (Lex.getKind() != lltok::lparen)
Value *Callee;
if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
- // Check for call to invalid intrinsic to avoid crashing later.
- if (Function *F = dyn_cast<Function>(Callee)) {
- if (F->hasName() && F->getNameLen() >= 5 &&
- !strncmp(F->getValueName()->getKeyData(), "llvm.", 5) &&
- !F->getIntrinsicID(true))
- return Error(CallLoc, "Call to invalid LLVM intrinsic function '" +
- F->getNameStr() + "'");
- }
-
// FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
// function attributes.
unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;