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