lib/AsmParser/LLParser.cpp

   1 //===-- LLParser.cpp - Parser Class ---------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file defines the parser class for .ll files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "LLParser.h"
  15 #include "llvm/AutoUpgrade.h"
  16 #include "llvm/CallingConv.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/DerivedTypes.h"
  19 #include "llvm/InlineAsm.h"
  20 #include "llvm/Instructions.h"
  21 #include "llvm/LLVMContext.h"
  22 #include "llvm/Metadata.h"
  23 #include "llvm/Module.h"
  24 #include "llvm/Operator.h"
  25 #include "llvm/ValueSymbolTable.h"
  26 #include "llvm/ADT/SmallPtrSet.h"
  27 #include "llvm/ADT/StringExtras.h"
  28 #include "llvm/Support/ErrorHandling.h"
  29 #include "llvm/Support/raw_ostream.h"
  30 using namespace llvm;
  31
  32 /// Run: module ::= toplevelentity*
  33 bool LLParser::Run() {
  34   // Prime the lexer.
  35   Lex.Lex();
  36
  37   return ParseTopLevelEntities() ||
  38          ValidateEndOfModule();
  39 }
  40
  41 /// ValidateEndOfModule - Do final validity and sanity checks at the end of the
  42 /// module.
  43 bool LLParser::ValidateEndOfModule() {
  44   // Update auto-upgraded malloc calls to "malloc".
  45   // FIXME: Remove in LLVM 3.0.
  46   if (MallocF) {
  47     MallocF->setName("malloc");
  48     // If setName() does not set the name to "malloc", then there is already a
  49     // declaration of "malloc".  In that case, iterate over all calls to MallocF
  50     // and get them to call the declared "malloc" instead.
  51     if (MallocF->getName() != "malloc") {
  52       Constant *RealMallocF = M->getFunction("malloc");
  53       if (RealMallocF->getType() != MallocF->getType())
  54         RealMallocF = ConstantExpr::getBitCast(RealMallocF, MallocF->getType());
  55       MallocF->replaceAllUsesWith(RealMallocF);
  56       MallocF->eraseFromParent();
  57       MallocF = NULL;
  58     }
  59   }
  60
  61
  62   // If there are entries in ForwardRefBlockAddresses at this point, they are
  63   // references after the function was defined.  Resolve those now.
  64   while (!ForwardRefBlockAddresses.empty()) {
  65     // Okay, we are referencing an already-parsed function, resolve them now.
  66     Function *TheFn = 0;
  67     const ValID &Fn = ForwardRefBlockAddresses.begin()->first;
  68     if (Fn.Kind == ValID::t_GlobalName)
  69       TheFn = M->getFunction(Fn.StrVal);
  70     else if (Fn.UIntVal < NumberedVals.size())
  71       TheFn = dyn_cast<Function>(NumberedVals[Fn.UIntVal]);
  72
  73     if (TheFn == 0)
  74       return Error(Fn.Loc, "unknown function referenced by blockaddress");
  75
  76     // Resolve all these references.
  77     if (ResolveForwardRefBlockAddresses(TheFn,
  78                                       ForwardRefBlockAddresses.begin()->second,
  79                                         0))
  80       return true;
  81
  82     ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin());
  83   }
  84
  85
  86   if (!ForwardRefTypes.empty())
  87     return Error(ForwardRefTypes.begin()->second.second,
  88                  "use of undefined type named '" +
  89                  ForwardRefTypes.begin()->first + "'");
  90   if (!ForwardRefTypeIDs.empty())
  91     return Error(ForwardRefTypeIDs.begin()->second.second,
  92                  "use of undefined type '%" +
  93                  utostr(ForwardRefTypeIDs.begin()->first) + "'");
  94
  95   if (!ForwardRefVals.empty())
  96     return Error(ForwardRefVals.begin()->second.second,
  97                  "use of undefined value '@" + ForwardRefVals.begin()->first +
  98                  "'");
  99
 100   if (!ForwardRefValIDs.empty())
 101     return Error(ForwardRefValIDs.begin()->second.second,
 102                  "use of undefined value '@" +
 103                  utostr(ForwardRefValIDs.begin()->first) + "'");
 104
 105   if (!ForwardRefMDNodes.empty())
 106     return Error(ForwardRefMDNodes.begin()->second.second,
 107                  "use of undefined metadata '!" +
 108                  utostr(ForwardRefMDNodes.begin()->first) + "'");
 109
 110
 111   // Look for intrinsic functions and CallInst that need to be upgraded
 112   for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; )
 113     UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove
 114
 115   // Check debug info intrinsics.
 116   CheckDebugInfoIntrinsics(M);
 117   return false;
 118 }
 119
 120 bool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn,
 121                              std::vector<std::pair<ValID, GlobalValue*> > &Refs,
 122                                                PerFunctionState *PFS) {
 123   // Loop over all the references, resolving them.
 124   for (unsigned i = 0, e = Refs.size(); i != e; ++i) {
 125     BasicBlock *Res;
 126     if (PFS) {
 127       if (Refs[i].first.Kind == ValID::t_LocalName)
 128         Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc);
 129       else
 130         Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc);
 131     } else if (Refs[i].first.Kind == ValID::t_LocalID) {
 132       return Error(Refs[i].first.Loc,
 133        "cannot take address of numeric label after the function is defined");
 134     } else {
 135       Res = dyn_cast_or_null<BasicBlock>(
 136                      TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal));
 137     }
 138
 139     if (Res == 0)
 140       return Error(Refs[i].first.Loc,
 141                    "referenced value is not a basic block");
 142
 143     // Get the BlockAddress for this and update references to use it.
 144     BlockAddress *BA = BlockAddress::get(TheFn, Res);
 145     Refs[i].second->replaceAllUsesWith(BA);
 146     Refs[i].second->eraseFromParent();
 147   }
 148   return false;
 149 }
 150
 151
 152 //===----------------------------------------------------------------------===//
 153 // Top-Level Entities
 154 //===----------------------------------------------------------------------===//
 155
 156 bool LLParser::ParseTopLevelEntities() {
 157   while (1) {
 158     switch (Lex.getKind()) {
 159     default:         return TokError("expected top-level entity");
 160     case lltok::Eof: return false;
 161     //case lltok::kw_define:
 162     case lltok::kw_declare: if (ParseDeclare()) return true; break;
 163     case lltok::kw_define:  if (ParseDefine()) return true; break;
 164     case lltok::kw_module:  if (ParseModuleAsm()) return true; break;
 165     case lltok::kw_target:  if (ParseTargetDefinition()) return true; break;
 166     case lltok::kw_deplibs: if (ParseDepLibs()) return true; break;
 167     case lltok::kw_type:    if (ParseUnnamedType()) return true; break;
 168     case lltok::LocalVarID: if (ParseUnnamedType()) return true; break;
 169     case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0
 170     case lltok::LocalVar:   if (ParseNamedType()) return true; break;
 171     case lltok::GlobalID:   if (ParseUnnamedGlobal()) return true; break;
 172     case lltok::GlobalVar:  if (ParseNamedGlobal()) return true; break;
 173     case lltok::Metadata:   if (ParseStandaloneMetadata()) return true; break;
 174     case lltok::NamedOrCustomMD: if (ParseNamedMetadata()) return true; break;
 175
 176     // The Global variable production with no name can have many different
 177     // optional leading prefixes, the production is:
 178     // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
 179     //               OptionalAddrSpace ('constant'|'global') ...
 180     case lltok::kw_private :       // OptionalLinkage
 181     case lltok::kw_linker_private: // OptionalLinkage
 182     case lltok::kw_internal:       // OptionalLinkage
 183     case lltok::kw_weak:           // OptionalLinkage
 184     case lltok::kw_weak_odr:       // OptionalLinkage
 185     case lltok::kw_linkonce:       // OptionalLinkage
 186     case lltok::kw_linkonce_odr:   // OptionalLinkage
 187     case lltok::kw_appending:      // OptionalLinkage
 188     case lltok::kw_dllexport:      // OptionalLinkage
 189     case lltok::kw_common:         // OptionalLinkage
 190     case lltok::kw_dllimport:      // OptionalLinkage
 191     case lltok::kw_extern_weak:    // OptionalLinkage
 192     case lltok::kw_external: {     // OptionalLinkage
 193       unsigned Linkage, Visibility;
 194       if (ParseOptionalLinkage(Linkage) ||
 195           ParseOptionalVisibility(Visibility) ||
 196           ParseGlobal("", SMLoc(), Linkage, true, Visibility))
 197         return true;
 198       break;
 199     }
 200     case lltok::kw_default:       // OptionalVisibility
 201     case lltok::kw_hidden:        // OptionalVisibility
 202     case lltok::kw_protected: {   // OptionalVisibility
 203       unsigned Visibility;
 204       if (ParseOptionalVisibility(Visibility) ||
 205           ParseGlobal("", SMLoc(), 0, false, Visibility))
 206         return true;
 207       break;
 208     }
 209
 210     case lltok::kw_thread_local:  // OptionalThreadLocal
 211     case lltok::kw_addrspace:     // OptionalAddrSpace
 212     case lltok::kw_constant:      // GlobalType
 213     case lltok::kw_global:        // GlobalType
 214       if (ParseGlobal("", SMLoc(), 0, false, 0)) return true;
 215       break;
 216     }
 217   }
 218 }
 219
 220
 221 /// toplevelentity
 222 ///   ::= 'module' 'asm' STRINGCONSTANT
 223 bool LLParser::ParseModuleAsm() {
 224   assert(Lex.getKind() == lltok::kw_module);
 225   Lex.Lex();
 226
 227   std::string AsmStr;
 228   if (ParseToken(lltok::kw_asm, "expected 'module asm'") ||
 229       ParseStringConstant(AsmStr)) return true;
 230
 231   const std::string &AsmSoFar = M->getModuleInlineAsm();
 232   if (AsmSoFar.empty())
 233     M->setModuleInlineAsm(AsmStr);
 234   else
 235     M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr);
 236   return false;
 237 }
 238
 239 /// toplevelentity
 240 ///   ::= 'target' 'triple' '=' STRINGCONSTANT
 241 ///   ::= 'target' 'datalayout' '=' STRINGCONSTANT
 242 bool LLParser::ParseTargetDefinition() {
 243   assert(Lex.getKind() == lltok::kw_target);
 244   std::string Str;
 245   switch (Lex.Lex()) {
 246   default: return TokError("unknown target property");
 247   case lltok::kw_triple:
 248     Lex.Lex();
 249     if (ParseToken(lltok::equal, "expected '=' after target triple") ||
 250         ParseStringConstant(Str))
 251       return true;
 252     M->setTargetTriple(Str);
 253     return false;
 254   case lltok::kw_datalayout:
 255     Lex.Lex();
 256     if (ParseToken(lltok::equal, "expected '=' after target datalayout") ||
 257         ParseStringConstant(Str))
 258       return true;
 259     M->setDataLayout(Str);
 260     return false;
 261   }
 262 }
 263
 264 /// toplevelentity
 265 ///   ::= 'deplibs' '=' '[' ']'
 266 ///   ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']'
 267 bool LLParser::ParseDepLibs() {
 268   assert(Lex.getKind() == lltok::kw_deplibs);
 269   Lex.Lex();
 270   if (ParseToken(lltok::equal, "expected '=' after deplibs") ||
 271       ParseToken(lltok::lsquare, "expected '=' after deplibs"))
 272     return true;
 273
 274   if (EatIfPresent(lltok::rsquare))
 275     return false;
 276
 277   std::string Str;
 278   if (ParseStringConstant(Str)) return true;
 279   M->addLibrary(Str);
 280
 281   while (EatIfPresent(lltok::comma)) {
 282     if (ParseStringConstant(Str)) return true;
 283     M->addLibrary(Str);
 284   }
 285
 286   return ParseToken(lltok::rsquare, "expected ']' at end of list");
 287 }
 288
 289 /// ParseUnnamedType:
 290 ///   ::= 'type' type
 291 ///   ::= LocalVarID '=' 'type' type
 292 bool LLParser::ParseUnnamedType() {
 293   unsigned TypeID = NumberedTypes.size();
 294
 295   // Handle the LocalVarID form.
 296   if (Lex.getKind() == lltok::LocalVarID) {
 297     if (Lex.getUIntVal() != TypeID)
 298       return Error(Lex.getLoc(), "type expected to be numbered '%" +
 299                    utostr(TypeID) + "'");
 300     Lex.Lex(); // eat LocalVarID;
 301
 302     if (ParseToken(lltok::equal, "expected '=' after name"))
 303       return true;
 304   }
 305
 306   assert(Lex.getKind() == lltok::kw_type);
 307   LocTy TypeLoc = Lex.getLoc();
 308   Lex.Lex(); // eat kw_type
 309
 310   PATypeHolder Ty(Type::getVoidTy(Context));
 311   if (ParseType(Ty)) return true;
 312
 313   // See if this type was previously referenced.
 314   std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator
 315     FI = ForwardRefTypeIDs.find(TypeID);
 316   if (FI != ForwardRefTypeIDs.end()) {
 317     if (FI->second.first.get() == Ty)
 318       return Error(TypeLoc, "self referential type is invalid");
 319
 320     cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty);
 321     Ty = FI->second.first.get();
 322     ForwardRefTypeIDs.erase(FI);
 323   }
 324
 325   NumberedTypes.push_back(Ty);
 326
 327   return false;
 328 }
 329
 330 /// toplevelentity
 331 ///   ::= LocalVar '=' 'type' type
 332 bool LLParser::ParseNamedType() {
 333   std::string Name = Lex.getStrVal();
 334   LocTy NameLoc = Lex.getLoc();
 335   Lex.Lex();  // eat LocalVar.
 336
 337   PATypeHolder Ty(Type::getVoidTy(Context));
 338
 339   if (ParseToken(lltok::equal, "expected '=' after name") ||
 340       ParseToken(lltok::kw_type, "expected 'type' after name") ||
 341       ParseType(Ty))
 342     return true;
 343
 344   // Set the type name, checking for conflicts as we do so.
 345   bool AlreadyExists = M->addTypeName(Name, Ty);
 346   if (!AlreadyExists) return false;
 347
 348   // See if this type is a forward reference.  We need to eagerly resolve
 349   // types to allow recursive type redefinitions below.
 350   std::map<std::string, std::pair<PATypeHolder, LocTy> >::iterator
 351   FI = ForwardRefTypes.find(Name);
 352   if (FI != ForwardRefTypes.end()) {
 353     if (FI->second.first.get() == Ty)
 354       return Error(NameLoc, "self referential type is invalid");
 355
 356     cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty);
 357     Ty = FI->second.first.get();
 358     ForwardRefTypes.erase(FI);
 359   }
 360
 361   // Inserting a name that is already defined, get the existing name.
 362   const Type *Existing = M->getTypeByName(Name);
 363   assert(Existing && "Conflict but no matching type?!");
 364
 365   // Otherwise, this is an attempt to redefine a type. That's okay if
 366   // the redefinition is identical to the original.
 367   // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0
 368   if (Existing == Ty) return false;
 369
 370   // Any other kind of (non-equivalent) redefinition is an error.
 371   return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" +
 372                Ty->getDescription() + "'");
 373 }
 374
 375
 376 /// toplevelentity
 377 ///   ::= 'declare' FunctionHeader
 378 bool LLParser::ParseDeclare() {
 379   assert(Lex.getKind() == lltok::kw_declare);
 380   Lex.Lex();
 381
 382   Function *F;
 383   return ParseFunctionHeader(F, false);
 384 }
 385
 386 /// toplevelentity
 387 ///   ::= 'define' FunctionHeader '{' ...
 388 bool LLParser::ParseDefine() {
 389   assert(Lex.getKind() == lltok::kw_define);
 390   Lex.Lex();
 391
 392   Function *F;
 393   return ParseFunctionHeader(F, true) ||
 394          ParseFunctionBody(*F);
 395 }
 396
 397 /// ParseGlobalType
 398 ///   ::= 'constant'
 399 ///   ::= 'global'
 400 bool LLParser::ParseGlobalType(bool &IsConstant) {
 401   if (Lex.getKind() == lltok::kw_constant)
 402     IsConstant = true;
 403   else if (Lex.getKind() == lltok::kw_global)
 404     IsConstant = false;
 405   else {
 406     IsConstant = false;
 407     return TokError("expected 'global' or 'constant'");
 408   }
 409   Lex.Lex();
 410   return false;
 411 }
 412
 413 /// ParseUnnamedGlobal:
 414 ///   OptionalVisibility ALIAS ...
 415 ///   OptionalLinkage OptionalVisibility ...   -> global variable
 416 ///   GlobalID '=' OptionalVisibility ALIAS ...
 417 ///   GlobalID '=' OptionalLinkage OptionalVisibility ...   -> global variable
 418 bool LLParser::ParseUnnamedGlobal() {
 419   unsigned VarID = NumberedVals.size();
 420   std::string Name;
 421   LocTy NameLoc = Lex.getLoc();
 422
 423   // Handle the GlobalID form.
 424   if (Lex.getKind() == lltok::GlobalID) {
 425     if (Lex.getUIntVal() != VarID)
 426       return Error(Lex.getLoc(), "variable expected to be numbered '%" +
 427                    utostr(VarID) + "'");
 428     Lex.Lex(); // eat GlobalID;
 429
 430     if (ParseToken(lltok::equal, "expected '=' after name"))
 431       return true;
 432   }
 433
 434   bool HasLinkage;
 435   unsigned Linkage, Visibility;
 436   if (ParseOptionalLinkage(Linkage, HasLinkage) ||
 437       ParseOptionalVisibility(Visibility))
 438     return true;
 439
 440   if (HasLinkage || Lex.getKind() != lltok::kw_alias)
 441     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
 442   return ParseAlias(Name, NameLoc, Visibility);
 443 }
 444
 445 /// ParseNamedGlobal:
 446 ///   GlobalVar '=' OptionalVisibility ALIAS ...
 447 ///   GlobalVar '=' OptionalLinkage OptionalVisibility ...   -> global variable
 448 bool LLParser::ParseNamedGlobal() {
 449   assert(Lex.getKind() == lltok::GlobalVar);
 450   LocTy NameLoc = Lex.getLoc();
 451   std::string Name = Lex.getStrVal();
 452   Lex.Lex();
 453
 454   bool HasLinkage;
 455   unsigned Linkage, Visibility;
 456   if (ParseToken(lltok::equal, "expected '=' in global variable") ||
 457       ParseOptionalLinkage(Linkage, HasLinkage) ||
 458       ParseOptionalVisibility(Visibility))
 459     return true;
 460
 461   if (HasLinkage || Lex.getKind() != lltok::kw_alias)
 462     return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility);
 463   return ParseAlias(Name, NameLoc, Visibility);
 464 }
 465
 466 // MDString:
 467 //   ::= '!' STRINGCONSTANT
 468 bool LLParser::ParseMDString(MetadataBase *&MDS) {
 469   std::string Str;
 470   if (ParseStringConstant(Str)) return true;
 471   MDS = MDString::get(Context, Str);
 472   return false;
 473 }
 474
 475 // MDNode:
 476 //   ::= '!' MDNodeNumber
 477 bool LLParser::ParseMDNode(MetadataBase *&Node) {
 478   // !{ ..., !42, ... }
 479   unsigned MID = 0;
 480   if (ParseUInt32(MID))  return true;
 481
 482   // Check existing MDNode.
 483   std::map<unsigned, WeakVH>::iterator I = MetadataCache.find(MID);
 484   if (I != MetadataCache.end()) {
 485     Node = cast<MetadataBase>(I->second);
 486     return false;
 487   }
 488
 489   // Check known forward references.
 490   std::map<unsigned, std::pair<WeakVH, LocTy> >::iterator
 491     FI = ForwardRefMDNodes.find(MID);
 492   if (FI != ForwardRefMDNodes.end()) {
 493     Node = cast<MetadataBase>(FI->second.first);
 494     return false;
 495   }
 496
 497   // Create MDNode forward reference
 498   SmallVector<Value *, 1> Elts;
 499   std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID);
 500   Elts.push_back(MDString::get(Context, FwdRefName));
 501   MDNode *FwdNode = MDNode::get(Context, Elts.data(), Elts.size());
 502   ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc());
 503   Node = FwdNode;
 504   return false;
 505 }
 506
 507 ///ParseNamedMetadata:
 508 ///   !foo = !{ !1, !2 }
 509 bool LLParser::ParseNamedMetadata() {
 510   assert(Lex.getKind() == lltok::NamedOrCustomMD);
 511   Lex.Lex();
 512   std::string Name = Lex.getStrVal();
 513
 514   if (ParseToken(lltok::equal, "expected '=' here"))
 515     return true;
 516
 517   if (Lex.getKind() != lltok::Metadata)
 518     return TokError("Expected '!' here");
 519   Lex.Lex();
 520
 521   if (Lex.getKind() != lltok::lbrace)
 522     return TokError("Expected '{' here");
 523   Lex.Lex();
 524   SmallVector<MetadataBase *, 8> Elts;
 525   do {
 526     if (Lex.getKind() != lltok::Metadata)
 527       return TokError("Expected '!' here");
 528     Lex.Lex();
 529     MetadataBase *N = 0;
 530     if (ParseMDNode(N)) return true;
 531     Elts.push_back(N);
 532   } while (EatIfPresent(lltok::comma));
 533
 534   if (ParseToken(lltok::rbrace, "expected end of metadata node"))
 535     return true;
 536
 537   NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M);
 538   return false;
 539 }
 540
 541 /// ParseStandaloneMetadata:
 542 ///   !42 = !{...}
 543 bool LLParser::ParseStandaloneMetadata() {
 544   assert(Lex.getKind() == lltok::Metadata);
 545   Lex.Lex();
 546   unsigned MetadataID = 0;
 547   if (ParseUInt32(MetadataID))
 548     return true;
 549   if (MetadataCache.find(MetadataID) != MetadataCache.end())
 550     return TokError("Metadata id is already used");
 551   if (ParseToken(lltok::equal, "expected '=' here"))
 552     return true;
 553
 554   LocTy TyLoc;
 555   PATypeHolder Ty(Type::getVoidTy(Context));
 556   if (ParseType(Ty, TyLoc))
 557     return true;
 558
 559   if (Lex.getKind() != lltok::Metadata)
 560     return TokError("Expected metadata here");
 561
 562   Lex.Lex();
 563   if (Lex.getKind() != lltok::lbrace)
 564     return TokError("Expected '{' here");
 565
 566   SmallVector<Value *, 16> Elts;
 567   if (ParseMDNodeVector(Elts)
 568       || ParseToken(lltok::rbrace, "expected end of metadata node"))
 569     return true;
 570
 571   MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size());
 572   MetadataCache[MetadataID] = Init;
 573   std::map<unsigned, std::pair<WeakVH, LocTy> >::iterator
 574     FI = ForwardRefMDNodes.find(MetadataID);
 575   if (FI != ForwardRefMDNodes.end()) {
 576     MDNode *FwdNode = cast<MDNode>(FI->second.first);
 577     FwdNode->replaceAllUsesWith(Init);
 578     ForwardRefMDNodes.erase(FI);
 579   }
 580
 581   return false;
 582 }
 583
 584 /// ParseAlias:
 585 ///   ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee
 586 /// Aliasee
 587 ///   ::= TypeAndValue
 588 ///   ::= 'bitcast' '(' TypeAndValue 'to' Type ')'
 589 ///   ::= 'getelementptr' 'inbounds'? '(' ... ')'
 590 ///
 591 /// Everything through visibility has already been parsed.
 592 ///
 593 bool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc,
 594                           unsigned Visibility) {
 595   assert(Lex.getKind() == lltok::kw_alias);
 596   Lex.Lex();
 597   unsigned Linkage;
 598   LocTy LinkageLoc = Lex.getLoc();
 599   if (ParseOptionalLinkage(Linkage))
 600     return true;
 601
 602   if (Linkage != GlobalValue::ExternalLinkage &&
 603       Linkage != GlobalValue::WeakAnyLinkage &&
 604       Linkage != GlobalValue::WeakODRLinkage &&
 605       Linkage != GlobalValue::InternalLinkage &&
 606       Linkage != GlobalValue::PrivateLinkage &&
 607       Linkage != GlobalValue::LinkerPrivateLinkage)
 608     return Error(LinkageLoc, "invalid linkage type for alias");
 609
 610   Constant *Aliasee;
 611   LocTy AliaseeLoc = Lex.getLoc();
 612   if (Lex.getKind() != lltok::kw_bitcast &&
 613       Lex.getKind() != lltok::kw_getelementptr) {
 614     if (ParseGlobalTypeAndValue(Aliasee)) return true;
 615   } else {
 616     // The bitcast dest type is not present, it is implied by the dest type.
 617     ValID ID;
 618     if (ParseValID(ID)) return true;
 619     if (ID.Kind != ValID::t_Constant)
 620       return Error(AliaseeLoc, "invalid aliasee");
 621     Aliasee = ID.ConstantVal;
 622   }
 623
 624   if (!isa<PointerType>(Aliasee->getType()))
 625     return Error(AliaseeLoc, "alias must have pointer type");
 626
 627   // Okay, create the alias but do not insert it into the module yet.
 628   GlobalAlias* GA = new GlobalAlias(Aliasee->getType(),
 629                                     (GlobalValue::LinkageTypes)Linkage, Name,
 630                                     Aliasee);
 631   GA->setVisibility((GlobalValue::VisibilityTypes)Visibility);
 632
 633   // See if this value already exists in the symbol table.  If so, it is either
 634   // a redefinition or a definition of a forward reference.
 635   if (GlobalValue *Val = M->getNamedValue(Name)) {
 636     // See if this was a redefinition.  If so, there is no entry in
 637     // ForwardRefVals.
 638     std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
 639       I = ForwardRefVals.find(Name);
 640     if (I == ForwardRefVals.end())
 641       return Error(NameLoc, "redefinition of global named '@" + Name + "'");
 642
 643     // Otherwise, this was a definition of forward ref.  Verify that types
 644     // agree.
 645     if (Val->getType() != GA->getType())
 646       return Error(NameLoc,
 647               "forward reference and definition of alias have different types");
 648
 649     // If they agree, just RAUW the old value with the alias and remove the
 650     // forward ref info.
 651     Val->replaceAllUsesWith(GA);
 652     Val->eraseFromParent();
 653     ForwardRefVals.erase(I);
 654   }
 655
 656   // Insert into the module, we know its name won't collide now.
 657   M->getAliasList().push_back(GA);
 658   assert(GA->getNameStr() == Name && "Should not be a name conflict!");
 659
 660   return false;
 661 }
 662
 663 /// ParseGlobal
 664 ///   ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal
 665 ///       OptionalAddrSpace GlobalType Type Const
 666 ///   ::= OptionalLinkage OptionalVisibility OptionalThreadLocal
 667 ///       OptionalAddrSpace GlobalType Type Const
 668 ///
 669 /// Everything through visibility has been parsed already.
 670 ///
 671 bool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc,
 672                            unsigned Linkage, bool HasLinkage,
 673                            unsigned Visibility) {
 674   unsigned AddrSpace;
 675   bool ThreadLocal, IsConstant;
 676   LocTy TyLoc;
 677
 678   PATypeHolder Ty(Type::getVoidTy(Context));
 679   if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) ||
 680       ParseOptionalAddrSpace(AddrSpace) ||
 681       ParseGlobalType(IsConstant) ||
 682       ParseType(Ty, TyLoc))
 683     return true;
 684
 685   // If the linkage is specified and is external, then no initializer is
 686   // present.
 687   Constant *Init = 0;
 688   if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage &&
 689                       Linkage != GlobalValue::ExternalWeakLinkage &&
 690                       Linkage != GlobalValue::ExternalLinkage)) {
 691     if (ParseGlobalValue(Ty, Init))
 692       return true;
 693   }
 694
 695   if (isa<FunctionType>(Ty) || Ty->isLabelTy())
 696     return Error(TyLoc, "invalid type for global variable");
 697
 698   GlobalVariable *GV = 0;
 699
 700   // See if the global was forward referenced, if so, use the global.
 701   if (!Name.empty()) {
 702     if (GlobalValue *GVal = M->getNamedValue(Name)) {
 703       if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal))
 704         return Error(NameLoc, "redefinition of global '@" + Name + "'");
 705       GV = cast<GlobalVariable>(GVal);
 706     }
 707   } else {
 708     std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
 709       I = ForwardRefValIDs.find(NumberedVals.size());
 710     if (I != ForwardRefValIDs.end()) {
 711       GV = cast<GlobalVariable>(I->second.first);
 712       ForwardRefValIDs.erase(I);
 713     }
 714   }
 715
 716   if (GV == 0) {
 717     GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0,
 718                             Name, 0, false, AddrSpace);
 719   } else {
 720     if (GV->getType()->getElementType() != Ty)
 721       return Error(TyLoc,
 722             "forward reference and definition of global have different types");
 723
 724     // Move the forward-reference to the correct spot in the module.
 725     M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV);
 726   }
 727
 728   if (Name.empty())
 729     NumberedVals.push_back(GV);
 730
 731   // Set the parsed properties on the global.
 732   if (Init)
 733     GV->setInitializer(Init);
 734   GV->setConstant(IsConstant);
 735   GV->setLinkage((GlobalValue::LinkageTypes)Linkage);
 736   GV->setVisibility((GlobalValue::VisibilityTypes)Visibility);
 737   GV->setThreadLocal(ThreadLocal);
 738
 739   // Parse attributes on the global.
 740   while (Lex.getKind() == lltok::comma) {
 741     Lex.Lex();
 742
 743     if (Lex.getKind() == lltok::kw_section) {
 744       Lex.Lex();
 745       GV->setSection(Lex.getStrVal());
 746       if (ParseToken(lltok::StringConstant, "expected global section string"))
 747         return true;
 748     } else if (Lex.getKind() == lltok::kw_align) {
 749       unsigned Alignment;
 750       if (ParseOptionalAlignment(Alignment)) return true;
 751       GV->setAlignment(Alignment);
 752     } else {
 753       TokError("unknown global variable property!");
 754     }
 755   }
 756
 757   return false;
 758 }
 759
 760
 761 //===----------------------------------------------------------------------===//
 762 // GlobalValue Reference/Resolution Routines.
 763 //===----------------------------------------------------------------------===//
 764
 765 /// GetGlobalVal - Get a value with the specified name or ID, creating a
 766 /// forward reference record if needed.  This can return null if the value
 767 /// exists but does not have the right type.
 768 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty,
 769                                     LocTy Loc) {
 770   const PointerType *PTy = dyn_cast<PointerType>(Ty);
 771   if (PTy == 0) {
 772     Error(Loc, "global variable reference must have pointer type");
 773     return 0;
 774   }
 775
 776   // Look this name up in the normal function symbol table.
 777   GlobalValue *Val =
 778     cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name));
 779
 780   // If this is a forward reference for the value, see if we already created a
 781   // forward ref record.
 782   if (Val == 0) {
 783     std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator
 784       I = ForwardRefVals.find(Name);
 785     if (I != ForwardRefVals.end())
 786       Val = I->second.first;
 787   }
 788
 789   // If we have the value in the symbol table or fwd-ref table, return it.
 790   if (Val) {
 791     if (Val->getType() == Ty) return Val;
 792     Error(Loc, "'@" + Name + "' defined with type '" +
 793           Val->getType()->getDescription() + "'");
 794     return 0;
 795   }
 796
 797   // Otherwise, create a new forward reference for this value and remember it.
 798   GlobalValue *FwdVal;
 799   if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
 800     // Function types can return opaque but functions can't.
 801     if (isa<OpaqueType>(FT->getReturnType())) {
 802       Error(Loc, "function may not return opaque type");
 803       return 0;
 804     }
 805
 806     FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
 807   } else {
 808     FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
 809                                 GlobalValue::ExternalWeakLinkage, 0, Name);
 810   }
 811
 812   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
 813   return FwdVal;
 814 }
 815
 816 GlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) {
 817   const PointerType *PTy = dyn_cast<PointerType>(Ty);
 818   if (PTy == 0) {
 819     Error(Loc, "global variable reference must have pointer type");
 820     return 0;
 821   }
 822
 823   GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
 824
 825   // If this is a forward reference for the value, see if we already created a
 826   // forward ref record.
 827   if (Val == 0) {
 828     std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator
 829       I = ForwardRefValIDs.find(ID);
 830     if (I != ForwardRefValIDs.end())
 831       Val = I->second.first;
 832   }
 833
 834   // If we have the value in the symbol table or fwd-ref table, return it.
 835   if (Val) {
 836     if (Val->getType() == Ty) return Val;
 837     Error(Loc, "'@" + utostr(ID) + "' defined with type '" +
 838           Val->getType()->getDescription() + "'");
 839     return 0;
 840   }
 841
 842   // Otherwise, create a new forward reference for this value and remember it.
 843   GlobalValue *FwdVal;
 844   if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) {
 845     // Function types can return opaque but functions can't.
 846     if (isa<OpaqueType>(FT->getReturnType())) {
 847       Error(Loc, "function may not return opaque type");
 848       return 0;
 849     }
 850     FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M);
 851   } else {
 852     FwdVal = new GlobalVariable(*M, PTy->getElementType(), false,
 853                                 GlobalValue::ExternalWeakLinkage, 0, "");
 854   }
 855
 856   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
 857   return FwdVal;
 858 }
 859
 860
 861 //===----------------------------------------------------------------------===//
 862 // Helper Routines.
 863 //===----------------------------------------------------------------------===//
 864
 865 /// ParseToken - If the current token has the specified kind, eat it and return
 866 /// success.  Otherwise, emit the specified error and return failure.
 867 bool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) {
 868   if (Lex.getKind() != T)
 869     return TokError(ErrMsg);
 870   Lex.Lex();
 871   return false;
 872 }
 873
 874 /// ParseStringConstant
 875 ///   ::= StringConstant
 876 bool LLParser::ParseStringConstant(std::string &Result) {
 877   if (Lex.getKind() != lltok::StringConstant)
 878     return TokError("expected string constant");
 879   Result = Lex.getStrVal();
 880   Lex.Lex();
 881   return false;
 882 }
 883
 884 /// ParseUInt32
 885 ///   ::= uint32
 886 bool LLParser::ParseUInt32(unsigned &Val) {
 887   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned())
 888     return TokError("expected integer");
 889   uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1);
 890   if (Val64 != unsigned(Val64))
 891     return TokError("expected 32-bit integer (too large)");
 892   Val = Val64;
 893   Lex.Lex();
 894   return false;
 895 }
 896
 897
 898 /// ParseOptionalAddrSpace
 899 ///   := /*empty*/
 900 ///   := 'addrspace' '(' uint32 ')'
 901 bool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) {
 902   AddrSpace = 0;
 903   if (!EatIfPresent(lltok::kw_addrspace))
 904     return false;
 905   return ParseToken(lltok::lparen, "expected '(' in address space") ||
 906          ParseUInt32(AddrSpace) ||
 907          ParseToken(lltok::rparen, "expected ')' in address space");
 908 }
 909
 910 /// ParseOptionalAttrs - Parse a potentially empty attribute list.  AttrKind
 911 /// indicates what kind of attribute list this is: 0: function arg, 1: result,
 912 /// 2: function attr.
 913 /// 3: function arg after value: FIXME: REMOVE IN LLVM 3.0
 914 bool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) {
 915   Attrs = Attribute::None;
 916   LocTy AttrLoc = Lex.getLoc();
 917
 918   while (1) {
 919     switch (Lex.getKind()) {
 920     case lltok::kw_sext:
 921     case lltok::kw_zext:
 922       // Treat these as signext/zeroext if they occur in the argument list after
 923       // the value, as in "call i8 @foo(i8 10 sext)".  If they occur before the
 924       // value, as in "call i8 @foo(i8 sext (" then it is part of a constant
 925       // expr.
 926       // FIXME: REMOVE THIS IN LLVM 3.0
 927       if (AttrKind == 3) {
 928         if (Lex.getKind() == lltok::kw_sext)
 929           Attrs |= Attribute::SExt;
 930         else
 931           Attrs |= Attribute::ZExt;
 932         break;
 933       }
 934       // FALL THROUGH.
 935     default:  // End of attributes.
 936       if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly))
 937         return Error(AttrLoc, "invalid use of function-only attribute");
 938
 939       if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly))
 940         return Error(AttrLoc, "invalid use of parameter-only attribute");
 941
 942       return false;
 943     case lltok::kw_zeroext:         Attrs |= Attribute::ZExt; break;
 944     case lltok::kw_signext:         Attrs |= Attribute::SExt; break;
 945     case lltok::kw_inreg:           Attrs |= Attribute::InReg; break;
 946     case lltok::kw_sret:            Attrs |= Attribute::StructRet; break;
 947     case lltok::kw_noalias:         Attrs |= Attribute::NoAlias; break;
 948     case lltok::kw_nocapture:       Attrs |= Attribute::NoCapture; break;
 949     case lltok::kw_byval:           Attrs |= Attribute::ByVal; break;
 950     case lltok::kw_nest:            Attrs |= Attribute::Nest; break;
 951
 952     case lltok::kw_noreturn:        Attrs |= Attribute::NoReturn; break;
 953     case lltok::kw_nounwind:        Attrs |= Attribute::NoUnwind; break;
 954     case lltok::kw_noinline:        Attrs |= Attribute::NoInline; break;
 955     case lltok::kw_readnone:        Attrs |= Attribute::ReadNone; break;
 956     case lltok::kw_readonly:        Attrs |= Attribute::ReadOnly; break;
 957     case lltok::kw_inlinehint:      Attrs |= Attribute::InlineHint; break;
 958     case lltok::kw_alwaysinline:    Attrs |= Attribute::AlwaysInline; break;
 959     case lltok::kw_optsize:         Attrs |= Attribute::OptimizeForSize; break;
 960     case lltok::kw_ssp:             Attrs |= Attribute::StackProtect; break;
 961     case lltok::kw_sspreq:          Attrs |= Attribute::StackProtectReq; break;
 962     case lltok::kw_noredzone:       Attrs |= Attribute::NoRedZone; break;
 963     case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break;
 964     case lltok::kw_naked:           Attrs |= Attribute::Naked; break;
 965
 966     case lltok::kw_align: {
 967       unsigned Alignment;
 968       if (ParseOptionalAlignment(Alignment))
 969         return true;
 970       Attrs |= Attribute::constructAlignmentFromInt(Alignment);
 971       continue;
 972     }
 973     }
 974     Lex.Lex();
 975   }
 976 }
 977
 978 /// ParseOptionalLinkage
 979 ///   ::= /*empty*/
 980 ///   ::= 'private'
 981 ///   ::= 'linker_private'
 982 ///   ::= 'internal'
 983 ///   ::= 'weak'
 984 ///   ::= 'weak_odr'
 985 ///   ::= 'linkonce'
 986 ///   ::= 'linkonce_odr'
 987 ///   ::= 'appending'
 988 ///   ::= 'dllexport'
 989 ///   ::= 'common'
 990 ///   ::= 'dllimport'
 991 ///   ::= 'extern_weak'
 992 ///   ::= 'external'
 993 bool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) {
 994   HasLinkage = false;
 995   switch (Lex.getKind()) {
 996   default:                       Res=GlobalValue::ExternalLinkage; return false;
 997   case lltok::kw_private:        Res = GlobalValue::PrivateLinkage;       break;
 998   case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break;
 999   case lltok::kw_internal:       Res = GlobalValue::InternalLinkage;      break;
1000   case lltok::kw_weak:           Res = GlobalValue::WeakAnyLinkage;       break;
1001   case lltok::kw_weak_odr:       Res = GlobalValue::WeakODRLinkage;       break;
1002   case lltok::kw_linkonce:       Res = GlobalValue::LinkOnceAnyLinkage;   break;
1003   case lltok::kw_linkonce_odr:   Res = GlobalValue::LinkOnceODRLinkage;   break;
1004   case lltok::kw_available_externally:
1005     Res = GlobalValue::AvailableExternallyLinkage;
1006     break;
1007   case lltok::kw_appending:      Res = GlobalValue::AppendingLinkage;     break;
1008   case lltok::kw_dllexport:      Res = GlobalValue::DLLExportLinkage;     break;
1009   case lltok::kw_common:         Res = GlobalValue::CommonLinkage;        break;
1010   case lltok::kw_dllimport:      Res = GlobalValue::DLLImportLinkage;     break;
1011   case lltok::kw_extern_weak:    Res = GlobalValue::ExternalWeakLinkage;  break;
1012   case lltok::kw_external:       Res = GlobalValue::ExternalLinkage;      break;
1013   }
1014   Lex.Lex();
1015   HasLinkage = true;
1016   return false;
1017 }
1018
1019 /// ParseOptionalVisibility
1020 ///   ::= /*empty*/
1021 ///   ::= 'default'
1022 ///   ::= 'hidden'
1023 ///   ::= 'protected'
1024 ///
1025 bool LLParser::ParseOptionalVisibility(unsigned &Res) {
1026   switch (Lex.getKind()) {
1027   default:                  Res = GlobalValue::DefaultVisibility; return false;
1028   case lltok::kw_default:   Res = GlobalValue::DefaultVisibility; break;
1029   case lltok::kw_hidden:    Res = GlobalValue::HiddenVisibility; break;
1030   case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break;
1031   }
1032   Lex.Lex();
1033   return false;
1034 }
1035
1036 /// ParseOptionalCallingConv
1037 ///   ::= /*empty*/
1038 ///   ::= 'ccc'
1039 ///   ::= 'fastcc'
1040 ///   ::= 'coldcc'
1041 ///   ::= 'x86_stdcallcc'
1042 ///   ::= 'x86_fastcallcc'
1043 ///   ::= 'arm_apcscc'
1044 ///   ::= 'arm_aapcscc'
1045 ///   ::= 'arm_aapcs_vfpcc'
1046 ///   ::= 'cc' UINT
1047 ///
1048 bool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) {
1049   switch (Lex.getKind()) {
1050   default:                       CC = CallingConv::C; return false;
1051   case lltok::kw_ccc:            CC = CallingConv::C; break;
1052   case lltok::kw_fastcc:         CC = CallingConv::Fast; break;
1053   case lltok::kw_coldcc:         CC = CallingConv::Cold; break;
1054   case lltok::kw_x86_stdcallcc:  CC = CallingConv::X86_StdCall; break;
1055   case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break;
1056   case lltok::kw_arm_apcscc:     CC = CallingConv::ARM_APCS; break;
1057   case lltok::kw_arm_aapcscc:    CC = CallingConv::ARM_AAPCS; break;
1058   case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break;
1059   case lltok::kw_cc: {
1060       unsigned ArbitraryCC;
1061       Lex.Lex();
1062       if (ParseUInt32(ArbitraryCC)) {
1063         return true;
1064       } else
1065         CC = static_cast<CallingConv::ID>(ArbitraryCC);
1066         return false;
1067     }
1068     break;
1069   }
1070
1071   Lex.Lex();
1072   return false;
1073 }
1074
1075 /// ParseOptionalCustomMetadata
1076 ///   ::= /* empty */
1077 ///   ::= !dbg !42
1078 bool LLParser::ParseOptionalCustomMetadata() {
1079   if (Lex.getKind() != lltok::NamedOrCustomMD)
1080     return false;
1081
1082   std::string Name = Lex.getStrVal();
1083   Lex.Lex();
1084
1085   if (Lex.getKind() != lltok::Metadata)
1086     return TokError("Expected '!' here");
1087   Lex.Lex();
1088
1089   MetadataBase *Node;
1090   if (ParseMDNode(Node)) return true;
1091
1092   MetadataContext &TheMetadata = M->getContext().getMetadata();
1093   unsigned MDK = TheMetadata.getMDKind(Name.c_str());
1094   if (!MDK)
1095     MDK = TheMetadata.registerMDKind(Name.c_str());
1096   MDsOnInst.push_back(std::make_pair(MDK, cast<MDNode>(Node)));
1097
1098   return false;
1099 }
1100
1101 /// ParseOptionalAlignment
1102 ///   ::= /* empty */
1103 ///   ::= 'align' 4
1104 bool LLParser::ParseOptionalAlignment(unsigned &Alignment) {
1105   Alignment = 0;
1106   if (!EatIfPresent(lltok::kw_align))
1107     return false;
1108   LocTy AlignLoc = Lex.getLoc();
1109   if (ParseUInt32(Alignment)) return true;
1110   if (!isPowerOf2_32(Alignment))
1111     return Error(AlignLoc, "alignment is not a power of two");
1112   return false;
1113 }
1114
1115 /// ParseOptionalInfo
1116 ///   ::= OptionalInfo (',' OptionalInfo)+
1117 bool LLParser::ParseOptionalInfo(unsigned &Alignment) {
1118
1119   // FIXME: Handle customized metadata info attached with an instruction.
1120   do {
1121       if (Lex.getKind() == lltok::NamedOrCustomMD) {
1122       if (ParseOptionalCustomMetadata()) return true;
1123     } else if (Lex.getKind() == lltok::kw_align) {
1124       if (ParseOptionalAlignment(Alignment)) return true;
1125     } else
1126       return true;
1127   } while (EatIfPresent(lltok::comma));
1128
1129   return false;
1130 }
1131
1132
1133 /// ParseIndexList
1134 ///    ::=  (',' uint32)+
1135 bool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices) {
1136   if (Lex.getKind() != lltok::comma)
1137     return TokError("expected ',' as start of index list");
1138
1139   while (EatIfPresent(lltok::comma)) {
1140     if (Lex.getKind() == lltok::NamedOrCustomMD)
1141       break;
1142     unsigned Idx;
1143     if (ParseUInt32(Idx)) return true;
1144     Indices.push_back(Idx);
1145   }
1146
1147   return false;
1148 }
1149
1150 //===----------------------------------------------------------------------===//
1151 // Type Parsing.
1152 //===----------------------------------------------------------------------===//
1153
1154 /// ParseType - Parse and resolve a full type.
1155 bool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) {
1156   LocTy TypeLoc = Lex.getLoc();
1157   if (ParseTypeRec(Result)) return true;
1158
1159   // Verify no unresolved uprefs.
1160   if (!UpRefs.empty())
1161     return Error(UpRefs.back().Loc, "invalid unresolved type up reference");
1162
1163   if (!AllowVoid && Result.get()->isVoidTy())
1164     return Error(TypeLoc, "void type only allowed for function results");
1165
1166   return false;
1167 }
1168
1169 /// HandleUpRefs - Every time we finish a new layer of types, this function is
1170 /// called.  It loops through the UpRefs vector, which is a list of the
1171 /// currently active types.  For each type, if the up-reference is contained in
1172 /// the newly completed type, we decrement the level count.  When the level
1173 /// count reaches zero, the up-referenced type is the type that is passed in:
1174 /// thus we can complete the cycle.
1175 ///
1176 PATypeHolder LLParser::HandleUpRefs(const Type *ty) {
1177   // If Ty isn't abstract, or if there are no up-references in it, then there is
1178   // nothing to resolve here.
1179   if (!ty->isAbstract() || UpRefs.empty()) return ty;
1180
1181   PATypeHolder Ty(ty);
1182 #if 0
1183   errs() << "Type '" << Ty->getDescription()
1184          << "' newly formed.  Resolving upreferences.\n"
1185          << UpRefs.size() << " upreferences active!\n";
1186 #endif
1187
1188   // If we find any resolvable upreferences (i.e., those whose NestingLevel goes
1189   // to zero), we resolve them all together before we resolve them to Ty.  At
1190   // the end of the loop, if there is anything to resolve to Ty, it will be in
1191   // this variable.
1192   OpaqueType *TypeToResolve = 0;
1193
1194   for (unsigned i = 0; i != UpRefs.size(); ++i) {
1195     // Determine if 'Ty' directly contains this up-references 'LastContainedTy'.
1196     bool ContainsType =
1197       std::find(Ty->subtype_begin(), Ty->subtype_end(),
1198                 UpRefs[i].LastContainedTy) != Ty->subtype_end();
1199
1200 #if 0
1201     errs() << "  UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
1202            << UpRefs[i].LastContainedTy->getDescription() << ") = "
1203            << (ContainsType ? "true" : "false")
1204            << " level=" << UpRefs[i].NestingLevel << "\n";
1205 #endif
1206     if (!ContainsType)
1207       continue;
1208
1209     // Decrement level of upreference
1210     unsigned Level = --UpRefs[i].NestingLevel;
1211     UpRefs[i].LastContainedTy = Ty;
1212
1213     // If the Up-reference has a non-zero level, it shouldn't be resolved yet.
1214     if (Level != 0)
1215       continue;
1216
1217 #if 0
1218     errs() << "  * Resolving upreference for " << UpRefs[i].UpRefTy << "\n";
1219 #endif
1220     if (!TypeToResolve)
1221       TypeToResolve = UpRefs[i].UpRefTy;
1222     else
1223       UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
1224     UpRefs.erase(UpRefs.begin()+i);     // Remove from upreference list.
1225     --i;                                // Do not skip the next element.
1226   }
1227
1228   if (TypeToResolve)
1229     TypeToResolve->refineAbstractTypeTo(Ty);
1230
1231   return Ty;
1232 }
1233
1234
1235 /// ParseTypeRec - The recursive function used to process the internal
1236 /// implementation details of types.
1237 bool LLParser::ParseTypeRec(PATypeHolder &Result) {
1238   switch (Lex.getKind()) {
1239   default:
1240     return TokError("expected type");
1241   case lltok::Type:
1242     // TypeRec ::= 'float' | 'void' (etc)
1243     Result = Lex.getTyVal();
1244     Lex.Lex();
1245     break;
1246   case lltok::kw_opaque:
1247     // TypeRec ::= 'opaque'
1248     Result = OpaqueType::get(Context);
1249     Lex.Lex();
1250     break;
1251   case lltok::lbrace:
1252     // TypeRec ::= '{' ... '}'
1253     if (ParseStructType(Result, false))
1254       return true;
1255     break;
1256   case lltok::lsquare:
1257     // TypeRec ::= '[' ... ']'
1258     Lex.Lex(); // eat the lsquare.
1259     if (ParseArrayVectorType(Result, false))
1260       return true;
1261     break;
1262   case lltok::less: // Either vector or packed struct.
1263     // TypeRec ::= '<' ... '>'
1264     Lex.Lex();
1265     if (Lex.getKind() == lltok::lbrace) {
1266       if (ParseStructType(Result, true) ||
1267           ParseToken(lltok::greater, "expected '>' at end of packed struct"))
1268         return true;
1269     } else if (ParseArrayVectorType(Result, true))
1270       return true;
1271     break;
1272   case lltok::LocalVar:
1273   case lltok::StringConstant:  // FIXME: REMOVE IN LLVM 3.0
1274     // TypeRec ::= %foo
1275     if (const Type *T = M->getTypeByName(Lex.getStrVal())) {
1276       Result = T;
1277     } else {
1278       Result = OpaqueType::get(Context);
1279       ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(),
1280                                             std::make_pair(Result,
1281                                                            Lex.getLoc())));
1282       M->addTypeName(Lex.getStrVal(), Result.get());
1283     }
1284     Lex.Lex();
1285     break;
1286
1287   case lltok::LocalVarID:
1288     // TypeRec ::= %4
1289     if (Lex.getUIntVal() < NumberedTypes.size())
1290       Result = NumberedTypes[Lex.getUIntVal()];
1291     else {
1292       std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator
1293         I = ForwardRefTypeIDs.find(Lex.getUIntVal());
1294       if (I != ForwardRefTypeIDs.end())
1295         Result = I->second.first;
1296       else {
1297         Result = OpaqueType::get(Context);
1298         ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(),
1299                                                 std::make_pair(Result,
1300                                                                Lex.getLoc())));
1301       }
1302     }
1303     Lex.Lex();
1304     break;
1305   case lltok::backslash: {
1306     // TypeRec ::= '\' 4
1307     Lex.Lex();
1308     unsigned Val;
1309     if (ParseUInt32(Val)) return true;
1310     OpaqueType *OT = OpaqueType::get(Context); //Use temporary placeholder.
1311     UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT));
1312     Result = OT;
1313     break;
1314   }
1315   }
1316
1317   // Parse the type suffixes.
1318   while (1) {
1319     switch (Lex.getKind()) {
1320     // End of type.
1321     default: return false;
1322
1323     // TypeRec ::= TypeRec '*'
1324     case lltok::star:
1325       if (Result.get()->isLabelTy())
1326         return TokError("basic block pointers are invalid");
1327       if (Result.get()->isVoidTy())
1328         return TokError("pointers to void are invalid; use i8* instead");
1329       if (!PointerType::isValidElementType(Result.get()))
1330         return TokError("pointer to this type is invalid");
1331       Result = HandleUpRefs(PointerType::getUnqual(Result.get()));
1332       Lex.Lex();
1333       break;
1334
1335     // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*'
1336     case lltok::kw_addrspace: {
1337       if (Result.get()->isLabelTy())
1338         return TokError("basic block pointers are invalid");
1339       if (Result.get()->isVoidTy())
1340         return TokError("pointers to void are invalid; use i8* instead");
1341       if (!PointerType::isValidElementType(Result.get()))
1342         return TokError("pointer to this type is invalid");
1343       unsigned AddrSpace;
1344       if (ParseOptionalAddrSpace(AddrSpace) ||
1345           ParseToken(lltok::star, "expected '*' in address space"))
1346         return true;
1347
1348       Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace));
1349       break;
1350     }
1351
1352     /// Types '(' ArgTypeListI ')' OptFuncAttrs
1353     case lltok::lparen:
1354       if (ParseFunctionType(Result))
1355         return true;
1356       break;
1357     }
1358   }
1359 }
1360
1361 /// ParseParameterList
1362 ///    ::= '(' ')'
1363 ///    ::= '(' Arg (',' Arg)* ')'
1364 ///  Arg
1365 ///    ::= Type OptionalAttributes Value OptionalAttributes
1366 bool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList,
1367                                   PerFunctionState &PFS) {
1368   if (ParseToken(lltok::lparen, "expected '(' in call"))
1369     return true;
1370
1371   while (Lex.getKind() != lltok::rparen) {
1372     // If this isn't the first argument, we need a comma.
1373     if (!ArgList.empty() &&
1374         ParseToken(lltok::comma, "expected ',' in argument list"))
1375       return true;
1376
1377     // Parse the argument.
1378     LocTy ArgLoc;
1379     PATypeHolder ArgTy(Type::getVoidTy(Context));
1380     unsigned ArgAttrs1, ArgAttrs2;
1381     Value *V;
1382     if (ParseType(ArgTy, ArgLoc) ||
1383         ParseOptionalAttrs(ArgAttrs1, 0) ||
1384         ParseValue(ArgTy, V, PFS) ||
1385         // FIXME: Should not allow attributes after the argument, remove this in
1386         // LLVM 3.0.
1387         ParseOptionalAttrs(ArgAttrs2, 3))
1388       return true;
1389     ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2));
1390   }
1391
1392   Lex.Lex();  // Lex the ')'.
1393   return false;
1394 }
1395
1396
1397
1398 /// ParseArgumentList - Parse the argument list for a function type or function
1399 /// prototype.  If 'inType' is true then we are parsing a FunctionType.
1400 ///   ::= '(' ArgTypeListI ')'
1401 /// ArgTypeListI
1402 ///   ::= /*empty*/
1403 ///   ::= '...'
1404 ///   ::= ArgTypeList ',' '...'
1405 ///   ::= ArgType (',' ArgType)*
1406 ///
1407 bool LLParser::ParseArgumentList(std::vector<ArgInfo> &ArgList,
1408                                  bool &isVarArg, bool inType) {
1409   isVarArg = false;
1410   assert(Lex.getKind() == lltok::lparen);
1411   Lex.Lex(); // eat the (.
1412
1413   if (Lex.getKind() == lltok::rparen) {
1414     // empty
1415   } else if (Lex.getKind() == lltok::dotdotdot) {
1416     isVarArg = true;
1417     Lex.Lex();
1418   } else {
1419     LocTy TypeLoc = Lex.getLoc();
1420     PATypeHolder ArgTy(Type::getVoidTy(Context));
1421     unsigned Attrs;
1422     std::string Name;
1423
1424     // If we're parsing a type, use ParseTypeRec, because we allow recursive
1425     // types (such as a function returning a pointer to itself).  If parsing a
1426     // function prototype, we require fully resolved types.
1427     if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) ||
1428         ParseOptionalAttrs(Attrs, 0)) return true;
1429
1430     if (ArgTy->isVoidTy())
1431       return Error(TypeLoc, "argument can not have void type");
1432
1433     if (Lex.getKind() == lltok::LocalVar ||
1434         Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0
1435       Name = Lex.getStrVal();
1436       Lex.Lex();
1437     }
1438
1439     if (!FunctionType::isValidArgumentType(ArgTy))
1440       return Error(TypeLoc, "invalid type for function argument");
1441
1442     ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
1443
1444     while (EatIfPresent(lltok::comma)) {
1445       // Handle ... at end of arg list.
1446       if (EatIfPresent(lltok::dotdotdot)) {
1447         isVarArg = true;
1448         break;
1449       }
1450
1451       // Otherwise must be an argument type.
1452       TypeLoc = Lex.getLoc();
1453       if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) ||
1454           ParseOptionalAttrs(Attrs, 0)) return true;
1455
1456       if (ArgTy->isVoidTy())
1457         return Error(TypeLoc, "argument can not have void type");
1458
1459       if (Lex.getKind() == lltok::LocalVar ||
1460           Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0
1461         Name = Lex.getStrVal();
1462         Lex.Lex();
1463       } else {
1464         Name = "";
1465       }
1466
1467       if (!ArgTy->isFirstClassType() && !isa<OpaqueType>(ArgTy))
1468         return Error(TypeLoc, "invalid type for function argument");
1469
1470       ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name));
1471     }
1472   }
1473
1474   return ParseToken(lltok::rparen, "expected ')' at end of argument list");
1475 }
1476
1477 /// ParseFunctionType
1478 ///  ::= Type ArgumentList OptionalAttrs
1479 bool LLParser::ParseFunctionType(PATypeHolder &Result) {
1480   assert(Lex.getKind() == lltok::lparen);
1481
1482   if (!FunctionType::isValidReturnType(Result))
1483     return TokError("invalid function return type");
1484
1485   std::vector<ArgInfo> ArgList;
1486   bool isVarArg;
1487   unsigned Attrs;
1488   if (ParseArgumentList(ArgList, isVarArg, true) ||
1489       // FIXME: Allow, but ignore attributes on function types!
1490       // FIXME: Remove in LLVM 3.0
1491       ParseOptionalAttrs(Attrs, 2))
1492     return true;
1493
1494   // Reject names on the arguments lists.
1495   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
1496     if (!ArgList[i].Name.empty())
1497       return Error(ArgList[i].Loc, "argument name invalid in function type");
1498     if (!ArgList[i].Attrs != 0) {
1499       // Allow but ignore attributes on function types; this permits
1500       // auto-upgrade.
1501       // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0
1502     }
1503   }
1504
1505   std::vector<const Type*> ArgListTy;
1506   for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
1507     ArgListTy.push_back(ArgList[i].Type);
1508
1509   Result = HandleUpRefs(FunctionType::get(Result.get(),
1510                                                 ArgListTy, isVarArg));
1511   return false;
1512 }
1513
1514 /// ParseStructType: Handles packed and unpacked types.  </> parsed elsewhere.
1515 ///   TypeRec
1516 ///     ::= '{' '}'
1517 ///     ::= '{' TypeRec (',' TypeRec)* '}'
1518 ///     ::= '<' '{' '}' '>'
1519 ///     ::= '<' '{' TypeRec (',' TypeRec)* '}' '>'
1520 bool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) {
1521   assert(Lex.getKind() == lltok::lbrace);
1522   Lex.Lex(); // Consume the '{'
1523
1524   if (EatIfPresent(lltok::rbrace)) {
1525     Result = StructType::get(Context, Packed);
1526     return false;
1527   }
1528
1529   std::vector<PATypeHolder> ParamsList;
1530   LocTy EltTyLoc = Lex.getLoc();
1531   if (ParseTypeRec(Result)) return true;
1532   ParamsList.push_back(Result);
1533
1534   if (Result->isVoidTy())
1535     return Error(EltTyLoc, "struct element can not have void type");
1536   if (!StructType::isValidElementType(Result))
1537     return Error(EltTyLoc, "invalid element type for struct");
1538
1539   while (EatIfPresent(lltok::comma)) {
1540     EltTyLoc = Lex.getLoc();
1541     if (ParseTypeRec(Result)) return true;
1542
1543     if (Result->isVoidTy())
1544       return Error(EltTyLoc, "struct element can not have void type");
1545     if (!StructType::isValidElementType(Result))
1546       return Error(EltTyLoc, "invalid element type for struct");
1547
1548     ParamsList.push_back(Result);
1549   }
1550
1551   if (ParseToken(lltok::rbrace, "expected '}' at end of struct"))
1552     return true;
1553
1554   std::vector<const Type*> ParamsListTy;
1555   for (unsigned i = 0, e = ParamsList.size(); i != e; ++i)
1556     ParamsListTy.push_back(ParamsList[i].get());
1557   Result = HandleUpRefs(StructType::get(Context, ParamsListTy, Packed));
1558   return false;
1559 }
1560
1561 /// ParseArrayVectorType - Parse an array or vector type, assuming the first
1562 /// token has already been consumed.
1563 ///   TypeRec
1564 ///     ::= '[' APSINTVAL 'x' Types ']'
1565 ///     ::= '<' APSINTVAL 'x' Types '>'
1566 bool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) {
1567   if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() ||
1568       Lex.getAPSIntVal().getBitWidth() > 64)
1569     return TokError("expected number in address space");
1570
1571   LocTy SizeLoc = Lex.getLoc();
1572   uint64_t Size = Lex.getAPSIntVal().getZExtValue();
1573   Lex.Lex();
1574
1575   if (ParseToken(lltok::kw_x, "expected 'x' after element count"))
1576       return true;
1577
1578   LocTy TypeLoc = Lex.getLoc();
1579   PATypeHolder EltTy(Type::getVoidTy(Context));
1580   if (ParseTypeRec(EltTy)) return true;
1581
1582   if (EltTy->isVoidTy())
1583     return Error(TypeLoc, "array and vector element type cannot be void");
1584
1585   if (ParseToken(isVector ? lltok::greater : lltok::rsquare,
1586                  "expected end of sequential type"))
1587     return true;
1588
1589   if (isVector) {
1590     if (Size == 0)
1591       return Error(SizeLoc, "zero element vector is illegal");
1592     if ((unsigned)Size != Size)
1593       return Error(SizeLoc, "size too large for vector");
1594     if (!VectorType::isValidElementType(EltTy))
1595       return Error(TypeLoc, "vector element type must be fp or integer");
1596     Result = VectorType::get(EltTy, unsigned(Size));
1597   } else {
1598     if (!ArrayType::isValidElementType(EltTy))
1599       return Error(TypeLoc, "invalid array element type");
1600     Result = HandleUpRefs(ArrayType::get(EltTy, Size));
1601   }
1602   return false;
1603 }
1604
1605 //===----------------------------------------------------------------------===//
1606 // Function Semantic Analysis.
1607 //===----------------------------------------------------------------------===//
1608
1609 LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
1610                                              int functionNumber)
1611   : P(p), F(f), FunctionNumber(functionNumber) {
1612
1613   // Insert unnamed arguments into the NumberedVals list.
1614   for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end();
1615        AI != E; ++AI)
1616     if (!AI->hasName())
1617       NumberedVals.push_back(AI);
1618 }
1619
1620 LLParser::PerFunctionState::~PerFunctionState() {
1621   // If there were any forward referenced non-basicblock values, delete them.
1622   for (std::map<std::string, std::pair<Value*, LocTy> >::iterator
1623        I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I)
1624     if (!isa<BasicBlock>(I->second.first)) {
1625       I->second.first->replaceAllUsesWith(
1626                            UndefValue::get(I->second.first->getType()));
1627       delete I->second.first;
1628       I->second.first = 0;
1629     }
1630
1631   for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1632        I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I)
1633     if (!isa<BasicBlock>(I->second.first)) {
1634       I->second.first->replaceAllUsesWith(
1635                            UndefValue::get(I->second.first->getType()));
1636       delete I->second.first;
1637       I->second.first = 0;
1638     }
1639 }
1640
1641 bool LLParser::PerFunctionState::FinishFunction() {
1642   // Check to see if someone took the address of labels in this block.
1643   if (!P.ForwardRefBlockAddresses.empty()) {
1644     ValID FunctionID;
1645     if (!F.getName().empty()) {
1646       FunctionID.Kind = ValID::t_GlobalName;
1647       FunctionID.StrVal = F.getName();
1648     } else {
1649       FunctionID.Kind = ValID::t_GlobalID;
1650       FunctionID.UIntVal = FunctionNumber;
1651     }
1652
1653     std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator
1654       FRBAI = P.ForwardRefBlockAddresses.find(FunctionID);
1655     if (FRBAI != P.ForwardRefBlockAddresses.end()) {
1656       // Resolve all these references.
1657       if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this))
1658         return true;
1659
1660       P.ForwardRefBlockAddresses.erase(FRBAI);
1661     }
1662   }
1663
1664   if (!ForwardRefVals.empty())
1665     return P.Error(ForwardRefVals.begin()->second.second,
1666                    "use of undefined value '%" + ForwardRefVals.begin()->first +
1667                    "'");
1668   if (!ForwardRefValIDs.empty())
1669     return P.Error(ForwardRefValIDs.begin()->second.second,
1670                    "use of undefined value '%" +
1671                    utostr(ForwardRefValIDs.begin()->first) + "'");
1672   return false;
1673 }
1674
1675
1676 /// GetVal - Get a value with the specified name or ID, creating a
1677 /// forward reference record if needed.  This can return null if the value
1678 /// exists but does not have the right type.
1679 Value *LLParser::PerFunctionState::GetVal(const std::string &Name,
1680                                           const Type *Ty, LocTy Loc) {
1681   // Look this name up in the normal function symbol table.
1682   Value *Val = F.getValueSymbolTable().lookup(Name);
1683
1684   // If this is a forward reference for the value, see if we already created a
1685   // forward ref record.
1686   if (Val == 0) {
1687     std::map<std::string, std::pair<Value*, LocTy> >::iterator
1688       I = ForwardRefVals.find(Name);
1689     if (I != ForwardRefVals.end())
1690       Val = I->second.first;
1691   }
1692
1693   // If we have the value in the symbol table or fwd-ref table, return it.
1694   if (Val) {
1695     if (Val->getType() == Ty) return Val;
1696     if (Ty->isLabelTy())
1697       P.Error(Loc, "'%" + Name + "' is not a basic block");
1698     else
1699       P.Error(Loc, "'%" + Name + "' defined with type '" +
1700               Val->getType()->getDescription() + "'");
1701     return 0;
1702   }
1703
1704   // Don't make placeholders with invalid type.
1705   if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) &&
1706       Ty != Type::getLabelTy(F.getContext())) {
1707     P.Error(Loc, "invalid use of a non-first-class type");
1708     return 0;
1709   }
1710
1711   // Otherwise, create a new forward reference for this value and remember it.
1712   Value *FwdVal;
1713   if (Ty->isLabelTy())
1714     FwdVal = BasicBlock::Create(F.getContext(), Name, &F);
1715   else
1716     FwdVal = new Argument(Ty, Name);
1717
1718   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
1719   return FwdVal;
1720 }
1721
1722 Value *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty,
1723                                           LocTy Loc) {
1724   // Look this name up in the normal function symbol table.
1725   Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0;
1726
1727   // If this is a forward reference for the value, see if we already created a
1728   // forward ref record.
1729   if (Val == 0) {
1730     std::map<unsigned, std::pair<Value*, LocTy> >::iterator
1731       I = ForwardRefValIDs.find(ID);
1732     if (I != ForwardRefValIDs.end())
1733       Val = I->second.first;
1734   }
1735
1736   // If we have the value in the symbol table or fwd-ref table, return it.
1737   if (Val) {
1738     if (Val->getType() == Ty) return Val;
1739     if (Ty->isLabelTy())
1740       P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block");
1741     else
1742       P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" +
1743               Val->getType()->getDescription() + "'");
1744     return 0;
1745   }
1746
1747   if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) &&
1748       Ty != Type::getLabelTy(F.getContext())) {
1749     P.Error(Loc, "invalid use of a non-first-class type");
1750     return 0;
1751   }
1752
1753   // Otherwise, create a new forward reference for this value and remember it.
1754   Value *FwdVal;
1755   if (Ty->isLabelTy())
1756     FwdVal = BasicBlock::Create(F.getContext(), "", &F);
1757   else
1758     FwdVal = new Argument(Ty);
1759
1760   ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc);
1761   return FwdVal;
1762 }
1763
1764 /// SetInstName - After an instruction is parsed and inserted into its
1765 /// basic block, this installs its name.
1766 bool LLParser::PerFunctionState::SetInstName(int NameID,
1767                                              const std::string &NameStr,
1768                                              LocTy NameLoc, Instruction *Inst) {
1769   // If this instruction has void type, it cannot have a name or ID specified.
1770   if (Inst->getType()->isVoidTy()) {
1771     if (NameID != -1 || !NameStr.empty())
1772       return P.Error(NameLoc, "instructions returning void cannot have a name");
1773     return false;
1774   }
1775
1776   // If this was a numbered instruction, verify that the instruction is the
1777   // expected value and resolve any forward references.
1778   if (NameStr.empty()) {
1779     // If neither a name nor an ID was specified, just use the next ID.
1780     if (NameID == -1)
1781       NameID = NumberedVals.size();
1782
1783     if (unsigned(NameID) != NumberedVals.size())
1784       return P.Error(NameLoc, "instruction expected to be numbered '%" +
1785                      utostr(NumberedVals.size()) + "'");
1786
1787     std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI =
1788       ForwardRefValIDs.find(NameID);
1789     if (FI != ForwardRefValIDs.end()) {
1790       if (FI->second.first->getType() != Inst->getType())
1791         return P.Error(NameLoc, "instruction forward referenced with type '" +
1792                        FI->second.first->getType()->getDescription() + "'");
1793       FI->second.first->replaceAllUsesWith(Inst);
1794       delete FI->second.first;
1795       ForwardRefValIDs.erase(FI);
1796     }
1797
1798     NumberedVals.push_back(Inst);
1799     return false;
1800   }
1801
1802   // Otherwise, the instruction had a name.  Resolve forward refs and set it.
1803   std::map<std::string, std::pair<Value*, LocTy> >::iterator
1804     FI = ForwardRefVals.find(NameStr);
1805   if (FI != ForwardRefVals.end()) {
1806     if (FI->second.first->getType() != Inst->getType())
1807       return P.Error(NameLoc, "instruction forward referenced with type '" +
1808                      FI->second.first->getType()->getDescription() + "'");
1809     FI->second.first->replaceAllUsesWith(Inst);
1810     delete FI->second.first;
1811     ForwardRefVals.erase(FI);
1812   }
1813
1814   // Set the name on the instruction.
1815   Inst->setName(NameStr);
1816
1817   if (Inst->getNameStr() != NameStr)
1818     return P.Error(NameLoc, "multiple definition of local value named '" +
1819                    NameStr + "'");
1820   return false;
1821 }
1822
1823 /// GetBB - Get a basic block with the specified name or ID, creating a
1824 /// forward reference record if needed.
1825 BasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name,
1826                                               LocTy Loc) {
1827   return cast_or_null<BasicBlock>(GetVal(Name,
1828                                         Type::getLabelTy(F.getContext()), Loc));
1829 }
1830
1831 BasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) {
1832   return cast_or_null<BasicBlock>(GetVal(ID,
1833                                         Type::getLabelTy(F.getContext()), Loc));
1834 }
1835
1836 /// DefineBB - Define the specified basic block, which is either named or
1837 /// unnamed.  If there is an error, this returns null otherwise it returns
1838 /// the block being defined.
1839 BasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name,
1840                                                  LocTy Loc) {
1841   BasicBlock *BB;
1842   if (Name.empty())
1843     BB = GetBB(NumberedVals.size(), Loc);
1844   else
1845     BB = GetBB(Name, Loc);
1846   if (BB == 0) return 0; // Already diagnosed error.
1847
1848   // Move the block to the end of the function.  Forward ref'd blocks are
1849   // inserted wherever they happen to be referenced.
1850   F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB);
1851
1852   // Remove the block from forward ref sets.
1853   if (Name.empty()) {
1854     ForwardRefValIDs.erase(NumberedVals.size());
1855     NumberedVals.push_back(BB);
1856   } else {
1857     // BB forward references are already in the function symbol table.
1858     ForwardRefVals.erase(Name);
1859   }
1860
1861   return BB;
1862 }
1863
1864 //===----------------------------------------------------------------------===//
1865 // Constants.
1866 //===----------------------------------------------------------------------===//
1867
1868 /// ParseValID - Parse an abstract value that doesn't necessarily have a
1869 /// type implied.  For example, if we parse "4" we don't know what integer type
1870 /// it has.  The value will later be combined with its type and checked for
1871 /// sanity.
1872 bool LLParser::ParseValID(ValID &ID) {
1873   ID.Loc = Lex.getLoc();
1874   switch (Lex.getKind()) {
1875   default: return TokError("expected value token");
1876   case lltok::GlobalID:  // @42
1877     ID.UIntVal = Lex.getUIntVal();
1878     ID.Kind = ValID::t_GlobalID;
1879     break;
1880   case lltok::GlobalVar:  // @foo
1881     ID.StrVal = Lex.getStrVal();
1882     ID.Kind = ValID::t_GlobalName;
1883     break;
1884   case lltok::LocalVarID:  // %42
1885     ID.UIntVal = Lex.getUIntVal();
1886     ID.Kind = ValID::t_LocalID;
1887     break;
1888   case lltok::LocalVar:  // %foo
1889   case lltok::StringConstant:  // "foo" - FIXME: REMOVE IN LLVM 3.0
1890     ID.StrVal = Lex.getStrVal();
1891     ID.Kind = ValID::t_LocalName;
1892     break;
1893   case lltok::Metadata: {  // !{...} MDNode, !"foo" MDString
1894     ID.Kind = ValID::t_Metadata;
1895     Lex.Lex();
1896     if (Lex.getKind() == lltok::lbrace) {
1897       SmallVector<Value*, 16> Elts;
1898       if (ParseMDNodeVector(Elts) ||
1899           ParseToken(lltok::rbrace, "expected end of metadata node"))
1900         return true;
1901
1902       ID.MetadataVal = MDNode::get(Context, Elts.data(), Elts.size());
1903       return false;
1904     }
1905
1906     // Standalone metadata reference
1907     // !{ ..., !42, ... }
1908     if (!ParseMDNode(ID.MetadataVal))
1909       return false;
1910
1911     // MDString:
1912     //   ::= '!' STRINGCONSTANT
1913     if (ParseMDString(ID.MetadataVal)) return true;
1914     ID.Kind = ValID::t_Metadata;
1915     return false;
1916   }
1917   case lltok::APSInt:
1918     ID.APSIntVal = Lex.getAPSIntVal();
1919     ID.Kind = ValID::t_APSInt;
1920     break;
1921   case lltok::APFloat:
1922     ID.APFloatVal = Lex.getAPFloatVal();
1923     ID.Kind = ValID::t_APFloat;
1924     break;
1925   case lltok::kw_true:
1926     ID.ConstantVal = ConstantInt::getTrue(Context);
1927     ID.Kind = ValID::t_Constant;
1928     break;
1929   case lltok::kw_false:
1930     ID.ConstantVal = ConstantInt::getFalse(Context);
1931     ID.Kind = ValID::t_Constant;
1932     break;
1933   case lltok::kw_null: ID.Kind = ValID::t_Null; break;
1934   case lltok::kw_undef: ID.Kind = ValID::t_Undef; break;
1935   case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break;
1936
1937   case lltok::lbrace: {
1938     // ValID ::= '{' ConstVector '}'
1939     Lex.Lex();
1940     SmallVector<Constant*, 16> Elts;
1941     if (ParseGlobalValueVector(Elts) ||
1942         ParseToken(lltok::rbrace, "expected end of struct constant"))
1943       return true;
1944
1945     ID.ConstantVal = ConstantStruct::get(Context, Elts.data(),
1946                                          Elts.size(), false);
1947     ID.Kind = ValID::t_Constant;
1948     return false;
1949   }
1950   case lltok::less: {
1951     // ValID ::= '<' ConstVector '>'         --> Vector.
1952     // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct.
1953     Lex.Lex();
1954     bool isPackedStruct = EatIfPresent(lltok::lbrace);
1955
1956     SmallVector<Constant*, 16> Elts;
1957     LocTy FirstEltLoc = Lex.getLoc();
1958     if (ParseGlobalValueVector(Elts) ||
1959         (isPackedStruct &&
1960          ParseToken(lltok::rbrace, "expected end of packed struct")) ||
1961         ParseToken(lltok::greater, "expected end of constant"))
1962       return true;
1963
1964     if (isPackedStruct) {
1965       ID.ConstantVal =
1966         ConstantStruct::get(Context, Elts.data(), Elts.size(), true);
1967       ID.Kind = ValID::t_Constant;
1968       return false;
1969     }
1970
1971     if (Elts.empty())
1972       return Error(ID.Loc, "constant vector must not be empty");
1973
1974     if (!Elts[0]->getType()->isInteger() &&
1975         !Elts[0]->getType()->isFloatingPoint())
1976       return Error(FirstEltLoc,
1977                    "vector elements must have integer or floating point type");
1978
1979     // Verify that all the vector elements have the same type.
1980     for (unsigned i = 1, e = Elts.size(); i != e; ++i)
1981       if (Elts[i]->getType() != Elts[0]->getType())
1982         return Error(FirstEltLoc,
1983                      "vector element #" + utostr(i) +
1984                     " is not of type '" + Elts[0]->getType()->getDescription());
1985
1986     ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size());
1987     ID.Kind = ValID::t_Constant;
1988     return false;
1989   }
1990   case lltok::lsquare: {   // Array Constant
1991     Lex.Lex();
1992     SmallVector<Constant*, 16> Elts;
1993     LocTy FirstEltLoc = Lex.getLoc();
1994     if (ParseGlobalValueVector(Elts) ||
1995         ParseToken(lltok::rsquare, "expected end of array constant"))
1996       return true;
1997
1998     // Handle empty element.
1999     if (Elts.empty()) {
2000       // Use undef instead of an array because it's inconvenient to determine
2001       // the element type at this point, there being no elements to examine.
2002       ID.Kind = ValID::t_EmptyArray;
2003       return false;
2004     }
2005
2006     if (!Elts[0]->getType()->isFirstClassType())
2007       return Error(FirstEltLoc, "invalid array element type: " +
2008                    Elts[0]->getType()->getDescription());
2009
2010     ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size());
2011
2012     // Verify all elements are correct type!
2013     for (unsigned i = 0, e = Elts.size(); i != e; ++i) {
2014       if (Elts[i]->getType() != Elts[0]->getType())
2015         return Error(FirstEltLoc,
2016                      "array element #" + utostr(i) +
2017                      " is not of type '" +Elts[0]->getType()->getDescription());
2018     }
2019
2020     ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size());
2021     ID.Kind = ValID::t_Constant;
2022     return false;
2023   }
2024   case lltok::kw_c:  // c "foo"
2025     Lex.Lex();
2026     ID.ConstantVal = ConstantArray::get(Context, Lex.getStrVal(), false);
2027     if (ParseToken(lltok::StringConstant, "expected string")) return true;
2028     ID.Kind = ValID::t_Constant;
2029     return false;
2030
2031   case lltok::kw_asm: {
2032     // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT
2033     bool HasSideEffect, AlignStack;
2034     Lex.Lex();
2035     if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) ||
2036         ParseOptionalToken(lltok::kw_alignstack, AlignStack) ||
2037         ParseStringConstant(ID.StrVal) ||
2038         ParseToken(lltok::comma, "expected comma in inline asm expression") ||
2039         ParseToken(lltok::StringConstant, "expected constraint string"))
2040       return true;
2041     ID.StrVal2 = Lex.getStrVal();
2042     ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1);
2043     ID.Kind = ValID::t_InlineAsm;
2044     return false;
2045   }
2046
2047   case lltok::kw_blockaddress: {
2048     // ValID ::= 'blockaddress' '(' @foo ',' %bar ')'
2049     Lex.Lex();
2050
2051     ValID Fn, Label;
2052     LocTy FnLoc, LabelLoc;
2053
2054     if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
2055         ParseValID(Fn) ||
2056         ParseToken(lltok::comma, "expected comma in block address expression")||
2057         ParseValID(Label) ||
2058         ParseToken(lltok::rparen, "expected ')' in block address expression"))
2059       return true;
2060
2061     if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
2062       return Error(Fn.Loc, "expected function name in blockaddress");
2063     if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName)
2064       return Error(Label.Loc, "expected basic block name in blockaddress");
2065
2066     // Make a global variable as a placeholder for this reference.
2067     GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context),
2068                                            false, GlobalValue::InternalLinkage,
2069                                                 0, "");
2070     ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef));
2071     ID.ConstantVal = FwdRef;
2072     ID.Kind = ValID::t_Constant;
2073     return false;
2074   }
2075
2076   case lltok::kw_trunc:
2077   case lltok::kw_zext:
2078   case lltok::kw_sext:
2079   case lltok::kw_fptrunc:
2080   case lltok::kw_fpext:
2081   case lltok::kw_bitcast:
2082   case lltok::kw_uitofp:
2083   case lltok::kw_sitofp:
2084   case lltok::kw_fptoui:
2085   case lltok::kw_fptosi:
2086   case lltok::kw_inttoptr:
2087   case lltok::kw_ptrtoint: {
2088     unsigned Opc = Lex.getUIntVal();
2089     PATypeHolder DestTy(Type::getVoidTy(Context));
2090     Constant *SrcVal;
2091     Lex.Lex();
2092     if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") ||
2093         ParseGlobalTypeAndValue(SrcVal) ||
2094         ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") ||
2095         ParseType(DestTy) ||
2096         ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast"))
2097       return true;
2098     if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy))
2099       return Error(ID.Loc, "invalid cast opcode for cast from '" +
2100                    SrcVal->getType()->getDescription() + "' to '" +
2101                    DestTy->getDescription() + "'");
2102     ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc,
2103                                                  SrcVal, DestTy);
2104     ID.Kind = ValID::t_Constant;
2105     return false;
2106   }
2107   case lltok::kw_extractvalue: {
2108     Lex.Lex();
2109     Constant *Val;
2110     SmallVector<unsigned, 4> Indices;
2111     if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")||
2112         ParseGlobalTypeAndValue(Val) ||
2113         ParseIndexList(Indices) ||
2114         ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr"))
2115       return true;
2116     if (Lex.getKind() == lltok::NamedOrCustomMD)
2117       if (ParseOptionalCustomMetadata()) return true;
2118
2119     if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
2120       return Error(ID.Loc, "extractvalue operand must be array or struct");
2121     if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(),
2122                                           Indices.end()))
2123       return Error(ID.Loc, "invalid indices for extractvalue");
2124     ID.ConstantVal =
2125       ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size());
2126     ID.Kind = ValID::t_Constant;
2127     return false;
2128   }
2129   case lltok::kw_insertvalue: {
2130     Lex.Lex();
2131     Constant *Val0, *Val1;
2132     SmallVector<unsigned, 4> Indices;
2133     if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")||
2134         ParseGlobalTypeAndValue(Val0) ||
2135         ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")||
2136         ParseGlobalTypeAndValue(Val1) ||
2137         ParseIndexList(Indices) ||
2138         ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr"))
2139       return true;
2140     if (Lex.getKind() == lltok::NamedOrCustomMD)
2141       if (ParseOptionalCustomMetadata()) return true;
2142     if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType()))
2143       return Error(ID.Loc, "extractvalue operand must be array or struct");
2144     if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
2145                                           Indices.end()))
2146       return Error(ID.Loc, "invalid indices for insertvalue");
2147     ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1,
2148                        Indices.data(), Indices.size());
2149     ID.Kind = ValID::t_Constant;
2150     return false;
2151   }
2152   case lltok::kw_icmp:
2153   case lltok::kw_fcmp: {
2154     unsigned PredVal, Opc = Lex.getUIntVal();
2155     Constant *Val0, *Val1;
2156     Lex.Lex();
2157     if (ParseCmpPredicate(PredVal, Opc) ||
2158         ParseToken(lltok::lparen, "expected '(' in compare constantexpr") ||
2159         ParseGlobalTypeAndValue(Val0) ||
2160         ParseToken(lltok::comma, "expected comma in compare constantexpr") ||
2161         ParseGlobalTypeAndValue(Val1) ||
2162         ParseToken(lltok::rparen, "expected ')' in compare constantexpr"))
2163       return true;
2164
2165     if (Val0->getType() != Val1->getType())
2166       return Error(ID.Loc, "compare operands must have the same type");
2167
2168     CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal;
2169
2170     if (Opc == Instruction::FCmp) {
2171       if (!Val0->getType()->isFPOrFPVector())
2172         return Error(ID.Loc, "fcmp requires floating point operands");
2173       ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1);
2174     } else {
2175       assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!");
2176       if (!Val0->getType()->isIntOrIntVector() &&
2177           !isa<PointerType>(Val0->getType()))
2178         return Error(ID.Loc, "icmp requires pointer or integer operands");
2179       ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1);
2180     }
2181     ID.Kind = ValID::t_Constant;
2182     return false;
2183   }
2184
2185   // Binary Operators.
2186   case lltok::kw_add:
2187   case lltok::kw_fadd:
2188   case lltok::kw_sub:
2189   case lltok::kw_fsub:
2190   case lltok::kw_mul:
2191   case lltok::kw_fmul:
2192   case lltok::kw_udiv:
2193   case lltok::kw_sdiv:
2194   case lltok::kw_fdiv:
2195   case lltok::kw_urem:
2196   case lltok::kw_srem:
2197   case lltok::kw_frem: {
2198     bool NUW = false;
2199     bool NSW = false;
2200     bool Exact = false;
2201     unsigned Opc = Lex.getUIntVal();
2202     Constant *Val0, *Val1;
2203     Lex.Lex();
2204     LocTy ModifierLoc = Lex.getLoc();
2205     if (Opc == Instruction::Add ||
2206         Opc == Instruction::Sub ||
2207         Opc == Instruction::Mul) {
2208       if (EatIfPresent(lltok::kw_nuw))
2209         NUW = true;
2210       if (EatIfPresent(lltok::kw_nsw)) {
2211         NSW = true;
2212         if (EatIfPresent(lltok::kw_nuw))
2213           NUW = true;
2214       }
2215     } else if (Opc == Instruction::SDiv) {
2216       if (EatIfPresent(lltok::kw_exact))
2217         Exact = true;
2218     }
2219     if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") ||
2220         ParseGlobalTypeAndValue(Val0) ||
2221         ParseToken(lltok::comma, "expected comma in binary constantexpr") ||
2222         ParseGlobalTypeAndValue(Val1) ||
2223         ParseToken(lltok::rparen, "expected ')' in binary constantexpr"))
2224       return true;
2225     if (Val0->getType() != Val1->getType())
2226       return Error(ID.Loc, "operands of constexpr must have same type");
2227     if (!Val0->getType()->isIntOrIntVector()) {
2228       if (NUW)
2229         return Error(ModifierLoc, "nuw only applies to integer operations");
2230       if (NSW)
2231         return Error(ModifierLoc, "nsw only applies to integer operations");
2232     }
2233     // API compatibility: Accept either integer or floating-point types with
2234     // add, sub, and mul.
2235     if (!Val0->getType()->isIntOrIntVector() &&
2236         !Val0->getType()->isFPOrFPVector())
2237       return Error(ID.Loc,"constexpr requires integer, fp, or vector operands");
2238     unsigned Flags = 0;
2239     if (NUW)   Flags |= OverflowingBinaryOperator::NoUnsignedWrap;
2240     if (NSW)   Flags |= OverflowingBinaryOperator::NoSignedWrap;
2241     if (Exact) Flags |= SDivOperator::IsExact;
2242     Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags);
2243     ID.ConstantVal = C;
2244     ID.Kind = ValID::t_Constant;
2245     return false;
2246   }
2247
2248   // Logical Operations
2249   case lltok::kw_shl:
2250   case lltok::kw_lshr:
2251   case lltok::kw_ashr:
2252   case lltok::kw_and:
2253   case lltok::kw_or:
2254   case lltok::kw_xor: {
2255     unsigned Opc = Lex.getUIntVal();
2256     Constant *Val0, *Val1;
2257     Lex.Lex();
2258     if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") ||
2259         ParseGlobalTypeAndValue(Val0) ||
2260         ParseToken(lltok::comma, "expected comma in logical constantexpr") ||
2261         ParseGlobalTypeAndValue(Val1) ||
2262         ParseToken(lltok::rparen, "expected ')' in logical constantexpr"))
2263       return true;
2264     if (Val0->getType() != Val1->getType())
2265       return Error(ID.Loc, "operands of constexpr must have same type");
2266     if (!Val0->getType()->isIntOrIntVector())
2267       return Error(ID.Loc,
2268                    "constexpr requires integer or integer vector operands");
2269     ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1);
2270     ID.Kind = ValID::t_Constant;
2271     return false;
2272   }
2273
2274   case lltok::kw_getelementptr:
2275   case lltok::kw_shufflevector:
2276   case lltok::kw_insertelement:
2277   case lltok::kw_extractelement:
2278   case lltok::kw_select: {
2279     unsigned Opc = Lex.getUIntVal();
2280     SmallVector<Constant*, 16> Elts;
2281     bool InBounds = false;
2282     Lex.Lex();
2283     if (Opc == Instruction::GetElementPtr)
2284       InBounds = EatIfPresent(lltok::kw_inbounds);
2285     if (ParseToken(lltok::lparen, "expected '(' in constantexpr") ||
2286         ParseGlobalValueVector(Elts) ||
2287         ParseToken(lltok::rparen, "expected ')' in constantexpr"))
2288       return true;
2289
2290     if (Opc == Instruction::GetElementPtr) {
2291       if (Elts.size() == 0 || !isa<PointerType>(Elts[0]->getType()))
2292         return Error(ID.Loc, "getelementptr requires pointer operand");
2293
2294       if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(),
2295                                              (Value**)(Elts.data() + 1),
2296                                              Elts.size() - 1))
2297         return Error(ID.Loc, "invalid indices for getelementptr");
2298       ID.ConstantVal = InBounds ?
2299         ConstantExpr::getInBoundsGetElementPtr(Elts[0],
2300                                                Elts.data() + 1,
2301                                                Elts.size() - 1) :
2302         ConstantExpr::getGetElementPtr(Elts[0],
2303                                        Elts.data() + 1, Elts.size() - 1);
2304     } else if (Opc == Instruction::Select) {
2305       if (Elts.size() != 3)
2306         return Error(ID.Loc, "expected three operands to select");
2307       if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1],
2308                                                               Elts[2]))
2309         return Error(ID.Loc, Reason);
2310       ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]);
2311     } else if (Opc == Instruction::ShuffleVector) {
2312       if (Elts.size() != 3)
2313         return Error(ID.Loc, "expected three operands to shufflevector");
2314       if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2315         return Error(ID.Loc, "invalid operands to shufflevector");
2316       ID.ConstantVal =
2317                  ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]);
2318     } else if (Opc == Instruction::ExtractElement) {
2319       if (Elts.size() != 2)
2320         return Error(ID.Loc, "expected two operands to extractelement");
2321       if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1]))
2322         return Error(ID.Loc, "invalid extractelement operands");
2323       ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]);
2324     } else {
2325       assert(Opc == Instruction::InsertElement && "Unknown opcode");
2326       if (Elts.size() != 3)
2327       return Error(ID.Loc, "expected three operands to insertelement");
2328       if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2]))
2329         return Error(ID.Loc, "invalid insertelement operands");
2330       ID.ConstantVal =
2331                  ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]);
2332     }
2333
2334     ID.Kind = ValID::t_Constant;
2335     return false;
2336   }
2337   }
2338
2339   Lex.Lex();
2340   return false;
2341 }
2342
2343 /// ParseGlobalValue - Parse a global value with the specified type.
2344 bool LLParser::ParseGlobalValue(const Type *Ty, Constant *&V) {
2345   V = 0;
2346   ValID ID;
2347   return ParseValID(ID) ||
2348          ConvertGlobalValIDToValue(Ty, ID, V);
2349 }
2350
2351 /// ConvertGlobalValIDToValue - Apply a type to a ValID to get a fully resolved
2352 /// constant.
2353 bool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID,
2354                                          Constant *&V) {
2355   if (isa<FunctionType>(Ty))
2356     return Error(ID.Loc, "functions are not values, refer to them as pointers");
2357
2358   switch (ID.Kind) {
2359   default: llvm_unreachable("Unknown ValID!");
2360   case ValID::t_Metadata:
2361     return Error(ID.Loc, "invalid use of metadata");
2362   case ValID::t_LocalID:
2363   case ValID::t_LocalName:
2364     return Error(ID.Loc, "invalid use of function-local name");
2365   case ValID::t_InlineAsm:
2366     return Error(ID.Loc, "inline asm can only be an operand of call/invoke");
2367   case ValID::t_GlobalName:
2368     V = GetGlobalVal(ID.StrVal, Ty, ID.Loc);
2369     return V == 0;
2370   case ValID::t_GlobalID:
2371     V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc);
2372     return V == 0;
2373   case ValID::t_APSInt:
2374     if (!isa<IntegerType>(Ty))
2375       return Error(ID.Loc, "integer constant must have integer type");
2376     ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits());
2377     V = ConstantInt::get(Context, ID.APSIntVal);
2378     return false;
2379   case ValID::t_APFloat:
2380     if (!Ty->isFloatingPoint() ||
2381         !ConstantFP::isValueValidForType(Ty, ID.APFloatVal))
2382       return Error(ID.Loc, "floating point constant invalid for type");
2383
2384     // The lexer has no type info, so builds all float and double FP constants
2385     // as double.  Fix this here.  Long double does not need this.
2386     if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble &&
2387         Ty->isFloatTy()) {
2388       bool Ignored;
2389       ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
2390                             &Ignored);
2391     }
2392     V = ConstantFP::get(Context, ID.APFloatVal);
2393
2394     if (V->getType() != Ty)
2395       return Error(ID.Loc, "floating point constant does not have type '" +
2396                    Ty->getDescription() + "'");
2397
2398     return false;
2399   case ValID::t_Null:
2400     if (!isa<PointerType>(Ty))
2401       return Error(ID.Loc, "null must be a pointer type");
2402     V = ConstantPointerNull::get(cast<PointerType>(Ty));
2403     return false;
2404   case ValID::t_Undef:
2405     // FIXME: LabelTy should not be a first-class type.
2406     if ((!Ty->isFirstClassType() || Ty->isLabelTy()) &&
2407         !isa<OpaqueType>(Ty))
2408       return Error(ID.Loc, "invalid type for undef constant");
2409     V = UndefValue::get(Ty);
2410     return false;
2411   case ValID::t_EmptyArray:
2412     if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0)
2413       return Error(ID.Loc, "invalid empty array initializer");
2414     V = UndefValue::get(Ty);
2415     return false;
2416   case ValID::t_Zero:
2417     // FIXME: LabelTy should not be a first-class type.
2418     if (!Ty->isFirstClassType() || Ty->isLabelTy())
2419       return Error(ID.Loc, "invalid type for null constant");
2420     V = Constant::getNullValue(Ty);
2421     return false;
2422   case ValID::t_Constant:
2423     if (ID.ConstantVal->getType() != Ty)
2424       return Error(ID.Loc, "constant expression type mismatch");
2425     V = ID.ConstantVal;
2426     return false;
2427   }
2428 }
2429
2430 bool LLParser::ParseGlobalTypeAndValue(Constant *&V) {
2431   PATypeHolder Type(Type::getVoidTy(Context));
2432   return ParseType(Type) ||
2433          ParseGlobalValue(Type, V);
2434 }
2435
2436 /// ParseGlobalValueVector
2437 ///   ::= /*empty*/
2438 ///   ::= TypeAndValue (',' TypeAndValue)*
2439 bool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) {
2440   // Empty list.
2441   if (Lex.getKind() == lltok::rbrace ||
2442       Lex.getKind() == lltok::rsquare ||
2443       Lex.getKind() == lltok::greater ||
2444       Lex.getKind() == lltok::rparen)
2445     return false;
2446
2447   Constant *C;
2448   if (ParseGlobalTypeAndValue(C)) return true;
2449   Elts.push_back(C);
2450
2451   while (EatIfPresent(lltok::comma)) {
2452     if (ParseGlobalTypeAndValue(C)) return true;
2453     Elts.push_back(C);
2454   }
2455
2456   return false;
2457 }
2458
2459
2460 //===----------------------------------------------------------------------===//
2461 // Function Parsing.
2462 //===----------------------------------------------------------------------===//
2463
2464 bool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V,
2465                                    PerFunctionState &PFS) {
2466   if (ID.Kind == ValID::t_LocalID)
2467     V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc);
2468   else if (ID.Kind == ValID::t_LocalName)
2469     V = PFS.GetVal(ID.StrVal, Ty, ID.Loc);
2470   else if (ID.Kind == ValID::t_InlineAsm) {
2471     const PointerType *PTy = dyn_cast<PointerType>(Ty);
2472     const FunctionType *FTy =
2473       PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
2474     if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2))
2475       return Error(ID.Loc, "invalid type for inline asm constraint string");
2476     V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, ID.UIntVal>>1);
2477     return false;
2478   } else if (ID.Kind == ValID::t_Metadata) {
2479     V = ID.MetadataVal;
2480   } else {
2481     Constant *C;
2482     if (ConvertGlobalValIDToValue(Ty, ID, C)) return true;
2483     V = C;
2484     return false;
2485   }
2486
2487   return V == 0;
2488 }
2489
2490 bool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) {
2491   V = 0;
2492   ValID ID;
2493   return ParseValID(ID) ||
2494          ConvertValIDToValue(Ty, ID, V, PFS);
2495 }
2496
2497 bool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) {
2498   PATypeHolder T(Type::getVoidTy(Context));
2499   return ParseType(T) ||
2500          ParseValue(T, V, PFS);
2501 }
2502
2503 bool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc,
2504                                       PerFunctionState &PFS) {
2505   Value *V;
2506   Loc = Lex.getLoc();
2507   if (ParseTypeAndValue(V, PFS)) return true;
2508   if (!isa<BasicBlock>(V))
2509     return Error(Loc, "expected a basic block");
2510   BB = cast<BasicBlock>(V);
2511   return false;
2512 }
2513
2514
2515 /// FunctionHeader
2516 ///   ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs
2517 ///       Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection
2518 ///       OptionalAlign OptGC
2519 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
2520   // Parse the linkage.
2521   LocTy LinkageLoc = Lex.getLoc();
2522   unsigned Linkage;
2523
2524   unsigned Visibility, RetAttrs;
2525   CallingConv::ID CC;
2526   PATypeHolder RetType(Type::getVoidTy(Context));
2527   LocTy RetTypeLoc = Lex.getLoc();
2528   if (ParseOptionalLinkage(Linkage) ||
2529       ParseOptionalVisibility(Visibility) ||
2530       ParseOptionalCallingConv(CC) ||
2531       ParseOptionalAttrs(RetAttrs, 1) ||
2532       ParseType(RetType, RetTypeLoc, true /*void allowed*/))
2533     return true;
2534
2535   // Verify that the linkage is ok.
2536   switch ((GlobalValue::LinkageTypes)Linkage) {
2537   case GlobalValue::ExternalLinkage:
2538     break; // always ok.
2539   case GlobalValue::DLLImportLinkage:
2540   case GlobalValue::ExternalWeakLinkage:
2541     if (isDefine)
2542       return Error(LinkageLoc, "invalid linkage for function definition");
2543     break;
2544   case GlobalValue::PrivateLinkage:
2545   case GlobalValue::LinkerPrivateLinkage:
2546   case GlobalValue::InternalLinkage:
2547   case GlobalValue::AvailableExternallyLinkage:
2548   case GlobalValue::LinkOnceAnyLinkage:
2549   case GlobalValue::LinkOnceODRLinkage:
2550   case GlobalValue::WeakAnyLinkage:
2551   case GlobalValue::WeakODRLinkage:
2552   case GlobalValue::DLLExportLinkage:
2553     if (!isDefine)
2554       return Error(LinkageLoc, "invalid linkage for function declaration");
2555     break;
2556   case GlobalValue::AppendingLinkage:
2557   case GlobalValue::GhostLinkage:
2558   case GlobalValue::CommonLinkage:
2559     return Error(LinkageLoc, "invalid function linkage type");
2560   }
2561
2562   if (!FunctionType::isValidReturnType(RetType) ||
2563       isa<OpaqueType>(RetType))
2564     return Error(RetTypeLoc, "invalid function return type");
2565
2566   LocTy NameLoc = Lex.getLoc();
2567
2568   std::string FunctionName;
2569   if (Lex.getKind() == lltok::GlobalVar) {
2570     FunctionName = Lex.getStrVal();
2571   } else if (Lex.getKind() == lltok::GlobalID) {     // @42 is ok.
2572     unsigned NameID = Lex.getUIntVal();
2573
2574     if (NameID != NumberedVals.size())
2575       return TokError("function expected to be numbered '%" +
2576                       utostr(NumberedVals.size()) + "'");
2577   } else {
2578     return TokError("expected function name");
2579   }
2580
2581   Lex.Lex();
2582
2583   if (Lex.getKind() != lltok::lparen)
2584     return TokError("expected '(' in function argument list");
2585
2586   std::vector<ArgInfo> ArgList;
2587   bool isVarArg;
2588   unsigned FuncAttrs;
2589   std::string Section;
2590   unsigned Alignment;
2591   std::string GC;
2592
2593   if (ParseArgumentList(ArgList, isVarArg, false) ||
2594       ParseOptionalAttrs(FuncAttrs, 2) ||
2595       (EatIfPresent(lltok::kw_section) &&
2596        ParseStringConstant(Section)) ||
2597       ParseOptionalAlignment(Alignment) ||
2598       (EatIfPresent(lltok::kw_gc) &&
2599        ParseStringConstant(GC)))
2600     return true;
2601
2602   // If the alignment was parsed as an attribute, move to the alignment field.
2603   if (FuncAttrs & Attribute::Alignment) {
2604     Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs);
2605     FuncAttrs &= ~Attribute::Alignment;
2606   }
2607
2608   // Okay, if we got here, the function is syntactically valid.  Convert types
2609   // and do semantic checks.
2610   std::vector<const Type*> ParamTypeList;
2611   SmallVector<AttributeWithIndex, 8> Attrs;
2612   // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function
2613   // attributes.
2614   unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
2615   if (FuncAttrs & ObsoleteFuncAttrs) {
2616     RetAttrs |= FuncAttrs & ObsoleteFuncAttrs;
2617     FuncAttrs &= ~ObsoleteFuncAttrs;
2618   }
2619
2620   if (RetAttrs != Attribute::None)
2621     Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
2622
2623   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
2624     ParamTypeList.push_back(ArgList[i].Type);
2625     if (ArgList[i].Attrs != Attribute::None)
2626       Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
2627   }
2628
2629   if (FuncAttrs != Attribute::None)
2630     Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs));
2631
2632   AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
2633
2634   if (PAL.paramHasAttr(1, Attribute::StructRet) &&
2635       RetType != Type::getVoidTy(Context))
2636     return Error(RetTypeLoc, "functions with 'sret' argument must return void");
2637
2638   const FunctionType *FT =
2639     FunctionType::get(RetType, ParamTypeList, isVarArg);
2640   const PointerType *PFT = PointerType::getUnqual(FT);
2641
2642   Fn = 0;
2643   if (!FunctionName.empty()) {
2644     // If this was a definition of a forward reference, remove the definition
2645     // from the forward reference table and fill in the forward ref.
2646     std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI =
2647       ForwardRefVals.find(FunctionName);
2648     if (FRVI != ForwardRefVals.end()) {
2649       Fn = M->getFunction(FunctionName);
2650       ForwardRefVals.erase(FRVI);
2651     } else if ((Fn = M->getFunction(FunctionName))) {
2652       // If this function already exists in the symbol table, then it is
2653       // multiply defined.  We accept a few cases for old backwards compat.
2654       // FIXME: Remove this stuff for LLVM 3.0.
2655       if (Fn->getType() != PFT || Fn->getAttributes() != PAL ||
2656           (!Fn->isDeclaration() && isDefine)) {
2657         // If the redefinition has different type or different attributes,
2658         // reject it.  If both have bodies, reject it.
2659         return Error(NameLoc, "invalid redefinition of function '" +
2660                      FunctionName + "'");
2661       } else if (Fn->isDeclaration()) {
2662         // Make sure to strip off any argument names so we can't get conflicts.
2663         for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
2664              AI != AE; ++AI)
2665           AI->setName("");
2666       }
2667     } else if (M->getNamedValue(FunctionName)) {
2668       return Error(NameLoc, "redefinition of function '@" + FunctionName + "'");
2669     }
2670
2671   } else {
2672     // If this is a definition of a forward referenced function, make sure the
2673     // types agree.
2674     std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I
2675       = ForwardRefValIDs.find(NumberedVals.size());
2676     if (I != ForwardRefValIDs.end()) {
2677       Fn = cast<Function>(I->second.first);
2678       if (Fn->getType() != PFT)
2679         return Error(NameLoc, "type of definition and forward reference of '@" +
2680                      utostr(NumberedVals.size()) +"' disagree");
2681       ForwardRefValIDs.erase(I);
2682     }
2683   }
2684
2685   if (Fn == 0)
2686     Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
2687   else // Move the forward-reference to the correct spot in the module.
2688     M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
2689
2690   if (FunctionName.empty())
2691     NumberedVals.push_back(Fn);
2692
2693   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
2694   Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility);
2695   Fn->setCallingConv(CC);
2696   Fn->setAttributes(PAL);
2697   Fn->setAlignment(Alignment);
2698   Fn->setSection(Section);
2699   if (!GC.empty()) Fn->setGC(GC.c_str());
2700
2701   // Add all of the arguments we parsed to the function.
2702   Function::arg_iterator ArgIt = Fn->arg_begin();
2703   for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) {
2704     // If we run out of arguments in the Function prototype, exit early.
2705     // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above.
2706     if (ArgIt == Fn->arg_end()) break;
2707
2708     // If the argument has a name, insert it into the argument symbol table.
2709     if (ArgList[i].Name.empty()) continue;
2710
2711     // Set the name, if it conflicted, it will be auto-renamed.
2712     ArgIt->setName(ArgList[i].Name);
2713
2714     if (ArgIt->getNameStr() != ArgList[i].Name)
2715       return Error(ArgList[i].Loc, "redefinition of argument '%" +
2716                    ArgList[i].Name + "'");
2717   }
2718
2719   return false;
2720 }
2721
2722
2723 /// ParseFunctionBody
2724 ///   ::= '{' BasicBlock+ '}'
2725 ///   ::= 'begin' BasicBlock+ 'end'  // FIXME: remove in LLVM 3.0
2726 ///
2727 bool LLParser::ParseFunctionBody(Function &Fn) {
2728   if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin)
2729     return TokError("expected '{' in function body");
2730   Lex.Lex();  // eat the {.
2731
2732   int FunctionNumber = -1;
2733   if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1;
2734
2735   PerFunctionState PFS(*this, Fn, FunctionNumber);
2736
2737   while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end)
2738     if (ParseBasicBlock(PFS)) return true;
2739
2740   // Eat the }.
2741   Lex.Lex();
2742
2743   // Verify function is ok.
2744   return PFS.FinishFunction();
2745 }
2746
2747 /// ParseBasicBlock
2748 ///   ::= LabelStr? Instruction*
2749 bool LLParser::ParseBasicBlock(PerFunctionState &PFS) {
2750   // If this basic block starts out with a name, remember it.
2751   std::string Name;
2752   LocTy NameLoc = Lex.getLoc();
2753   if (Lex.getKind() == lltok::LabelStr) {
2754     Name = Lex.getStrVal();
2755     Lex.Lex();
2756   }
2757
2758   BasicBlock *BB = PFS.DefineBB(Name, NameLoc);
2759   if (BB == 0) return true;
2760
2761   std::string NameStr;
2762
2763   // Parse the instructions in this block until we get a terminator.
2764   Instruction *Inst;
2765   do {
2766     // This instruction may have three possibilities for a name: a) none
2767     // specified, b) name specified "%foo =", c) number specified: "%4 =".
2768     LocTy NameLoc = Lex.getLoc();
2769     int NameID = -1;
2770     NameStr = "";
2771
2772     if (Lex.getKind() == lltok::LocalVarID) {
2773       NameID = Lex.getUIntVal();
2774       Lex.Lex();
2775       if (ParseToken(lltok::equal, "expected '=' after instruction id"))
2776         return true;
2777     } else if (Lex.getKind() == lltok::LocalVar ||
2778                // FIXME: REMOVE IN LLVM 3.0
2779                Lex.getKind() == lltok::StringConstant) {
2780       NameStr = Lex.getStrVal();
2781       Lex.Lex();
2782       if (ParseToken(lltok::equal, "expected '=' after instruction name"))
2783         return true;
2784     }
2785
2786     if (ParseInstruction(Inst, BB, PFS)) return true;
2787     if (EatIfPresent(lltok::comma))
2788       ParseOptionalCustomMetadata();
2789
2790     // Set metadata attached with this instruction.
2791     MetadataContext &TheMetadata = M->getContext().getMetadata();
2792     for (SmallVector<std::pair<unsigned, MDNode *>, 2>::iterator
2793            MDI = MDsOnInst.begin(), MDE = MDsOnInst.end(); MDI != MDE; ++MDI)
2794       TheMetadata.addMD(MDI->first, MDI->second, Inst);
2795     MDsOnInst.clear();
2796
2797     BB->getInstList().push_back(Inst);
2798
2799     // Set the name on the instruction.
2800     if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true;
2801   } while (!isa<TerminatorInst>(Inst));
2802
2803   return false;
2804 }
2805
2806 //===----------------------------------------------------------------------===//
2807 // Instruction Parsing.
2808 //===----------------------------------------------------------------------===//
2809
2810 /// ParseInstruction - Parse one of the many different instructions.
2811 ///
2812 bool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB,
2813                                 PerFunctionState &PFS) {
2814   lltok::Kind Token = Lex.getKind();
2815   if (Token == lltok::Eof)
2816     return TokError("found end of file when expecting more instructions");
2817   LocTy Loc = Lex.getLoc();
2818   unsigned KeywordVal = Lex.getUIntVal();
2819   Lex.Lex();  // Eat the keyword.
2820
2821   switch (Token) {
2822   default:                    return Error(Loc, "expected instruction opcode");
2823   // Terminator Instructions.
2824   case lltok::kw_unwind:      Inst = new UnwindInst(Context); return false;
2825   case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false;
2826   case lltok::kw_ret:         return ParseRet(Inst, BB, PFS);
2827   case lltok::kw_br:          return ParseBr(Inst, PFS);
2828   case lltok::kw_switch:      return ParseSwitch(Inst, PFS);
2829   case lltok::kw_indirectbr:  return ParseIndirectBr(Inst, PFS);
2830   case lltok::kw_invoke:      return ParseInvoke(Inst, PFS);
2831   // Binary Operators.
2832   case lltok::kw_add:
2833   case lltok::kw_sub:
2834   case lltok::kw_mul: {
2835     bool NUW = false;
2836     bool NSW = false;
2837     LocTy ModifierLoc = Lex.getLoc();
2838     if (EatIfPresent(lltok::kw_nuw))
2839       NUW = true;
2840     if (EatIfPresent(lltok::kw_nsw)) {
2841       NSW = true;
2842       if (EatIfPresent(lltok::kw_nuw))
2843         NUW = true;
2844     }
2845     // API compatibility: Accept either integer or floating-point types.
2846     bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 0);
2847     if (!Result) {
2848       if (!Inst->getType()->isIntOrIntVector()) {
2849         if (NUW)
2850           return Error(ModifierLoc, "nuw only applies to integer operations");
2851         if (NSW)
2852           return Error(ModifierLoc, "nsw only applies to integer operations");
2853       }
2854       if (NUW)
2855         cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true);
2856       if (NSW)
2857         cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true);
2858     }
2859     return Result;
2860   }
2861   case lltok::kw_fadd:
2862   case lltok::kw_fsub:
2863   case lltok::kw_fmul:    return ParseArithmetic(Inst, PFS, KeywordVal, 2);
2864
2865   case lltok::kw_sdiv: {
2866     bool Exact = false;
2867     if (EatIfPresent(lltok::kw_exact))
2868       Exact = true;
2869     bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 1);
2870     if (!Result)
2871       if (Exact)
2872         cast<BinaryOperator>(Inst)->setIsExact(true);
2873     return Result;
2874   }
2875
2876   case lltok::kw_udiv:
2877   case lltok::kw_urem:
2878   case lltok::kw_srem:   return ParseArithmetic(Inst, PFS, KeywordVal, 1);
2879   case lltok::kw_fdiv:
2880   case lltok::kw_frem:   return ParseArithmetic(Inst, PFS, KeywordVal, 2);
2881   case lltok::kw_shl:
2882   case lltok::kw_lshr:
2883   case lltok::kw_ashr:
2884   case lltok::kw_and:
2885   case lltok::kw_or:
2886   case lltok::kw_xor:    return ParseLogical(Inst, PFS, KeywordVal);
2887   case lltok::kw_icmp:
2888   case lltok::kw_fcmp:   return ParseCompare(Inst, PFS, KeywordVal);
2889   // Casts.
2890   case lltok::kw_trunc:
2891   case lltok::kw_zext:
2892   case lltok::kw_sext:
2893   case lltok::kw_fptrunc:
2894   case lltok::kw_fpext:
2895   case lltok::kw_bitcast:
2896   case lltok::kw_uitofp:
2897   case lltok::kw_sitofp:
2898   case lltok::kw_fptoui:
2899   case lltok::kw_fptosi:
2900   case lltok::kw_inttoptr:
2901   case lltok::kw_ptrtoint:       return ParseCast(Inst, PFS, KeywordVal);
2902   // Other.
2903   case lltok::kw_select:         return ParseSelect(Inst, PFS);
2904   case lltok::kw_va_arg:         return ParseVA_Arg(Inst, PFS);
2905   case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS);
2906   case lltok::kw_insertelement:  return ParseInsertElement(Inst, PFS);
2907   case lltok::kw_shufflevector:  return ParseShuffleVector(Inst, PFS);
2908   case lltok::kw_phi:            return ParsePHI(Inst, PFS);
2909   case lltok::kw_call:           return ParseCall(Inst, PFS, false);
2910   case lltok::kw_tail:           return ParseCall(Inst, PFS, true);
2911   // Memory.
2912   case lltok::kw_alloca:         return ParseAlloc(Inst, PFS);
2913   case lltok::kw_malloc:         return ParseAlloc(Inst, PFS, BB, false);
2914   case lltok::kw_free:           return ParseFree(Inst, PFS, BB);
2915   case lltok::kw_load:           return ParseLoad(Inst, PFS, false);
2916   case lltok::kw_store:          return ParseStore(Inst, PFS, false);
2917   case lltok::kw_volatile:
2918     if (EatIfPresent(lltok::kw_load))
2919       return ParseLoad(Inst, PFS, true);
2920     else if (EatIfPresent(lltok::kw_store))
2921       return ParseStore(Inst, PFS, true);
2922     else
2923       return TokError("expected 'load' or 'store'");
2924   case lltok::kw_getresult:     return ParseGetResult(Inst, PFS);
2925   case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS);
2926   case lltok::kw_extractvalue:  return ParseExtractValue(Inst, PFS);
2927   case lltok::kw_insertvalue:   return ParseInsertValue(Inst, PFS);
2928   }
2929 }
2930
2931 /// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind.
2932 bool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) {
2933   if (Opc == Instruction::FCmp) {
2934     switch (Lex.getKind()) {
2935     default: TokError("expected fcmp predicate (e.g. 'oeq')");
2936     case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break;
2937     case lltok::kw_one: P = CmpInst::FCMP_ONE; break;
2938     case lltok::kw_olt: P = CmpInst::FCMP_OLT; break;
2939     case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break;
2940     case lltok::kw_ole: P = CmpInst::FCMP_OLE; break;
2941     case lltok::kw_oge: P = CmpInst::FCMP_OGE; break;
2942     case lltok::kw_ord: P = CmpInst::FCMP_ORD; break;
2943     case lltok::kw_uno: P = CmpInst::FCMP_UNO; break;
2944     case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break;
2945     case lltok::kw_une: P = CmpInst::FCMP_UNE; break;
2946     case lltok::kw_ult: P = CmpInst::FCMP_ULT; break;
2947     case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break;
2948     case lltok::kw_ule: P = CmpInst::FCMP_ULE; break;
2949     case lltok::kw_uge: P = CmpInst::FCMP_UGE; break;
2950     case lltok::kw_true: P = CmpInst::FCMP_TRUE; break;
2951     case lltok::kw_false: P = CmpInst::FCMP_FALSE; break;
2952     }
2953   } else {
2954     switch (Lex.getKind()) {
2955     default: TokError("expected icmp predicate (e.g. 'eq')");
2956     case lltok::kw_eq:  P = CmpInst::ICMP_EQ; break;
2957     case lltok::kw_ne:  P = CmpInst::ICMP_NE; break;
2958     case lltok::kw_slt: P = CmpInst::ICMP_SLT; break;
2959     case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break;
2960     case lltok::kw_sle: P = CmpInst::ICMP_SLE; break;
2961     case lltok::kw_sge: P = CmpInst::ICMP_SGE; break;
2962     case lltok::kw_ult: P = CmpInst::ICMP_ULT; break;
2963     case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break;
2964     case lltok::kw_ule: P = CmpInst::ICMP_ULE; break;
2965     case lltok::kw_uge: P = CmpInst::ICMP_UGE; break;
2966     }
2967   }
2968   Lex.Lex();
2969   return false;
2970 }
2971
2972 //===----------------------------------------------------------------------===//
2973 // Terminator Instructions.
2974 //===----------------------------------------------------------------------===//
2975
2976 /// ParseRet - Parse a return instruction.
2977 ///   ::= 'ret' void (',' !dbg, !1)
2978 ///   ::= 'ret' TypeAndValue (',' !dbg, !1)
2979 ///   ::= 'ret' TypeAndValue (',' TypeAndValue)+  (',' !dbg, !1)
2980 ///         [[obsolete: LLVM 3.0]]
2981 bool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB,
2982                         PerFunctionState &PFS) {
2983   PATypeHolder Ty(Type::getVoidTy(Context));
2984   if (ParseType(Ty, true /*void allowed*/)) return true;
2985
2986   if (Ty->isVoidTy()) {
2987     Inst = ReturnInst::Create(Context);
2988     return false;
2989   }
2990
2991   Value *RV;
2992   if (ParseValue(Ty, RV, PFS)) return true;
2993
2994   if (EatIfPresent(lltok::comma)) {
2995     // Parse optional custom metadata, e.g. !dbg
2996     if (Lex.getKind() == lltok::NamedOrCustomMD) {
2997       if (ParseOptionalCustomMetadata()) return true;
2998     } else {
2999       // The normal case is one return value.
3000       // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring use
3001       // of 'ret {i32,i32} {i32 1, i32 2}'
3002       SmallVector<Value*, 8> RVs;
3003       RVs.push_back(RV);
3004
3005       do {
3006         // If optional custom metadata, e.g. !dbg is seen then this is the
3007         // end of MRV.
3008         if (Lex.getKind() == lltok::NamedOrCustomMD)
3009           break;
3010         if (ParseTypeAndValue(RV, PFS)) return true;
3011         RVs.push_back(RV);
3012       } while (EatIfPresent(lltok::comma));
3013
3014       RV = UndefValue::get(PFS.getFunction().getReturnType());
3015       for (unsigned i = 0, e = RVs.size(); i != e; ++i) {
3016         Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv");
3017         BB->getInstList().push_back(I);
3018         RV = I;
3019       }
3020     }
3021   }
3022
3023   Inst = ReturnInst::Create(Context, RV);
3024   return false;
3025 }
3026
3027
3028 /// ParseBr
3029 ///   ::= 'br' TypeAndValue
3030 ///   ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3031 bool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) {
3032   LocTy Loc, Loc2;
3033   Value *Op0;
3034   BasicBlock *Op1, *Op2;
3035   if (ParseTypeAndValue(Op0, Loc, PFS)) return true;
3036
3037   if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) {
3038     Inst = BranchInst::Create(BB);
3039     return false;
3040   }
3041
3042   if (Op0->getType() != Type::getInt1Ty(Context))
3043     return Error(Loc, "branch condition must have 'i1' type");
3044
3045   if (ParseToken(lltok::comma, "expected ',' after branch condition") ||
3046       ParseTypeAndBasicBlock(Op1, Loc, PFS) ||
3047       ParseToken(lltok::comma, "expected ',' after true destination") ||
3048       ParseTypeAndBasicBlock(Op2, Loc2, PFS))
3049     return true;
3050
3051   Inst = BranchInst::Create(Op1, Op2, Op0);
3052   return false;
3053 }
3054
3055 /// ParseSwitch
3056 ///  Instruction
3057 ///    ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']'
3058 ///  JumpTable
3059 ///    ::= (TypeAndValue ',' TypeAndValue)*
3060 bool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) {
3061   LocTy CondLoc, BBLoc;
3062   Value *Cond;
3063   BasicBlock *DefaultBB;
3064   if (ParseTypeAndValue(Cond, CondLoc, PFS) ||
3065       ParseToken(lltok::comma, "expected ',' after switch condition") ||
3066       ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) ||
3067       ParseToken(lltok::lsquare, "expected '[' with switch table"))
3068     return true;
3069
3070   if (!isa<IntegerType>(Cond->getType()))
3071     return Error(CondLoc, "switch condition must have integer type");
3072
3073   // Parse the jump table pairs.
3074   SmallPtrSet<Value*, 32> SeenCases;
3075   SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
3076   while (Lex.getKind() != lltok::rsquare) {
3077     Value *Constant;
3078     BasicBlock *DestBB;
3079
3080     if (ParseTypeAndValue(Constant, CondLoc, PFS) ||
3081         ParseToken(lltok::comma, "expected ',' after case value") ||
3082         ParseTypeAndBasicBlock(DestBB, PFS))
3083       return true;
3084
3085     if (!SeenCases.insert(Constant))
3086       return Error(CondLoc, "duplicate case value in switch");
3087     if (!isa<ConstantInt>(Constant))
3088       return Error(CondLoc, "case value is not a constant integer");
3089
3090     Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
3091   }
3092
3093   Lex.Lex();  // Eat the ']'.
3094
3095   SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size());
3096   for (unsigned i = 0, e = Table.size(); i != e; ++i)
3097     SI->addCase(Table[i].first, Table[i].second);
3098   Inst = SI;
3099   return false;
3100 }
3101
3102 /// ParseIndirectBr
3103 ///  Instruction
3104 ///    ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']'
3105 bool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) {
3106   LocTy AddrLoc;
3107   Value *Address;
3108   if (ParseTypeAndValue(Address, AddrLoc, PFS) ||
3109       ParseToken(lltok::comma, "expected ',' after indirectbr address") ||
3110       ParseToken(lltok::lsquare, "expected '[' with indirectbr"))
3111     return true;
3112
3113   if (!isa<PointerType>(Address->getType()))
3114     return Error(AddrLoc, "indirectbr address must have pointer type");
3115
3116   // Parse the destination list.
3117   SmallVector<BasicBlock*, 16> DestList;
3118
3119   if (Lex.getKind() != lltok::rsquare) {
3120     BasicBlock *DestBB;
3121     if (ParseTypeAndBasicBlock(DestBB, PFS))
3122       return true;
3123     DestList.push_back(DestBB);
3124
3125     while (EatIfPresent(lltok::comma)) {
3126       if (ParseTypeAndBasicBlock(DestBB, PFS))
3127         return true;
3128       DestList.push_back(DestBB);
3129     }
3130   }
3131
3132   if (ParseToken(lltok::rsquare, "expected ']' at end of block list"))
3133     return true;
3134
3135   IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size());
3136   for (unsigned i = 0, e = DestList.size(); i != e; ++i)
3137     IBI->addDestination(DestList[i]);
3138   Inst = IBI;
3139   return false;
3140 }
3141
3142
3143 /// ParseInvoke
3144 ///   ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList
3145 ///       OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue
3146 bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
3147   LocTy CallLoc = Lex.getLoc();
3148   unsigned RetAttrs, FnAttrs;
3149   CallingConv::ID CC;
3150   PATypeHolder RetType(Type::getVoidTy(Context));
3151   LocTy RetTypeLoc;
3152   ValID CalleeID;
3153   SmallVector<ParamInfo, 16> ArgList;
3154
3155   BasicBlock *NormalBB, *UnwindBB;
3156   if (ParseOptionalCallingConv(CC) ||
3157       ParseOptionalAttrs(RetAttrs, 1) ||
3158       ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3159       ParseValID(CalleeID) ||
3160       ParseParameterList(ArgList, PFS) ||
3161       ParseOptionalAttrs(FnAttrs, 2) ||
3162       ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
3163       ParseTypeAndBasicBlock(NormalBB, PFS) ||
3164       ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") ||
3165       ParseTypeAndBasicBlock(UnwindBB, PFS))
3166     return true;
3167
3168   // If RetType is a non-function pointer type, then this is the short syntax
3169   // for the call, which means that RetType is just the return type.  Infer the
3170   // rest of the function argument types from the arguments that are present.
3171   const PointerType *PFTy = 0;
3172   const FunctionType *Ty = 0;
3173   if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3174       !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3175     // Pull out the types of all of the arguments...
3176     std::vector<const Type*> ParamTypes;
3177     for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3178       ParamTypes.push_back(ArgList[i].V->getType());
3179
3180     if (!FunctionType::isValidReturnType(RetType))
3181       return Error(RetTypeLoc, "Invalid result type for LLVM function");
3182
3183     Ty = FunctionType::get(RetType, ParamTypes, false);
3184     PFTy = PointerType::getUnqual(Ty);
3185   }
3186
3187   // Look up the callee.
3188   Value *Callee;
3189   if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
3190
3191   // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
3192   // function attributes.
3193   unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
3194   if (FnAttrs & ObsoleteFuncAttrs) {
3195     RetAttrs |= FnAttrs & ObsoleteFuncAttrs;
3196     FnAttrs &= ~ObsoleteFuncAttrs;
3197   }
3198
3199   // Set up the Attributes for the function.
3200   SmallVector<AttributeWithIndex, 8> Attrs;
3201   if (RetAttrs != Attribute::None)
3202     Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
3203
3204   SmallVector<Value*, 8> Args;
3205
3206   // Loop through FunctionType's arguments and ensure they are specified
3207   // correctly.  Also, gather any parameter attributes.
3208   FunctionType::param_iterator I = Ty->param_begin();
3209   FunctionType::param_iterator E = Ty->param_end();
3210   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3211     const Type *ExpectedTy = 0;
3212     if (I != E) {
3213       ExpectedTy = *I++;
3214     } else if (!Ty->isVarArg()) {
3215       return Error(ArgList[i].Loc, "too many arguments specified");
3216     }
3217
3218     if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3219       return Error(ArgList[i].Loc, "argument is not of expected type '" +
3220                    ExpectedTy->getDescription() + "'");
3221     Args.push_back(ArgList[i].V);
3222     if (ArgList[i].Attrs != Attribute::None)
3223       Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
3224   }
3225
3226   if (I != E)
3227     return Error(CallLoc, "not enough parameters specified for call");
3228
3229   if (FnAttrs != Attribute::None)
3230     Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
3231
3232   // Finish off the Attributes and check them
3233   AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
3234
3235   InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB,
3236                                       Args.begin(), Args.end());
3237   II->setCallingConv(CC);
3238   II->setAttributes(PAL);
3239   Inst = II;
3240   return false;
3241 }
3242
3243
3244
3245 //===----------------------------------------------------------------------===//
3246 // Binary Operators.
3247 //===----------------------------------------------------------------------===//
3248
3249 /// ParseArithmetic
3250 ///  ::= ArithmeticOps TypeAndValue ',' Value
3251 ///
3252 /// If OperandType is 0, then any FP or integer operand is allowed.  If it is 1,
3253 /// then any integer operand is allowed, if it is 2, any fp operand is allowed.
3254 bool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS,
3255                                unsigned Opc, unsigned OperandType) {
3256   LocTy Loc; Value *LHS, *RHS;
3257   if (ParseTypeAndValue(LHS, Loc, PFS) ||
3258       ParseToken(lltok::comma, "expected ',' in arithmetic operation") ||
3259       ParseValue(LHS->getType(), RHS, PFS))
3260     return true;
3261
3262   bool Valid;
3263   switch (OperandType) {
3264   default: llvm_unreachable("Unknown operand type!");
3265   case 0: // int or FP.
3266     Valid = LHS->getType()->isIntOrIntVector() ||
3267             LHS->getType()->isFPOrFPVector();
3268     break;
3269   case 1: Valid = LHS->getType()->isIntOrIntVector(); break;
3270   case 2: Valid = LHS->getType()->isFPOrFPVector(); break;
3271   }
3272
3273   if (!Valid)
3274     return Error(Loc, "invalid operand type for instruction");
3275
3276   Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3277   return false;
3278 }
3279
3280 /// ParseLogical
3281 ///  ::= ArithmeticOps TypeAndValue ',' Value {
3282 bool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS,
3283                             unsigned Opc) {
3284   LocTy Loc; Value *LHS, *RHS;
3285   if (ParseTypeAndValue(LHS, Loc, PFS) ||
3286       ParseToken(lltok::comma, "expected ',' in logical operation") ||
3287       ParseValue(LHS->getType(), RHS, PFS))
3288     return true;
3289
3290   if (!LHS->getType()->isIntOrIntVector())
3291     return Error(Loc,"instruction requires integer or integer vector operands");
3292
3293   Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS);
3294   return false;
3295 }
3296
3297
3298 /// ParseCompare
3299 ///  ::= 'icmp' IPredicates TypeAndValue ',' Value
3300 ///  ::= 'fcmp' FPredicates TypeAndValue ',' Value
3301 bool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS,
3302                             unsigned Opc) {
3303   // Parse the integer/fp comparison predicate.
3304   LocTy Loc;
3305   unsigned Pred;
3306   Value *LHS, *RHS;
3307   if (ParseCmpPredicate(Pred, Opc) ||
3308       ParseTypeAndValue(LHS, Loc, PFS) ||
3309       ParseToken(lltok::comma, "expected ',' after compare value") ||
3310       ParseValue(LHS->getType(), RHS, PFS))
3311     return true;
3312
3313   if (Opc == Instruction::FCmp) {
3314     if (!LHS->getType()->isFPOrFPVector())
3315       return Error(Loc, "fcmp requires floating point operands");
3316     Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3317   } else {
3318     assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!");
3319     if (!LHS->getType()->isIntOrIntVector() &&
3320         !isa<PointerType>(LHS->getType()))
3321       return Error(Loc, "icmp requires integer operands");
3322     Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS);
3323   }
3324   return false;
3325 }
3326
3327 //===----------------------------------------------------------------------===//
3328 // Other Instructions.
3329 //===----------------------------------------------------------------------===//
3330
3331
3332 /// ParseCast
3333 ///   ::= CastOpc TypeAndValue 'to' Type
3334 bool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS,
3335                          unsigned Opc) {
3336   LocTy Loc;  Value *Op;
3337   PATypeHolder DestTy(Type::getVoidTy(Context));
3338   if (ParseTypeAndValue(Op, Loc, PFS) ||
3339       ParseToken(lltok::kw_to, "expected 'to' after cast value") ||
3340       ParseType(DestTy))
3341     return true;
3342
3343   if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
3344     CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
3345     return Error(Loc, "invalid cast opcode for cast from '" +
3346                  Op->getType()->getDescription() + "' to '" +
3347                  DestTy->getDescription() + "'");
3348   }
3349   Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
3350   return false;
3351 }
3352
3353 /// ParseSelect
3354 ///   ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3355 bool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) {
3356   LocTy Loc;
3357   Value *Op0, *Op1, *Op2;
3358   if (ParseTypeAndValue(Op0, Loc, PFS) ||
3359       ParseToken(lltok::comma, "expected ',' after select condition") ||
3360       ParseTypeAndValue(Op1, PFS) ||
3361       ParseToken(lltok::comma, "expected ',' after select value") ||
3362       ParseTypeAndValue(Op2, PFS))
3363     return true;
3364
3365   if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2))
3366     return Error(Loc, Reason);
3367
3368   Inst = SelectInst::Create(Op0, Op1, Op2);
3369   return false;
3370 }
3371
3372 /// ParseVA_Arg
3373 ///   ::= 'va_arg' TypeAndValue ',' Type
3374 bool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) {
3375   Value *Op;
3376   PATypeHolder EltTy(Type::getVoidTy(Context));
3377   LocTy TypeLoc;
3378   if (ParseTypeAndValue(Op, PFS) ||
3379       ParseToken(lltok::comma, "expected ',' after vaarg operand") ||
3380       ParseType(EltTy, TypeLoc))
3381     return true;
3382
3383   if (!EltTy->isFirstClassType())
3384     return Error(TypeLoc, "va_arg requires operand with first class type");
3385
3386   Inst = new VAArgInst(Op, EltTy);
3387   return false;
3388 }
3389
3390 /// ParseExtractElement
3391 ///   ::= 'extractelement' TypeAndValue ',' TypeAndValue
3392 bool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) {
3393   LocTy Loc;
3394   Value *Op0, *Op1;
3395   if (ParseTypeAndValue(Op0, Loc, PFS) ||
3396       ParseToken(lltok::comma, "expected ',' after extract value") ||
3397       ParseTypeAndValue(Op1, PFS))
3398     return true;
3399
3400   if (!ExtractElementInst::isValidOperands(Op0, Op1))
3401     return Error(Loc, "invalid extractelement operands");
3402
3403   Inst = ExtractElementInst::Create(Op0, Op1);
3404   return false;
3405 }
3406
3407 /// ParseInsertElement
3408 ///   ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3409 bool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) {
3410   LocTy Loc;
3411   Value *Op0, *Op1, *Op2;
3412   if (ParseTypeAndValue(Op0, Loc, PFS) ||
3413       ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3414       ParseTypeAndValue(Op1, PFS) ||
3415       ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3416       ParseTypeAndValue(Op2, PFS))
3417     return true;
3418
3419   if (!InsertElementInst::isValidOperands(Op0, Op1, Op2))
3420     return Error(Loc, "invalid insertelement operands");
3421
3422   Inst = InsertElementInst::Create(Op0, Op1, Op2);
3423   return false;
3424 }
3425
3426 /// ParseShuffleVector
3427 ///   ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue
3428 bool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) {
3429   LocTy Loc;
3430   Value *Op0, *Op1, *Op2;
3431   if (ParseTypeAndValue(Op0, Loc, PFS) ||
3432       ParseToken(lltok::comma, "expected ',' after shuffle mask") ||
3433       ParseTypeAndValue(Op1, PFS) ||
3434       ParseToken(lltok::comma, "expected ',' after shuffle value") ||
3435       ParseTypeAndValue(Op2, PFS))
3436     return true;
3437
3438   if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2))
3439     return Error(Loc, "invalid extractelement operands");
3440
3441   Inst = new ShuffleVectorInst(Op0, Op1, Op2);
3442   return false;
3443 }
3444
3445 /// ParsePHI
3446 ///   ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')*
3447 bool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) {
3448   PATypeHolder Ty(Type::getVoidTy(Context));
3449   Value *Op0, *Op1;
3450   LocTy TypeLoc = Lex.getLoc();
3451
3452   if (ParseType(Ty) ||
3453       ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3454       ParseValue(Ty, Op0, PFS) ||
3455       ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3456       ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3457       ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3458     return true;
3459
3460   SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals;
3461   while (1) {
3462     PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1)));
3463
3464     if (!EatIfPresent(lltok::comma))
3465       break;
3466
3467     if (Lex.getKind() == lltok::NamedOrCustomMD)
3468       break;
3469
3470     if (ParseToken(lltok::lsquare, "expected '[' in phi value list") ||
3471         ParseValue(Ty, Op0, PFS) ||
3472         ParseToken(lltok::comma, "expected ',' after insertelement value") ||
3473         ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
3474         ParseToken(lltok::rsquare, "expected ']' in phi value list"))
3475       return true;
3476   }
3477
3478   if (Lex.getKind() == lltok::NamedOrCustomMD)
3479     if (ParseOptionalCustomMetadata()) return true;
3480
3481   if (!Ty->isFirstClassType())
3482     return Error(TypeLoc, "phi node must have first class type");
3483
3484   PHINode *PN = PHINode::Create(Ty);
3485   PN->reserveOperandSpace(PHIVals.size());
3486   for (unsigned i = 0, e = PHIVals.size(); i != e; ++i)
3487     PN->addIncoming(PHIVals[i].first, PHIVals[i].second);
3488   Inst = PN;
3489   return false;
3490 }
3491
3492 /// ParseCall
3493 ///   ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value
3494 ///       ParameterList OptionalAttrs
3495 bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
3496                          bool isTail) {
3497   unsigned RetAttrs, FnAttrs;
3498   CallingConv::ID CC;
3499   PATypeHolder RetType(Type::getVoidTy(Context));
3500   LocTy RetTypeLoc;
3501   ValID CalleeID;
3502   SmallVector<ParamInfo, 16> ArgList;
3503   LocTy CallLoc = Lex.getLoc();
3504
3505   if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) ||
3506       ParseOptionalCallingConv(CC) ||
3507       ParseOptionalAttrs(RetAttrs, 1) ||
3508       ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
3509       ParseValID(CalleeID) ||
3510       ParseParameterList(ArgList, PFS) ||
3511       ParseOptionalAttrs(FnAttrs, 2))
3512     return true;
3513
3514   // If RetType is a non-function pointer type, then this is the short syntax
3515   // for the call, which means that RetType is just the return type.  Infer the
3516   // rest of the function argument types from the arguments that are present.
3517   const PointerType *PFTy = 0;
3518   const FunctionType *Ty = 0;
3519   if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
3520       !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
3521     // Pull out the types of all of the arguments...
3522     std::vector<const Type*> ParamTypes;
3523     for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
3524       ParamTypes.push_back(ArgList[i].V->getType());
3525
3526     if (!FunctionType::isValidReturnType(RetType))
3527       return Error(RetTypeLoc, "Invalid result type for LLVM function");
3528
3529     Ty = FunctionType::get(RetType, ParamTypes, false);
3530     PFTy = PointerType::getUnqual(Ty);
3531   }
3532
3533   // Look up the callee.
3534   Value *Callee;
3535   if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true;
3536
3537   // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional
3538   // function attributes.
3539   unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg;
3540   if (FnAttrs & ObsoleteFuncAttrs) {
3541     RetAttrs |= FnAttrs & ObsoleteFuncAttrs;
3542     FnAttrs &= ~ObsoleteFuncAttrs;
3543   }
3544
3545   // Set up the Attributes for the function.
3546   SmallVector<AttributeWithIndex, 8> Attrs;
3547   if (RetAttrs != Attribute::None)
3548     Attrs.push_back(AttributeWithIndex::get(0, RetAttrs));
3549
3550   SmallVector<Value*, 8> Args;
3551
3552   // Loop through FunctionType's arguments and ensure they are specified
3553   // correctly.  Also, gather any parameter attributes.
3554   FunctionType::param_iterator I = Ty->param_begin();
3555   FunctionType::param_iterator E = Ty->param_end();
3556   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
3557     const Type *ExpectedTy = 0;
3558     if (I != E) {
3559       ExpectedTy = *I++;
3560     } else if (!Ty->isVarArg()) {
3561       return Error(ArgList[i].Loc, "too many arguments specified");
3562     }
3563
3564     if (ExpectedTy && ExpectedTy != ArgList[i].V->getType())
3565       return Error(ArgList[i].Loc, "argument is not of expected type '" +
3566                    ExpectedTy->getDescription() + "'");
3567     Args.push_back(ArgList[i].V);
3568     if (ArgList[i].Attrs != Attribute::None)
3569       Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs));
3570   }
3571
3572   if (I != E)
3573     return Error(CallLoc, "not enough parameters specified for call");
3574
3575   if (FnAttrs != Attribute::None)
3576     Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs));
3577
3578   // Finish off the Attributes and check them
3579   AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end());
3580
3581   CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end());
3582   CI->setTailCall(isTail);
3583   CI->setCallingConv(CC);
3584   CI->setAttributes(PAL);
3585   Inst = CI;
3586   return false;
3587 }
3588
3589 //===----------------------------------------------------------------------===//
3590 // Memory Instructions.
3591 //===----------------------------------------------------------------------===//
3592
3593 /// ParseAlloc
3594 ///   ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)?
3595 ///   ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)?
3596 bool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS,
3597                           BasicBlock* BB, bool isAlloca) {
3598   PATypeHolder Ty(Type::getVoidTy(Context));
3599   Value *Size = 0;
3600   LocTy SizeLoc;
3601   unsigned Alignment = 0;
3602   if (ParseType(Ty)) return true;
3603
3604   if (EatIfPresent(lltok::comma)) {
3605     if (Lex.getKind() == lltok::kw_align
3606         || Lex.getKind() == lltok::NamedOrCustomMD) {
3607       if (ParseOptionalInfo(Alignment)) return true;
3608     } else {
3609       if (ParseTypeAndValue(Size, SizeLoc, PFS)) return true;
3610       if (EatIfPresent(lltok::comma))
3611         if (ParseOptionalInfo(Alignment)) return true;
3612     }
3613   }
3614
3615   if (Size && Size->getType() != Type::getInt32Ty(Context))
3616     return Error(SizeLoc, "element count must be i32");
3617
3618   if (isAlloca) {
3619     Inst = new AllocaInst(Ty, Size, Alignment);
3620     return false;
3621   }
3622
3623   // Autoupgrade old malloc instruction to malloc call.
3624   // FIXME: Remove in LLVM 3.0.
3625   const Type *IntPtrTy = Type::getInt32Ty(Context);
3626   Constant *AllocSize = ConstantExpr::getSizeOf(Ty);
3627   AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, IntPtrTy);
3628   if (!MallocF)
3629     // Prototype malloc as "void *(int32)".
3630     // This function is renamed as "malloc" in ValidateEndOfModule().
3631     MallocF = cast<Function>(
3632        M->getOrInsertFunction("", Type::getInt8PtrTy(Context), IntPtrTy, NULL));
3633   Inst = CallInst::CreateMalloc(BB, IntPtrTy, Ty, AllocSize, Size, MallocF);
3634   return false;
3635 }
3636
3637 /// ParseFree
3638 ///   ::= 'free' TypeAndValue
3639 bool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS,
3640                          BasicBlock* BB) {
3641   Value *Val; LocTy Loc;
3642   if (ParseTypeAndValue(Val, Loc, PFS)) return true;
3643   if (!isa<PointerType>(Val->getType()))
3644     return Error(Loc, "operand to free must be a pointer");
3645   Inst = CallInst::CreateFree(Val, BB);
3646   return false;
3647 }
3648
3649 /// ParseLoad
3650 ///   ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)?
3651 bool LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS,
3652                          bool isVolatile) {
3653   Value *Val; LocTy Loc;
3654   unsigned Alignment = 0;
3655   if (ParseTypeAndValue(Val, Loc, PFS)) return true;
3656
3657   if (EatIfPresent(lltok::comma))
3658     if (ParseOptionalInfo(Alignment)) return true;
3659
3660   if (!isa<PointerType>(Val->getType()) ||
3661       !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType())
3662     return Error(Loc, "load operand must be a pointer to a first class type");
3663
3664   Inst = new LoadInst(Val, "", isVolatile, Alignment);
3665   return false;
3666 }
3667
3668 /// ParseStore
3669 ///   ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)?
3670 bool LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS,
3671                           bool isVolatile) {
3672   Value *Val, *Ptr; LocTy Loc, PtrLoc;
3673   unsigned Alignment = 0;
3674   if (ParseTypeAndValue(Val, Loc, PFS) ||
3675       ParseToken(lltok::comma, "expected ',' after store operand") ||
3676       ParseTypeAndValue(Ptr, PtrLoc, PFS))
3677     return true;
3678
3679   if (EatIfPresent(lltok::comma))
3680     if (ParseOptionalInfo(Alignment)) return true;
3681
3682   if (!isa<PointerType>(Ptr->getType()))
3683     return Error(PtrLoc, "store operand must be a pointer");
3684   if (!Val->getType()->isFirstClassType())
3685     return Error(Loc, "store operand must be a first class value");
3686   if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType())
3687     return Error(Loc, "stored value and pointer type do not match");
3688
3689   Inst = new StoreInst(Val, Ptr, isVolatile, Alignment);
3690   return false;
3691 }
3692
3693 /// ParseGetResult
3694 ///   ::= 'getresult' TypeAndValue ',' i32
3695 /// FIXME: Remove support for getresult in LLVM 3.0
3696 bool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) {
3697   Value *Val; LocTy ValLoc, EltLoc;
3698   unsigned Element;
3699   if (ParseTypeAndValue(Val, ValLoc, PFS) ||
3700       ParseToken(lltok::comma, "expected ',' after getresult operand") ||
3701       ParseUInt32(Element, EltLoc))
3702     return true;
3703
3704   if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
3705     return Error(ValLoc, "getresult inst requires an aggregate operand");
3706   if (!ExtractValueInst::getIndexedType(Val->getType(), Element))
3707     return Error(EltLoc, "invalid getresult index for value");
3708   Inst = ExtractValueInst::Create(Val, Element);
3709   return false;
3710 }
3711
3712 /// ParseGetElementPtr
3713 ///   ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
3714 bool LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
3715   Value *Ptr, *Val; LocTy Loc, EltLoc;
3716
3717   bool InBounds = EatIfPresent(lltok::kw_inbounds);
3718
3719   if (ParseTypeAndValue(Ptr, Loc, PFS)) return true;
3720
3721   if (!isa<PointerType>(Ptr->getType()))
3722     return Error(Loc, "base of getelementptr must be a pointer");
3723
3724   SmallVector<Value*, 16> Indices;
3725   while (EatIfPresent(lltok::comma)) {
3726     if (Lex.getKind() == lltok::NamedOrCustomMD)
3727       break;
3728     if (ParseTypeAndValue(Val, EltLoc, PFS)) return true;
3729     if (!isa<IntegerType>(Val->getType()))
3730       return Error(EltLoc, "getelementptr index must be an integer");
3731     Indices.push_back(Val);
3732   }
3733   if (Lex.getKind() == lltok::NamedOrCustomMD)
3734     if (ParseOptionalCustomMetadata()) return true;
3735
3736   if (!GetElementPtrInst::getIndexedType(Ptr->getType(),
3737                                          Indices.begin(), Indices.end()))
3738     return Error(Loc, "invalid getelementptr indices");
3739   Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end());
3740   if (InBounds)
3741     cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
3742   return false;
3743 }
3744
3745 /// ParseExtractValue
3746 ///   ::= 'extractvalue' TypeAndValue (',' uint32)+
3747 bool LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
3748   Value *Val; LocTy Loc;
3749   SmallVector<unsigned, 4> Indices;
3750   if (ParseTypeAndValue(Val, Loc, PFS) ||
3751       ParseIndexList(Indices))
3752     return true;
3753   if (Lex.getKind() == lltok::NamedOrCustomMD)
3754     if (ParseOptionalCustomMetadata()) return true;
3755
3756   if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType()))
3757     return Error(Loc, "extractvalue operand must be array or struct");
3758
3759   if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(),
3760                                         Indices.end()))
3761     return Error(Loc, "invalid indices for extractvalue");
3762   Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end());
3763   return false;
3764 }
3765
3766 /// ParseInsertValue
3767 ///   ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+
3768 bool LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) {
3769   Value *Val0, *Val1; LocTy Loc0, Loc1;
3770   SmallVector<unsigned, 4> Indices;
3771   if (ParseTypeAndValue(Val0, Loc0, PFS) ||
3772       ParseToken(lltok::comma, "expected comma after insertvalue operand") ||
3773       ParseTypeAndValue(Val1, Loc1, PFS) ||
3774       ParseIndexList(Indices))
3775     return true;
3776   if (Lex.getKind() == lltok::NamedOrCustomMD)
3777     if (ParseOptionalCustomMetadata()) return true;
3778
3779   if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType()))
3780     return Error(Loc0, "extractvalue operand must be array or struct");
3781
3782   if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(),
3783                                         Indices.end()))
3784     return Error(Loc0, "invalid indices for insertvalue");
3785   Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end());
3786   return false;
3787 }
3788
3789 //===----------------------------------------------------------------------===//
3790 // Embedded metadata.
3791 //===----------------------------------------------------------------------===//
3792
3793 /// ParseMDNodeVector
3794 ///   ::= Element (',' Element)*
3795 /// Element
3796 ///   ::= 'null' | TypeAndValue
3797 bool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts) {
3798   assert(Lex.getKind() == lltok::lbrace);
3799   Lex.Lex();
3800   do {
3801     Value *V = 0;
3802     if (Lex.getKind() == lltok::kw_null) {
3803       Lex.Lex();
3804       V = 0;
3805     } else {
3806       PATypeHolder Ty(Type::getVoidTy(Context));
3807       if (ParseType(Ty)) return true;
3808       if (Lex.getKind() == lltok::Metadata) {
3809         Lex.Lex();
3810         MetadataBase *Node = 0;
3811         if (!ParseMDNode(Node))
3812           V = Node;
3813         else {
3814           MetadataBase *MDS = 0;
3815           if (ParseMDString(MDS)) return true;
3816           V = MDS;
3817         }
3818       } else {
3819         Constant *C;
3820         if (ParseGlobalValue(Ty, C)) return true;
3821         V = C;
3822       }
3823     }
3824     Elts.push_back(V);
3825   } while (EatIfPresent(lltok::comma));
3826
3827   return false;
3828 }