LLParser.cpp revision e434d277ca5183eeb6f881000732dcf4c8edd52e
1df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===-- LLParser.cpp - Parser Class ---------------------------------------===// 2df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// 3df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// The LLVM Compiler Infrastructure 4df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// 5df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// This file is distributed under the University of Illinois Open Source 6df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// License. See LICENSE.TXT for details. 7df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// 8df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 9df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// 10df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// This file defines the parser class for .ll files. 11df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// 12df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 13df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 14df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "LLParser.h" 15df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/AutoUpgrade.h" 16df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/CallingConv.h" 17df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/Constants.h" 18df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/DerivedTypes.h" 19df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/InlineAsm.h" 20df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/Instructions.h" 21df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/Module.h" 221224c386981f7948f298ed9ad444c40609570f2eDan Gohman#include "llvm/Operator.h" 23df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/ValueSymbolTable.h" 24df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/ADT/SmallPtrSet.h" 25df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/ADT/StringExtras.h" 26c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 27df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#include "llvm/Support/raw_ostream.h" 28df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerusing namespace llvm; 29df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 303ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// Run: module ::= toplevelentity* 31ad7d1e2085a489dbedc65b99bab811771ead1aabChris Lattnerbool LLParser::Run() { 323ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner // Prime the lexer. 333ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); 343ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner 35ad7d1e2085a489dbedc65b99bab811771ead1aabChris Lattner return ParseTopLevelEntities() || 36ad7d1e2085a489dbedc65b99bab811771ead1aabChris Lattner ValidateEndOfModule(); 37df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 38df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 39df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ValidateEndOfModule - Do final validity and sanity checks at the end of the 40df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// module. 41df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ValidateEndOfModule() { 4268afa54033eccda0f55e920cb548588e71a45418Victor Hernandez // Update auto-upgraded malloc calls to "malloc". 43cf4d2f11a1acc12a0f6b50991907e4a998ee9cddChris Lattner // FIXME: Remove in LLVM 3.0. 4413ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez if (MallocF) { 4513ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez MallocF->setName("malloc"); 4613ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez // If setName() does not set the name to "malloc", then there is already a 4713ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez // declaration of "malloc". In that case, iterate over all calls to MallocF 4813ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez // and get them to call the declared "malloc" instead. 4913ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez if (MallocF->getName() != "malloc") { 5009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Constant *RealMallocF = M->getFunction("malloc"); 5168afa54033eccda0f55e920cb548588e71a45418Victor Hernandez if (RealMallocF->getType() != MallocF->getType()) 5268afa54033eccda0f55e920cb548588e71a45418Victor Hernandez RealMallocF = ConstantExpr::getBitCast(RealMallocF, MallocF->getType()); 5368afa54033eccda0f55e920cb548588e71a45418Victor Hernandez MallocF->replaceAllUsesWith(RealMallocF); 5413ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez MallocF->eraseFromParent(); 5513ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez MallocF = NULL; 5613ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez } 5713ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez } 5809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 5909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 6009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // If there are entries in ForwardRefBlockAddresses at this point, they are 6109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // references after the function was defined. Resolve those now. 6209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner while (!ForwardRefBlockAddresses.empty()) { 6309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Okay, we are referencing an already-parsed function, resolve them now. 6409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Function *TheFn = 0; 6509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner const ValID &Fn = ForwardRefBlockAddresses.begin()->first; 6609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (Fn.Kind == ValID::t_GlobalName) 6709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner TheFn = M->getFunction(Fn.StrVal); 6809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner else if (Fn.UIntVal < NumberedVals.size()) 6909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner TheFn = dyn_cast<Function>(NumberedVals[Fn.UIntVal]); 7009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 7109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (TheFn == 0) 7209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return Error(Fn.Loc, "unknown function referenced by blockaddress"); 7309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 7409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Resolve all these references. 7509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (ResolveForwardRefBlockAddresses(TheFn, 7609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ForwardRefBlockAddresses.begin()->second, 7709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 0)) 7809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return true; 7909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 8009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ForwardRefBlockAddresses.erase(ForwardRefBlockAddresses.begin()); 8109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 8209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 8309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 84df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ForwardRefTypes.empty()) 85df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ForwardRefTypes.begin()->second.second, 86df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "use of undefined type named '" + 87df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefTypes.begin()->first + "'"); 88df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ForwardRefTypeIDs.empty()) 89df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ForwardRefTypeIDs.begin()->second.second, 90df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "use of undefined type '%" + 91df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner utostr(ForwardRefTypeIDs.begin()->first) + "'"); 92a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 93df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ForwardRefVals.empty()) 94df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ForwardRefVals.begin()->second.second, 95df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "use of undefined value '@" + ForwardRefVals.begin()->first + 96df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "'"); 97a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 98df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ForwardRefValIDs.empty()) 99df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ForwardRefValIDs.begin()->second.second, 100df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "use of undefined value '@" + 101df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner utostr(ForwardRefValIDs.begin()->first) + "'"); 102a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1031c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel if (!ForwardRefMDNodes.empty()) 1041c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel return Error(ForwardRefMDNodes.begin()->second.second, 1051c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel "use of undefined metadata '!" + 1061c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel utostr(ForwardRefMDNodes.begin()->first) + "'"); 107a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1081c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel 109df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Look for intrinsic functions and CallInst that need to be upgraded 110df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ) 111df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner UpgradeCallsToIntrinsic(FI++); // must be post-increment, as we remove 112a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 113e4b275610a7a05b7ee4c0378a906a6330e4c4ab0Devang Patel // Check debug info intrinsics. 114e4b275610a7a05b7ee4c0378a906a6330e4c4ab0Devang Patel CheckDebugInfoIntrinsics(M); 115df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 116df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 117df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 11809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattnerbool LLParser::ResolveForwardRefBlockAddresses(Function *TheFn, 11909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner std::vector<std::pair<ValID, GlobalValue*> > &Refs, 12009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner PerFunctionState *PFS) { 12109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Loop over all the references, resolving them. 12209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner for (unsigned i = 0, e = Refs.size(); i != e; ++i) { 12309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner BasicBlock *Res; 124cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner if (PFS) { 12509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (Refs[i].first.Kind == ValID::t_LocalName) 12609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Res = PFS->GetBB(Refs[i].first.StrVal, Refs[i].first.Loc); 127cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner else 12809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Res = PFS->GetBB(Refs[i].first.UIntVal, Refs[i].first.Loc); 12909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } else if (Refs[i].first.Kind == ValID::t_LocalID) { 13009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return Error(Refs[i].first.Loc, 131ee7644da4cbc18f95495a5217c6a0c61eb13c767Chris Lattner "cannot take address of numeric label after the function is defined"); 13209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } else { 13309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Res = dyn_cast_or_null<BasicBlock>( 13409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner TheFn->getValueSymbolTable().lookup(Refs[i].first.StrVal)); 13509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 13609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 137cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner if (Res == 0) 13809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return Error(Refs[i].first.Loc, 13909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner "referenced value is not a basic block"); 14009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 14109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Get the BlockAddress for this and update references to use it. 14209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner BlockAddress *BA = BlockAddress::get(TheFn, Res); 14309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Refs[i].second->replaceAllUsesWith(BA); 14409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Refs[i].second->eraseFromParent(); 14509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 14609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return false; 14709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner} 14809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 14909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 150df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 151df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Top-Level Entities 152df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 153df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 154df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseTopLevelEntities() { 155df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (1) { 156df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 157df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: return TokError("expected top-level entity"); 158df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::Eof: return false; 159df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner //case lltok::kw_define: 160df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_declare: if (ParseDeclare()) return true; break; 161df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_define: if (ParseDefine()) return true; break; 162df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_module: if (ParseModuleAsm()) return true; break; 163df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_target: if (ParseTargetDefinition()) return true; break; 164df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_deplibs: if (ParseDepLibs()) return true; break; 165df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_type: if (ParseUnnamedType()) return true; break; 1663845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman case lltok::LocalVarID: if (ParseUnnamedType()) return true; break; 167df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0 168df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::LocalVar: if (ParseNamedType()) return true; break; 1693845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman case lltok::GlobalID: if (ParseUnnamedGlobal()) return true; break; 170df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::GlobalVar: if (ParseNamedGlobal()) return true; break; 171e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner case lltok::exclaim: if (ParseStandaloneMetadata()) return true; break; 1720475c9170e9621292a48c688c3976031be5650bbDevang Patel case lltok::NamedOrCustomMD: if (ParseNamedMetadata()) return true; break; 173df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 174df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // The Global variable production with no name can have many different 175df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // optional leading prefixes, the production is: 176df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // GlobalVar ::= OptionalLinkage OptionalVisibility OptionalThreadLocal 177df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // OptionalAddrSpace ('constant'|'global') ... 1783d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_private : // OptionalLinkage 1793d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_linker_private: // OptionalLinkage 1803d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_internal: // OptionalLinkage 1813d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_weak: // OptionalLinkage 1823d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_weak_odr: // OptionalLinkage 1833d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_linkonce: // OptionalLinkage 1843d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_linkonce_odr: // OptionalLinkage 1853d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_appending: // OptionalLinkage 1863d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_dllexport: // OptionalLinkage 1873d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_common: // OptionalLinkage 1883d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_dllimport: // OptionalLinkage 1893d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_extern_weak: // OptionalLinkage 1903d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_external: { // OptionalLinkage 191df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Linkage, Visibility; 192df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalLinkage(Linkage) || 193df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalVisibility(Visibility) || 194eeb4a84ac8d91fb1d5a7c484a1c7047409faee30Chris Lattner ParseGlobal("", SMLoc(), Linkage, true, Visibility)) 195df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 196df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 197df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 198df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_default: // OptionalVisibility 199df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_hidden: // OptionalVisibility 200df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_protected: { // OptionalVisibility 201df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Visibility; 202df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalVisibility(Visibility) || 203eeb4a84ac8d91fb1d5a7c484a1c7047409faee30Chris Lattner ParseGlobal("", SMLoc(), 0, false, Visibility)) 204df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 205df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 206df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 207a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 208df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_thread_local: // OptionalThreadLocal 209df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_addrspace: // OptionalAddrSpace 210df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_constant: // GlobalType 211df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_global: // GlobalType 212eeb4a84ac8d91fb1d5a7c484a1c7047409faee30Chris Lattner if (ParseGlobal("", SMLoc(), 0, false, 0)) return true; 213df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 214df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 215df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 216df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 217df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 218df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 219df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// toplevelentity 220df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'module' 'asm' STRINGCONSTANT 221df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseModuleAsm() { 222df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_module); 223df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 224a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 225a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar std::string AsmStr; 2263ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::kw_asm, "expected 'module asm'") || 2273ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseStringConstant(AsmStr)) return true; 228a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 229df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const std::string &AsmSoFar = M->getModuleInlineAsm(); 230df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (AsmSoFar.empty()) 2313ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner M->setModuleInlineAsm(AsmStr); 232df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 2333ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner M->setModuleInlineAsm(AsmSoFar+"\n"+AsmStr); 234df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 235df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 236df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 237df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// toplevelentity 238df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'target' 'triple' '=' STRINGCONSTANT 239df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'target' 'datalayout' '=' STRINGCONSTANT 240df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseTargetDefinition() { 241df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_target); 2423ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner std::string Str; 243df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.Lex()) { 244df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: return TokError("unknown target property"); 245df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_triple: 246df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2473ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::equal, "expected '=' after target triple") || 2483ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseStringConstant(Str)) 249df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2503ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner M->setTargetTriple(Str); 251df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 252df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_datalayout: 253df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2543ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::equal, "expected '=' after target datalayout") || 2553ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseStringConstant(Str)) 256df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2573ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner M->setDataLayout(Str); 258df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 259df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 260df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 261df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 262df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// toplevelentity 263df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'deplibs' '=' '[' ']' 264df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'deplibs' '=' '[' STRINGCONSTANT (',' STRINGCONSTANT)* ']' 265df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseDepLibs() { 266df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_deplibs); 2673ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); 2683ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::equal, "expected '=' after deplibs") || 2693ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseToken(lltok::lsquare, "expected '=' after deplibs")) 2703ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return true; 271df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2723ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (EatIfPresent(lltok::rsquare)) 273df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 274a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2753ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner std::string Str; 2763ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseStringConstant(Str)) return true; 2773ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner M->addLibrary(Str); 278df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2793ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner while (EatIfPresent(lltok::comma)) { 2803ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseStringConstant(Str)) return true; 2813ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner M->addLibrary(Str); 282df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 283df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2843ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return ParseToken(lltok::rsquare, "expected ']' at end of list"); 285df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 286df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2873845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// ParseUnnamedType: 288df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'type' type 2893845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// ::= LocalVarID '=' 'type' type 290df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseUnnamedType() { 2913845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman unsigned TypeID = NumberedTypes.size(); 2923845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 2933845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman // Handle the LocalVarID form. 2943845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (Lex.getKind() == lltok::LocalVarID) { 2953845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (Lex.getUIntVal() != TypeID) 2963845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return Error(Lex.getLoc(), "type expected to be numbered '%" + 2973845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman utostr(TypeID) + "'"); 2983845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman Lex.Lex(); // eat LocalVarID; 2993845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 3003845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (ParseToken(lltok::equal, "expected '=' after name")) 3013845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return true; 3023845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman } 3033845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 304df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_type); 305df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy TypeLoc = Lex.getLoc(); 306df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // eat kw_type 307df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3081d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 309df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseType(Ty)) return true; 310a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 311df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // See if this type was previously referenced. 312df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator 313df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI = ForwardRefTypeIDs.find(TypeID); 314df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FI != ForwardRefTypeIDs.end()) { 315c38daba25b66f9a0386fc28861db66e62663310dChris Lattner if (FI->second.first.get() == Ty) 316c38daba25b66f9a0386fc28861db66e62663310dChris Lattner return Error(TypeLoc, "self referential type is invalid"); 317a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 318df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty); 319df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Ty = FI->second.first.get(); 320df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefTypeIDs.erase(FI); 321df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 322a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 323df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NumberedTypes.push_back(Ty); 324a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 325df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 326df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 327df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 328df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// toplevelentity 329df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= LocalVar '=' 'type' type 330df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseNamedType() { 331df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::string Name = Lex.getStrVal(); 332df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy NameLoc = Lex.getLoc(); 3333ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); // eat LocalVar. 334a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3351d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 336a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3373ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::equal, "expected '=' after name") || 3383ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseToken(lltok::kw_type, "expected 'type' after name") || 3393ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseType(Ty)) 3403ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return true; 341a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 342df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set the type name, checking for conflicts as we do so. 343df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool AlreadyExists = M->addTypeName(Name, Ty); 344df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!AlreadyExists) return false; 345df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 346df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // See if this type is a forward reference. We need to eagerly resolve 347df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // types to allow recursive type redefinitions below. 348df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<std::string, std::pair<PATypeHolder, LocTy> >::iterator 349df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI = ForwardRefTypes.find(Name); 350df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FI != ForwardRefTypes.end()) { 351c38daba25b66f9a0386fc28861db66e62663310dChris Lattner if (FI->second.first.get() == Ty) 352c38daba25b66f9a0386fc28861db66e62663310dChris Lattner return Error(NameLoc, "self referential type is invalid"); 353c38daba25b66f9a0386fc28861db66e62663310dChris Lattner 354df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner cast<DerivedType>(FI->second.first.get())->refineAbstractTypeTo(Ty); 355df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Ty = FI->second.first.get(); 356df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefTypes.erase(FI); 357df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 358a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 359df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Inserting a name that is already defined, get the existing name. 360df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const Type *Existing = M->getTypeByName(Name); 361df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Existing && "Conflict but no matching type?!"); 362a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 363df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, this is an attempt to redefine a type. That's okay if 364df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // the redefinition is identical to the original. 365df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: REMOVE REDEFINITIONS IN LLVM 3.0 366df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Existing == Ty) return false; 367a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 368df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Any other kind of (non-equivalent) redefinition is an error. 369df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(NameLoc, "redefinition of type named '" + Name + "' of type '" + 370df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Ty->getDescription() + "'"); 371df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 372df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 373df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 374df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// toplevelentity 375df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'declare' FunctionHeader 376df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseDeclare() { 377df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_declare); 378df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 379a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 380df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Function *F; 381df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseFunctionHeader(F, false); 382df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 383df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 384df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// toplevelentity 385df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'define' FunctionHeader '{' ... 386df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseDefine() { 387df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_define); 388df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 389a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 390df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Function *F; 3913ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return ParseFunctionHeader(F, true) || 3923ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseFunctionBody(*F); 393df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 394df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3953ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ParseGlobalType 3963ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ::= 'constant' 3973ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ::= 'global' 398df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGlobalType(bool &IsConstant) { 399df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::kw_constant) 400df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner IsConstant = true; 401df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else if (Lex.getKind() == lltok::kw_global) 402df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner IsConstant = false; 40335b5107951582f58bf9d6f786fdddbf7811420fdDuncan Sands else { 40435b5107951582f58bf9d6f786fdddbf7811420fdDuncan Sands IsConstant = false; 405df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected 'global' or 'constant'"); 40635b5107951582f58bf9d6f786fdddbf7811420fdDuncan Sands } 407df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 408df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 409df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 410df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 4113845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// ParseUnnamedGlobal: 4123845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// OptionalVisibility ALIAS ... 4133845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// OptionalLinkage OptionalVisibility ... -> global variable 4143845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// GlobalID '=' OptionalVisibility ALIAS ... 4153845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman/// GlobalID '=' OptionalLinkage OptionalVisibility ... -> global variable 4163845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohmanbool LLParser::ParseUnnamedGlobal() { 4173845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman unsigned VarID = NumberedVals.size(); 4183845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman std::string Name; 4193845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman LocTy NameLoc = Lex.getLoc(); 4203845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 4213845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman // Handle the GlobalID form. 4223845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (Lex.getKind() == lltok::GlobalID) { 4233845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (Lex.getUIntVal() != VarID) 4243845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return Error(Lex.getLoc(), "variable expected to be numbered '%" + 4253845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman utostr(VarID) + "'"); 4263845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman Lex.Lex(); // eat GlobalID; 4273845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 4283845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (ParseToken(lltok::equal, "expected '=' after name")) 4293845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return true; 4303845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman } 4313845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 4323845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman bool HasLinkage; 4333845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman unsigned Linkage, Visibility; 4343845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (ParseOptionalLinkage(Linkage, HasLinkage) || 4353845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman ParseOptionalVisibility(Visibility)) 4363845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return true; 437a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 4383845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman if (HasLinkage || Lex.getKind() != lltok::kw_alias) 4393845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); 4403845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman return ParseAlias(Name, NameLoc, Visibility); 4413845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman} 4423845e50edea58edd0f5e0f2b732e0106b53ba279Dan Gohman 443df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseNamedGlobal: 444df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// GlobalVar '=' OptionalVisibility ALIAS ... 445df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// GlobalVar '=' OptionalLinkage OptionalVisibility ... -> global variable 446df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseNamedGlobal() { 447df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::GlobalVar); 448df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy NameLoc = Lex.getLoc(); 449df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::string Name = Lex.getStrVal(); 450df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 451a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 452df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool HasLinkage; 453df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Linkage, Visibility; 454df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::equal, "expected '=' in global variable") || 455df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalLinkage(Linkage, HasLinkage) || 456df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalVisibility(Visibility)) 457df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 458a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 459df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (HasLinkage || Lex.getKind() != lltok::kw_alias) 460df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseGlobal(Name, NameLoc, Linkage, HasLinkage, Visibility); 461df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseAlias(Name, NameLoc, Visibility); 462df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 463df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 464256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel// MDString: 465256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel// ::= '!' STRINGCONSTANT 466442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattnerbool LLParser::ParseMDString(MDString *&Result) { 467256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel std::string Str; 468256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel if (ParseStringConstant(Str)) return true; 469442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner Result = MDString::get(Context, Str); 470256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel return false; 471256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel} 472256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel 473256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel// MDNode: 474256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel// ::= '!' MDNodeNumber 4754a72efc0ad18c1b9c98bb2f0cb881a39a7010b53Chris Lattnerbool LLParser::ParseMDNodeID(MDNode *&Result) { 476256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel // !{ ..., !42, ... } 477256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel unsigned MID = 0; 478e80250ec84e6e3aa916a66acc507241e7bde89c9Chris Lattner if (ParseUInt32(MID)) return true; 479a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 480256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel // Check existing MDNode. 4810834e6a07b1965712781804b0113a8b282f40a5fChris Lattner if (MID < NumberedMetadata.size() && NumberedMetadata[MID] != 0) { 4820834e6a07b1965712781804b0113a8b282f40a5fChris Lattner Result = NumberedMetadata[MID]; 483256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel return false; 484256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel } 485256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel 48642991eeb64ee178bd12ac243b0cfa7b3bde97f49Chris Lattner // Create MDNode forward reference. 48742991eeb64ee178bd12ac243b0cfa7b3bde97f49Chris Lattner 48842991eeb64ee178bd12ac243b0cfa7b3bde97f49Chris Lattner // FIXME: This is not unique enough! 489256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel std::string FwdRefName = "llvm.mdnode.fwdref." + utostr(MID); 490c17300f3c55fb0d44806578cf50f051c98780b61Benjamin Kramer Value *V = MDString::get(Context, FwdRefName); 49142991eeb64ee178bd12ac243b0cfa7b3bde97f49Chris Lattner MDNode *FwdNode = MDNode::get(Context, &V, 1); 492256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel ForwardRefMDNodes[MID] = std::make_pair(FwdNode, Lex.getLoc()); 4930834e6a07b1965712781804b0113a8b282f40a5fChris Lattner 4940834e6a07b1965712781804b0113a8b282f40a5fChris Lattner if (NumberedMetadata.size() <= MID) 4950834e6a07b1965712781804b0113a8b282f40a5fChris Lattner NumberedMetadata.resize(MID+1); 4960834e6a07b1965712781804b0113a8b282f40a5fChris Lattner NumberedMetadata[MID] = FwdNode; 497442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner Result = FwdNode; 498256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel return false; 499a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar} 500256be96457faf173de2ac3f8145077b7e6fb41baDevang Patel 50184d03b11d016821e0a2f31fc14a3cfd24b0df862Chris Lattner/// ParseNamedMetadata: 502eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel/// !foo = !{ !1, !2 } 503eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patelbool LLParser::ParseNamedMetadata() { 5040475c9170e9621292a48c688c3976031be5650bbDevang Patel assert(Lex.getKind() == lltok::NamedOrCustomMD); 505eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel Lex.Lex(); 506eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel std::string Name = Lex.getStrVal(); 507eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel 50884d03b11d016821e0a2f31fc14a3cfd24b0df862Chris Lattner if (ParseToken(lltok::equal, "expected '=' here") || 509e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner ParseToken(lltok::exclaim, "Expected '!' here") || 51084d03b11d016821e0a2f31fc14a3cfd24b0df862Chris Lattner ParseToken(lltok::lbrace, "Expected '{' here")) 511eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel return true; 512eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel 513eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel SmallVector<MetadataBase *, 8> Elts; 514eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel do { 515e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner if (ParseToken(lltok::exclaim, "Expected '!' here")) 51642991eeb64ee178bd12ac243b0cfa7b3bde97f49Chris Lattner return true; 517442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner 51842991eeb64ee178bd12ac243b0cfa7b3bde97f49Chris Lattner // FIXME: This rejects MDStrings. Are they legal in an named MDNode or not? 519442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner MDNode *N = 0; 5204a72efc0ad18c1b9c98bb2f0cb881a39a7010b53Chris Lattner if (ParseMDNodeID(N)) return true; 521eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel Elts.push_back(N); 522eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel } while (EatIfPresent(lltok::comma)); 523eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel 524eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel if (ParseToken(lltok::rbrace, "expected end of metadata node")) 525eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel return true; 526eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel 5271d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson NamedMDNode::Create(Context, Name, Elts.data(), Elts.size(), M); 528eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel return false; 529eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel} 530eff2ab61b5d411fe64ba601d402b7c549644b590Devang Patel 531923078c65d5a37a4f135705300c9feea49487de5Devang Patel/// ParseStandaloneMetadata: 532a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar/// !42 = !{...} 533923078c65d5a37a4f135705300c9feea49487de5Devang Patelbool LLParser::ParseStandaloneMetadata() { 534e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner assert(Lex.getKind() == lltok::exclaim); 535923078c65d5a37a4f135705300c9feea49487de5Devang Patel Lex.Lex(); 536923078c65d5a37a4f135705300c9feea49487de5Devang Patel unsigned MetadataID = 0; 537923078c65d5a37a4f135705300c9feea49487de5Devang Patel 538923078c65d5a37a4f135705300c9feea49487de5Devang Patel LocTy TyLoc; 5391d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 540104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel SmallVector<Value *, 16> Elts; 5413f5132a024960b7d2e226a210c5923c094f036efChris Lattner // FIXME: This doesn't make sense here. Pull braced MD stuff parsing out! 5423f5132a024960b7d2e226a210c5923c094f036efChris Lattner if (ParseUInt32(MetadataID) || 5433f5132a024960b7d2e226a210c5923c094f036efChris Lattner ParseToken(lltok::equal, "expected '=' here") || 5443f5132a024960b7d2e226a210c5923c094f036efChris Lattner ParseType(Ty, TyLoc) || 545e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner ParseToken(lltok::exclaim, "Expected '!' here") || 5463f5132a024960b7d2e226a210c5923c094f036efChris Lattner ParseToken(lltok::lbrace, "Expected '{' here") || 5473f5132a024960b7d2e226a210c5923c094f036efChris Lattner ParseMDNodeVector(Elts) || 5483f5132a024960b7d2e226a210c5923c094f036efChris Lattner ParseToken(lltok::rbrace, "expected end of metadata node")) 549104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel return true; 550104cf9e02b0ed94d4173869a598af6c6972a8660Devang Patel 551647e3016de18d2fc8b0f233a0b356809e3fdcc54Owen Anderson MDNode *Init = MDNode::get(Context, Elts.data(), Elts.size()); 5520834e6a07b1965712781804b0113a8b282f40a5fChris Lattner 5530834e6a07b1965712781804b0113a8b282f40a5fChris Lattner // See if this was forward referenced, if so, handle it. 554e80250ec84e6e3aa916a66acc507241e7bde89c9Chris Lattner std::map<unsigned, std::pair<TrackingVH<MDNode>, LocTy> >::iterator 5551c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel FI = ForwardRefMDNodes.find(MetadataID); 5561c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel if (FI != ForwardRefMDNodes.end()) { 557e80250ec84e6e3aa916a66acc507241e7bde89c9Chris Lattner FI->second.first->replaceAllUsesWith(Init); 5581c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel ForwardRefMDNodes.erase(FI); 5590834e6a07b1965712781804b0113a8b282f40a5fChris Lattner 5600834e6a07b1965712781804b0113a8b282f40a5fChris Lattner assert(NumberedMetadata[MetadataID] == Init && "Tracking VH didn't work"); 5610834e6a07b1965712781804b0113a8b282f40a5fChris Lattner } else { 5620834e6a07b1965712781804b0113a8b282f40a5fChris Lattner if (MetadataID >= NumberedMetadata.size()) 5630834e6a07b1965712781804b0113a8b282f40a5fChris Lattner NumberedMetadata.resize(MetadataID+1); 5640834e6a07b1965712781804b0113a8b282f40a5fChris Lattner 5650834e6a07b1965712781804b0113a8b282f40a5fChris Lattner if (NumberedMetadata[MetadataID] != 0) 5660834e6a07b1965712781804b0113a8b282f40a5fChris Lattner return TokError("Metadata id is already used"); 5670834e6a07b1965712781804b0113a8b282f40a5fChris Lattner NumberedMetadata[MetadataID] = Init; 5681c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel } 5691c7eea60d3cbada2bae54c42fa178078a3ace9b3Devang Patel 570923078c65d5a37a4f135705300c9feea49487de5Devang Patel return false; 571923078c65d5a37a4f135705300c9feea49487de5Devang Patel} 572923078c65d5a37a4f135705300c9feea49487de5Devang Patel 573df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseAlias: 574df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= GlobalVar '=' OptionalVisibility 'alias' OptionalLinkage Aliasee 575df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// Aliasee 576040f758e3abc75bdf6ddb1ce7bea1e1ed1293ccfChris Lattner/// ::= TypeAndValue 577040f758e3abc75bdf6ddb1ce7bea1e1ed1293ccfChris Lattner/// ::= 'bitcast' '(' TypeAndValue 'to' Type ')' 578dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman/// ::= 'getelementptr' 'inbounds'? '(' ... ')' 579df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 580df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// Everything through visibility has already been parsed. 581df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 582df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseAlias(const std::string &Name, LocTy NameLoc, 583df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Visibility) { 584df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::kw_alias); 585df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 586df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Linkage; 587df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy LinkageLoc = Lex.getLoc(); 588df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalLinkage(Linkage)) 589df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 590df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 591df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Linkage != GlobalValue::ExternalLinkage && 592667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands Linkage != GlobalValue::WeakAnyLinkage && 593667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands Linkage != GlobalValue::WeakODRLinkage && 594bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola Linkage != GlobalValue::InternalLinkage && 5953d10a5a75794356a0a568ce283713adc3a963200Bill Wendling Linkage != GlobalValue::PrivateLinkage && 5963d10a5a75794356a0a568ce283713adc3a963200Bill Wendling Linkage != GlobalValue::LinkerPrivateLinkage) 597df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(LinkageLoc, "invalid linkage type for alias"); 598a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 599df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Aliasee; 600df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy AliaseeLoc = Lex.getLoc(); 601040f758e3abc75bdf6ddb1ce7bea1e1ed1293ccfChris Lattner if (Lex.getKind() != lltok::kw_bitcast && 602040f758e3abc75bdf6ddb1ce7bea1e1ed1293ccfChris Lattner Lex.getKind() != lltok::kw_getelementptr) { 603df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalTypeAndValue(Aliasee)) return true; 604df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 605df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // The bitcast dest type is not present, it is implied by the dest type. 606df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ValID ID; 607df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseValID(ID)) return true; 608df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ID.Kind != ValID::t_Constant) 609df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(AliaseeLoc, "invalid aliasee"); 610df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Aliasee = ID.ConstantVal; 611df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 612a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 613df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<PointerType>(Aliasee->getType())) 614df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(AliaseeLoc, "alias must have pointer type"); 615df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 616df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Okay, create the alias but do not insert it into the module yet. 617df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GlobalAlias* GA = new GlobalAlias(Aliasee->getType(), 618df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner (GlobalValue::LinkageTypes)Linkage, Name, 619df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Aliasee); 620df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GA->setVisibility((GlobalValue::VisibilityTypes)Visibility); 621a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 622df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // See if this value already exists in the symbol table. If so, it is either 623df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // a redefinition or a definition of a forward reference. 6241d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner if (GlobalValue *Val = M->getNamedValue(Name)) { 625df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // See if this was a redefinition. If so, there is no entry in 626df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // ForwardRefVals. 627df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator 628df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefVals.find(Name); 629df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I == ForwardRefVals.end()) 630df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(NameLoc, "redefinition of global named '@" + Name + "'"); 631df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 632df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, this was a definition of forward ref. Verify that types 633df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // agree. 634df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val->getType() != GA->getType()) 635df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(NameLoc, 636df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "forward reference and definition of alias have different types"); 637a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 638df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If they agree, just RAUW the old value with the alias and remove the 639df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // forward ref info. 640df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val->replaceAllUsesWith(GA); 641df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val->eraseFromParent(); 642df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals.erase(I); 643df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 644a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 645df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Insert into the module, we know its name won't collide now. 646df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner M->getAliasList().push_back(GA); 647df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(GA->getNameStr() == Name && "Should not be a name conflict!"); 648a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 649df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 650df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 651df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 652df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseGlobal 653df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= GlobalVar '=' OptionalLinkage OptionalVisibility OptionalThreadLocal 654df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// OptionalAddrSpace GlobalType Type Const 655df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= OptionalLinkage OptionalVisibility OptionalThreadLocal 656df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// OptionalAddrSpace GlobalType Type Const 657df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 658df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// Everything through visibility has been parsed already. 659df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 660df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGlobal(const std::string &Name, LocTy NameLoc, 661df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Linkage, bool HasLinkage, 662df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Visibility) { 663df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned AddrSpace; 664df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool ThreadLocal, IsConstant; 665df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy TyLoc; 666a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 6671d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 668df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalToken(lltok::kw_thread_local, ThreadLocal) || 669df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAddrSpace(AddrSpace) || 670df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalType(IsConstant) || 671df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseType(Ty, TyLoc)) 672df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 673a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 674df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If the linkage is specified and is external, then no initializer is 675df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // present. 676df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Init = 0; 677df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!HasLinkage || (Linkage != GlobalValue::DLLImportLinkage && 6785f4ee1fc5d00ae55c30fa2ce450c69be4c6d6e63Duncan Sands Linkage != GlobalValue::ExternalWeakLinkage && 679df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Linkage != GlobalValue::ExternalLinkage)) { 680df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalValue(Ty, Init)) 681df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 682df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 683df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 684cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (isa<FunctionType>(Ty) || Ty->isLabelTy()) 6854a2f112a5c774cb1ab3fd890a88ba1db9709f561Chris Lattner return Error(TyLoc, "invalid type for global variable"); 686a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 687df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GlobalVariable *GV = 0; 688df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 689df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // See if the global was forward referenced, if so, use the global. 69091dad87ddc1e69ac5fa8953a583de4185e1dd0d7Chris Lattner if (!Name.empty()) { 6911d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner if (GlobalValue *GVal = M->getNamedValue(Name)) { 6921d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner if (!ForwardRefVals.erase(Name) || !isa<GlobalValue>(GVal)) 6931d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner return Error(NameLoc, "redefinition of global '@" + Name + "'"); 6941d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner GV = cast<GlobalVariable>(GVal); 6951d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner } 696df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 697df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator 698df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefValIDs.find(NumberedVals.size()); 699df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefValIDs.end()) { 700df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV = cast<GlobalVariable>(I->second.first); 701df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs.erase(I); 702df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 703df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 704df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 705df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (GV == 0) { 706a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar GV = new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage, 0, 707e9b11b431308f4766b73cda93e38ec930c912122Owen Anderson Name, 0, false, AddrSpace); 708df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 709df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (GV->getType()->getElementType() != Ty) 710df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(TyLoc, 711df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "forward reference and definition of global have different types"); 712a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 713df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Move the forward-reference to the correct spot in the module. 714df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner M->getGlobalList().splice(M->global_end(), M->getGlobalList(), GV); 715df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 716df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 717df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Name.empty()) 718df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NumberedVals.push_back(GV); 719a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 720df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set the parsed properties on the global. 721df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Init) 722df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setInitializer(Init); 723df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setConstant(IsConstant); 724df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setLinkage((GlobalValue::LinkageTypes)Linkage); 725df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setVisibility((GlobalValue::VisibilityTypes)Visibility); 726df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setThreadLocal(ThreadLocal); 727a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 728df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Parse attributes on the global. 729df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (Lex.getKind() == lltok::comma) { 730df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 731a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 732df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::kw_section) { 733df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 734df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setSection(Lex.getStrVal()); 735df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::StringConstant, "expected global section string")) 736df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 737df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Lex.getKind() == lltok::kw_align) { 738df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Alignment; 739df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalAlignment(Alignment)) return true; 740df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GV->setAlignment(Alignment); 741df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 742df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner TokError("unknown global variable property!"); 743df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 744df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 745a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 746df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 747df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 748df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 749df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 750df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 751df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// GlobalValue Reference/Resolution Routines. 752df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 753df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 754df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// GetGlobalVal - Get a value with the specified name or ID, creating a 755df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// forward reference record if needed. This can return null if the value 756df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// exists but does not have the right type. 757df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerGlobalValue *LLParser::GetGlobalVal(const std::string &Name, const Type *Ty, 758df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc) { 759df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const PointerType *PTy = dyn_cast<PointerType>(Ty); 760df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (PTy == 0) { 761df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Error(Loc, "global variable reference must have pointer type"); 762df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 763df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 764a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 765df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Look this name up in the normal function symbol table. 766df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GlobalValue *Val = 767df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner cast_or_null<GlobalValue>(M->getValueSymbolTable().lookup(Name)); 768a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 769df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this is a forward reference for the value, see if we already created a 770df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // forward ref record. 771df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val == 0) { 772df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator 773df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefVals.find(Name); 774df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefVals.end()) 775df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val = I->second.first; 776df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 777a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 778df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If we have the value in the symbol table or fwd-ref table, return it. 779df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val) { 780df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val->getType() == Ty) return Val; 781df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Error(Loc, "'@" + Name + "' defined with type '" + 782df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val->getType()->getDescription() + "'"); 783df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 784df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 785a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 786df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, create a new forward reference for this value and remember it. 787df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GlobalValue *FwdVal; 7881e407c338f6944242facb1e0c32903162cc366f0Chris Lattner if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) { 7891e407c338f6944242facb1e0c32903162cc366f0Chris Lattner // Function types can return opaque but functions can't. 7901e407c338f6944242facb1e0c32903162cc366f0Chris Lattner if (isa<OpaqueType>(FT->getReturnType())) { 7911e407c338f6944242facb1e0c32903162cc366f0Chris Lattner Error(Loc, "function may not return opaque type"); 7921e407c338f6944242facb1e0c32903162cc366f0Chris Lattner return 0; 7931e407c338f6944242facb1e0c32903162cc366f0Chris Lattner } 794a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 7955f4ee1fc5d00ae55c30fa2ce450c69be4c6d6e63Duncan Sands FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M); 7961e407c338f6944242facb1e0c32903162cc366f0Chris Lattner } else { 797e9b11b431308f4766b73cda93e38ec930c912122Owen Anderson FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, 798e9b11b431308f4766b73cda93e38ec930c912122Owen Anderson GlobalValue::ExternalWeakLinkage, 0, Name); 7991e407c338f6944242facb1e0c32903162cc366f0Chris Lattner } 800a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 801df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); 802df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return FwdVal; 803df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 804df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 805df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerGlobalValue *LLParser::GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc) { 806df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const PointerType *PTy = dyn_cast<PointerType>(Ty); 807df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (PTy == 0) { 808df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Error(Loc, "global variable reference must have pointer type"); 809df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 810df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 811a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 812df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GlobalValue *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; 813a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 814df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this is a forward reference for the value, see if we already created a 815df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // forward ref record. 816df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val == 0) { 817df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator 818df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefValIDs.find(ID); 819df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefValIDs.end()) 820df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val = I->second.first; 821df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 822a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 823df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If we have the value in the symbol table or fwd-ref table, return it. 824df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val) { 825df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val->getType() == Ty) return Val; 826df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Error(Loc, "'@" + utostr(ID) + "' defined with type '" + 827df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val->getType()->getDescription() + "'"); 828df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 829df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 830a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 831df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, create a new forward reference for this value and remember it. 832df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner GlobalValue *FwdVal; 833830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner if (const FunctionType *FT = dyn_cast<FunctionType>(PTy->getElementType())) { 834830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner // Function types can return opaque but functions can't. 835830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner if (isa<OpaqueType>(FT->getReturnType())) { 8360d8484f2edb1069522f5c3de6467433e0fbe9323Chris Lattner Error(Loc, "function may not return opaque type"); 837830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner return 0; 838830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner } 8395f4ee1fc5d00ae55c30fa2ce450c69be4c6d6e63Duncan Sands FwdVal = Function::Create(FT, GlobalValue::ExternalWeakLinkage, "", M); 840830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner } else { 841e9b11b431308f4766b73cda93e38ec930c912122Owen Anderson FwdVal = new GlobalVariable(*M, PTy->getElementType(), false, 842e9b11b431308f4766b73cda93e38ec930c912122Owen Anderson GlobalValue::ExternalWeakLinkage, 0, ""); 843830703b1bd88511e29eec76b1fd146524bc9c5a1Chris Lattner } 844a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 845df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); 846df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return FwdVal; 847df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 848df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 849df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 850df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 851df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Helper Routines. 852df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 853df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 854df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseToken - If the current token has the specified kind, eat it and return 855df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// success. Otherwise, emit the specified error and return failure. 856df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseToken(lltok::Kind T, const char *ErrMsg) { 857df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() != T) 858df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError(ErrMsg); 859df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 860df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 861df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 862df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 8633ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ParseStringConstant 8643ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ::= StringConstant 8653ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattnerbool LLParser::ParseStringConstant(std::string &Result) { 8663ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (Lex.getKind() != lltok::StringConstant) 8673ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return TokError("expected string constant"); 8683ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Result = Lex.getStrVal(); 8693ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); 8703ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return false; 8713ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner} 8723ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner 8733ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ParseUInt32 8743ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ::= uint32 8753ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattnerbool LLParser::ParseUInt32(unsigned &Val) { 876df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned()) 877df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected integer"); 878df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner uint64_t Val64 = Lex.getAPSIntVal().getLimitedValue(0xFFFFFFFFULL+1); 879df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val64 != unsigned(Val64)) 880df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected 32-bit integer (too large)"); 881df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val = Val64; 882df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 883df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 884df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 885df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 886df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 887df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseOptionalAddrSpace 888df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// := /*empty*/ 889df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// := 'addrspace' '(' uint32 ')' 890df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseOptionalAddrSpace(unsigned &AddrSpace) { 891df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AddrSpace = 0; 8923ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (!EatIfPresent(lltok::kw_addrspace)) 893df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 894df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseToken(lltok::lparen, "expected '(' in address space") || 8953ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseUInt32(AddrSpace) || 896df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in address space"); 897a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar} 898df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 899df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseOptionalAttrs - Parse a potentially empty attribute list. AttrKind 900df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// indicates what kind of attribute list this is: 0: function arg, 1: result, 901df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 2: function attr. 902ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner/// 3: function arg after value: FIXME: REMOVE IN LLVM 3.0 903df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind) { 904df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs = Attribute::None; 905df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy AttrLoc = Lex.getLoc(); 906a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 907df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (1) { 908df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 909df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sext: 910df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_zext: 911ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner // Treat these as signext/zeroext if they occur in the argument list after 912ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner // the value, as in "call i8 @foo(i8 10 sext)". If they occur before the 913ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner // value, as in "call i8 @foo(i8 sext (" then it is part of a constant 914ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner // expr. 915df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: REMOVE THIS IN LLVM 3.0 916ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner if (AttrKind == 3) { 917df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::kw_sext) 918df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs |= Attribute::SExt; 919df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 920df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs |= Attribute::ZExt; 921df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 922df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 923df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FALL THROUGH. 924df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: // End of attributes. 925df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (AttrKind != 2 && (Attrs & Attribute::FunctionOnly)) 926df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(AttrLoc, "invalid use of function-only attribute"); 927a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 928ad9ad7c827b585c018288c89d611d8c97d8d2e7dChris Lattner if (AttrKind != 0 && AttrKind != 3 && (Attrs & Attribute::ParameterOnly)) 929df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(AttrLoc, "invalid use of parameter-only attribute"); 930a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 931df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 932578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_zeroext: Attrs |= Attribute::ZExt; break; 933578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_signext: Attrs |= Attribute::SExt; break; 934578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_inreg: Attrs |= Attribute::InReg; break; 935578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_sret: Attrs |= Attribute::StructRet; break; 936578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_noalias: Attrs |= Attribute::NoAlias; break; 937578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_nocapture: Attrs |= Attribute::NoCapture; break; 938578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_byval: Attrs |= Attribute::ByVal; break; 939578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_nest: Attrs |= Attribute::Nest; break; 940578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel 941578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_noreturn: Attrs |= Attribute::NoReturn; break; 942578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_nounwind: Attrs |= Attribute::NoUnwind; break; 943578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_noinline: Attrs |= Attribute::NoInline; break; 944578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_readnone: Attrs |= Attribute::ReadNone; break; 945578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_readonly: Attrs |= Attribute::ReadOnly; break; 946de86d473fcc18fe769fa9edb075984880ef1a015Dale Johannesen case lltok::kw_inlinehint: Attrs |= Attribute::InlineHint; break; 947578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_alwaysinline: Attrs |= Attribute::AlwaysInline; break; 948578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_optsize: Attrs |= Attribute::OptimizeForSize; break; 949578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_ssp: Attrs |= Attribute::StackProtect; break; 950578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_sspreq: Attrs |= Attribute::StackProtectReq; break; 951578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_noredzone: Attrs |= Attribute::NoRedZone; break; 952578efa920abd218ba75a0fb3c9b8398f4c0a774bDevang Patel case lltok::kw_noimplicitfloat: Attrs |= Attribute::NoImplicitFloat; break; 953c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov case lltok::kw_naked: Attrs |= Attribute::Naked; break; 954a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 955df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_align: { 956df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Alignment; 957df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalAlignment(Alignment)) 958df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 959df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs |= Attribute::constructAlignmentFromInt(Alignment); 960df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner continue; 961df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 962df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 963df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 964df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 965df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 966df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 967df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseOptionalLinkage 968df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= /*empty*/ 969bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola/// ::= 'private' 9703d10a5a75794356a0a568ce283713adc3a963200Bill Wendling/// ::= 'linker_private' 971df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'internal' 972df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'weak' 973667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands/// ::= 'weak_odr' 974df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'linkonce' 975667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands/// ::= 'linkonce_odr' 976df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'appending' 977df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'dllexport' 978df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'common' 979df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'dllimport' 980df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'extern_weak' 981df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'external' 982df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseOptionalLinkage(unsigned &Res, bool &HasLinkage) { 983df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner HasLinkage = false; 984df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 9853d10a5a75794356a0a568ce283713adc3a963200Bill Wendling default: Res=GlobalValue::ExternalLinkage; return false; 9863d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_private: Res = GlobalValue::PrivateLinkage; break; 9873d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_linker_private: Res = GlobalValue::LinkerPrivateLinkage; break; 9883d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_internal: Res = GlobalValue::InternalLinkage; break; 9893d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_weak: Res = GlobalValue::WeakAnyLinkage; break; 9903d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_weak_odr: Res = GlobalValue::WeakODRLinkage; break; 9913d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_linkonce: Res = GlobalValue::LinkOnceAnyLinkage; break; 9923d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_linkonce_odr: Res = GlobalValue::LinkOnceODRLinkage; break; 993266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner case lltok::kw_available_externally: 994266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner Res = GlobalValue::AvailableExternallyLinkage; 995266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner break; 9963d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_appending: Res = GlobalValue::AppendingLinkage; break; 9973d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_dllexport: Res = GlobalValue::DLLExportLinkage; break; 9983d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_common: Res = GlobalValue::CommonLinkage; break; 9993d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_dllimport: Res = GlobalValue::DLLImportLinkage; break; 10003d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_extern_weak: Res = GlobalValue::ExternalWeakLinkage; break; 10013d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case lltok::kw_external: Res = GlobalValue::ExternalLinkage; break; 1002df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1003df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1004df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner HasLinkage = true; 1005df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1006df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1007df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1008df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseOptionalVisibility 1009df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= /*empty*/ 1010df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'default' 1011df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'hidden' 1012df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'protected' 1013a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar/// 1014df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseOptionalVisibility(unsigned &Res) { 1015df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 1016df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: Res = GlobalValue::DefaultVisibility; return false; 1017df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_default: Res = GlobalValue::DefaultVisibility; break; 1018df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_hidden: Res = GlobalValue::HiddenVisibility; break; 1019df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_protected: Res = GlobalValue::ProtectedVisibility; break; 1020df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1021df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1022df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1023df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1024df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1025df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseOptionalCallingConv 1026df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= /*empty*/ 1027df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'ccc' 1028df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'fastcc' 1029df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'coldcc' 1030df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'x86_stdcallcc' 1031df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'x86_fastcallcc' 1032385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov/// ::= 'arm_apcscc' 1033385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov/// ::= 'arm_aapcscc' 1034385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov/// ::= 'arm_aapcs_vfpcc' 1035211a14e476abc9b864ab6a5d5e0bbb86d288b650Anton Korobeynikov/// ::= 'msp430_intrcc' 1036df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'cc' UINT 1037385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov/// 103865c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patelbool LLParser::ParseOptionalCallingConv(CallingConv::ID &CC) { 1039df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 1040df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: CC = CallingConv::C; return false; 1041df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ccc: CC = CallingConv::C; break; 1042df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fastcc: CC = CallingConv::Fast; break; 1043df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_coldcc: CC = CallingConv::Cold; break; 1044df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_x86_stdcallcc: CC = CallingConv::X86_StdCall; break; 1045df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_x86_fastcallcc: CC = CallingConv::X86_FastCall; break; 1046385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov case lltok::kw_arm_apcscc: CC = CallingConv::ARM_APCS; break; 1047385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov case lltok::kw_arm_aapcscc: CC = CallingConv::ARM_AAPCS; break; 1048385f5a99ecc7fee48a7539bc63d3e1d3b5089c0dAnton Korobeynikov case lltok::kw_arm_aapcs_vfpcc:CC = CallingConv::ARM_AAPCS_VFP; break; 1049211a14e476abc9b864ab6a5d5e0bbb86d288b650Anton Korobeynikov case lltok::kw_msp430_intrcc: CC = CallingConv::MSP430_INTR; break; 105065c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel case lltok::kw_cc: { 105165c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel unsigned ArbitraryCC; 105265c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel Lex.Lex(); 105365c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel if (ParseUInt32(ArbitraryCC)) { 105465c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel return true; 105565c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel } else 105665c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel CC = static_cast<CallingConv::ID>(ArbitraryCC); 105765c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel return false; 105865c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel } 105965c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel break; 1060df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1061a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1062df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1063df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1064df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1065df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 10660475c9170e9621292a48c688c3976031be5650bbDevang Patel/// ParseOptionalCustomMetadata 1067f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// ::= /* empty */ 10683f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner/// ::= !dbg !42 (',' !dbg !57)* 10690475c9170e9621292a48c688c3976031be5650bbDevang Patelbool LLParser::ParseOptionalCustomMetadata() { 107052e2031d4a5d76ff37458015a086285dfaceb6d2Chris Lattner if (Lex.getKind() != lltok::NamedOrCustomMD) 1071f633a065de959b32892c51d741d4db010c5d25b1Devang Patel return false; 10720475c9170e9621292a48c688c3976031be5650bbDevang Patel 10733f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner while (1) { 10743f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner std::string Name = Lex.getStrVal(); 10753f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner Lex.Lex(); 107652e2031d4a5d76ff37458015a086285dfaceb6d2Chris Lattner 1077442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner MDNode *Node; 1078e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner if (ParseToken(lltok::exclaim, "expected '!' here") || 1079e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner ParseMDNodeID(Node)) 1080e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner return true; 1081a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 10823f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner unsigned MDK = M->getMDKindID(Name.c_str()); 1083442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner MDsOnInst.push_back(std::make_pair(MDK, Node)); 10843f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner 10853f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner // If this is the end of the list, we're done. 10863f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner if (!EatIfPresent(lltok::comma)) 10873f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner return false; 10883f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner 10893f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner // The next value must be a custom metadata id. 10903f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner if (Lex.getKind() != lltok::NamedOrCustomMD) 10913f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner return TokError("expected more custom metadata ids"); 10923f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner } 1093f633a065de959b32892c51d741d4db010c5d25b1Devang Patel} 1094f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 1095df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseOptionalAlignment 1096df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= /* empty */ 1097df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'align' 4 1098df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseOptionalAlignment(unsigned &Alignment) { 1099df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Alignment = 0; 11003ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (!EatIfPresent(lltok::kw_align)) 11013ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return false; 11023fbb3ab14d86f752a933b5af4e6728c5e57e1155Chris Lattner LocTy AlignLoc = Lex.getLoc(); 11033fbb3ab14d86f752a933b5af4e6728c5e57e1155Chris Lattner if (ParseUInt32(Alignment)) return true; 11043fbb3ab14d86f752a933b5af4e6728c5e57e1155Chris Lattner if (!isPowerOf2_32(Alignment)) 11053fbb3ab14d86f752a933b5af4e6728c5e57e1155Chris Lattner return Error(AlignLoc, "alignment is not a power of two"); 11063fbb3ab14d86f752a933b5af4e6728c5e57e1155Chris Lattner return false; 1107df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1108df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1109f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// ParseOptionalInfo 1110f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// ::= OptionalInfo (',' OptionalInfo)+ 1111f633a065de959b32892c51d741d4db010c5d25b1Devang Patelbool LLParser::ParseOptionalInfo(unsigned &Alignment) { 1112f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 1113f633a065de959b32892c51d741d4db010c5d25b1Devang Patel // FIXME: Handle customized metadata info attached with an instruction. 1114f633a065de959b32892c51d741d4db010c5d25b1Devang Patel do { 11150475c9170e9621292a48c688c3976031be5650bbDevang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) { 11160475c9170e9621292a48c688c3976031be5650bbDevang Patel if (ParseOptionalCustomMetadata()) return true; 1117f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } else if (Lex.getKind() == lltok::kw_align) { 1118f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (ParseOptionalAlignment(Alignment)) return true; 1119f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } else 1120f633a065de959b32892c51d741d4db010c5d25b1Devang Patel return true; 1121f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } while (EatIfPresent(lltok::comma)); 1122a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1123f633a065de959b32892c51d741d4db010c5d25b1Devang Patel return false; 1124df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1125df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1126f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 1127df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseIndexList 1128df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= (',' uint32)+ 1129df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseIndexList(SmallVectorImpl<unsigned> &Indices) { 1130df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() != lltok::comma) 1131df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected ',' as start of index list"); 1132a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 11333ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner while (EatIfPresent(lltok::comma)) { 1134e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 1135e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel break; 1136df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Idx; 11373ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseUInt32(Idx)) return true; 1138df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.push_back(Idx); 1139df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1140a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1141df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1142df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1143df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1144df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 1145df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Type Parsing. 1146df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 1147df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1148df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseType - Parse and resolve a full type. 1149a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattnerbool LLParser::ParseType(PATypeHolder &Result, bool AllowVoid) { 1150a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner LocTy TypeLoc = Lex.getLoc(); 1151df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeRec(Result)) return true; 1152a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1153df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Verify no unresolved uprefs. 1154df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!UpRefs.empty()) 1155df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(UpRefs.back().Loc, "invalid unresolved type up reference"); 1156a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1157cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (!AllowVoid && Result.get()->isVoidTy()) 1158a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner return Error(TypeLoc, "void type only allowed for function results"); 1159a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1160df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1161df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1162df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1163df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// HandleUpRefs - Every time we finish a new layer of types, this function is 1164df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// called. It loops through the UpRefs vector, which is a list of the 1165df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// currently active types. For each type, if the up-reference is contained in 1166df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// the newly completed type, we decrement the level count. When the level 1167df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// count reaches zero, the up-referenced type is the type that is passed in: 1168df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// thus we can complete the cycle. 1169df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 1170df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerPATypeHolder LLParser::HandleUpRefs(const Type *ty) { 1171df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If Ty isn't abstract, or if there are no up-references in it, then there is 1172df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // nothing to resolve here. 1173df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ty->isAbstract() || UpRefs.empty()) return ty; 1174a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1175df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PATypeHolder Ty(ty); 1176df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#if 0 11770e28d76696dce146266cab547033dd895ffd0323David Greene dbgs() << "Type '" << Ty->getDescription() 1178df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner << "' newly formed. Resolving upreferences.\n" 1179df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner << UpRefs.size() << " upreferences active!\n"; 1180df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#endif 1181a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1182df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If we find any resolvable upreferences (i.e., those whose NestingLevel goes 1183df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // to zero), we resolve them all together before we resolve them to Ty. At 1184df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // the end of the loop, if there is anything to resolve to Ty, it will be in 1185df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // this variable. 1186df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner OpaqueType *TypeToResolve = 0; 1187a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1188df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0; i != UpRefs.size(); ++i) { 1189df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Determine if 'Ty' directly contains this up-references 'LastContainedTy'. 1190df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool ContainsType = 1191df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::find(Ty->subtype_begin(), Ty->subtype_end(), 1192df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner UpRefs[i].LastContainedTy) != Ty->subtype_end(); 1193a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1194df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#if 0 11950e28d76696dce146266cab547033dd895ffd0323David Greene dbgs() << " UR#" << i << " - TypeContains(" << Ty->getDescription() << ", " 1196df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner << UpRefs[i].LastContainedTy->getDescription() << ") = " 1197df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner << (ContainsType ? "true" : "false") 1198df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner << " level=" << UpRefs[i].NestingLevel << "\n"; 1199df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#endif 1200df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ContainsType) 1201df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner continue; 1202a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1203df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Decrement level of upreference 1204df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Level = --UpRefs[i].NestingLevel; 1205df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner UpRefs[i].LastContainedTy = Ty; 1206a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1207df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If the Up-reference has a non-zero level, it shouldn't be resolved yet. 1208df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Level != 0) 1209df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner continue; 1210a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1211df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#if 0 12120e28d76696dce146266cab547033dd895ffd0323David Greene dbgs() << " * Resolving upreference for " << UpRefs[i].UpRefTy << "\n"; 1213df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner#endif 1214df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!TypeToResolve) 1215df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner TypeToResolve = UpRefs[i].UpRefTy; 1216df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 1217df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve); 1218df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list. 1219df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner --i; // Do not skip the next element. 1220df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1221a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1222df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (TypeToResolve) 1223df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner TypeToResolve->refineAbstractTypeTo(Ty); 1224a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1225df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Ty; 1226df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1227df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1228df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1229df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseTypeRec - The recursive function used to process the internal 1230df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// implementation details of types. 1231df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseTypeRec(PATypeHolder &Result) { 1232df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 1233df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: 1234df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected type"); 1235df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::Type: 1236df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= 'float' | 'void' (etc) 1237df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Result = Lex.getTyVal(); 1238a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar Lex.Lex(); 1239df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1240df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_opaque: 1241df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= 'opaque' 12420e275dc53880a7f14f8b8c83cc6e0290a215492dOwen Anderson Result = OpaqueType::get(Context); 1243df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1244df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1245df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::lbrace: 1246df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= '{' ... '}' 1247df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseStructType(Result, false)) 1248df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1249df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1250df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::lsquare: 1251df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= '[' ... ']' 1252df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // eat the lsquare. 1253df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseArrayVectorType(Result, false)) 1254df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1255df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1256df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::less: // Either vector or packed struct. 1257df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= '<' ... '>' 12583ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); 12593ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (Lex.getKind() == lltok::lbrace) { 12603ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseStructType(Result, true) || 12613ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseToken(lltok::greater, "expected '>' at end of packed struct")) 1262df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1263df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (ParseArrayVectorType(Result, true)) 1264df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1265df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1266df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::LocalVar: 1267df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::StringConstant: // FIXME: REMOVE IN LLVM 3.0 1268df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= %foo 1269df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (const Type *T = M->getTypeByName(Lex.getStrVal())) { 1270df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Result = T; 1271df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 12720e275dc53880a7f14f8b8c83cc6e0290a215492dOwen Anderson Result = OpaqueType::get(Context); 1273df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefTypes.insert(std::make_pair(Lex.getStrVal(), 1274df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::make_pair(Result, 1275df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getLoc()))); 1276df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner M->addTypeName(Lex.getStrVal(), Result.get()); 1277df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1278df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1279df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1280a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1281df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::LocalVarID: 1282df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= %4 1283df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getUIntVal() < NumberedTypes.size()) 1284df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Result = NumberedTypes[Lex.getUIntVal()]; 1285df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else { 1286df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<PATypeHolder, LocTy> >::iterator 1287df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefTypeIDs.find(Lex.getUIntVal()); 1288df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefTypeIDs.end()) 1289df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Result = I->second.first; 1290df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else { 12910e275dc53880a7f14f8b8c83cc6e0290a215492dOwen Anderson Result = OpaqueType::get(Context); 1292df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefTypeIDs.insert(std::make_pair(Lex.getUIntVal(), 1293df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::make_pair(Result, 1294df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getLoc()))); 1295df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1296df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1297df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1298df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1299df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::backslash: { 1300df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= '\' 4 1301df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 13023ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner unsigned Val; 13033ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseUInt32(Val)) return true; 13040e275dc53880a7f14f8b8c83cc6e0290a215492dOwen Anderson OpaqueType *OT = OpaqueType::get(Context); //Use temporary placeholder. 1305df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner UpRefs.push_back(UpRefRecord(Lex.getLoc(), Val, OT)); 1306df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Result = OT; 1307df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1308df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1309df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1310a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1311a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar // Parse the type suffixes. 1312df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (1) { 1313df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 1314df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // End of type. 1315a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar default: return false; 1316df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1317df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= TypeRec '*' 1318df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::star: 1319cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Result.get()->isLabelTy()) 1320df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("basic block pointers are invalid"); 1321cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Result.get()->isVoidTy()) 1322b9070d3f6309929e47503e2790a368592b4bd201Dan Gohman return TokError("pointers to void are invalid; use i8* instead"); 1323a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!PointerType::isValidElementType(Result.get())) 1324a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky return TokError("pointer to this type is invalid"); 1325debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Result = HandleUpRefs(PointerType::getUnqual(Result.get())); 1326df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1327df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1328df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1329df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // TypeRec ::= TypeRec 'addrspace' '(' uint32 ')' '*' 1330df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_addrspace: { 1331cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Result.get()->isLabelTy()) 1332df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("basic block pointers are invalid"); 1333cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Result.get()->isVoidTy()) 1334b9070d3f6309929e47503e2790a368592b4bd201Dan Gohman return TokError("pointers to void are invalid; use i8* instead"); 1335a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!PointerType::isValidElementType(Result.get())) 1336a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky return TokError("pointer to this type is invalid"); 1337df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned AddrSpace; 1338df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalAddrSpace(AddrSpace) || 1339df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::star, "expected '*' in address space")) 1340df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1341df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1342debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Result = HandleUpRefs(PointerType::get(Result.get(), AddrSpace)); 1343df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1344df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1345a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1346df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner /// Types '(' ArgTypeListI ')' OptFuncAttrs 1347df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::lparen: 1348df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseFunctionType(Result)) 1349df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1350df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1351df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1352df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1353df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1354df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1355df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseParameterList 1356df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '(' ')' 1357df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '(' Arg (',' Arg)* ')' 1358df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// Arg 1359df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= Type OptionalAttributes Value OptionalAttributes 1360df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList, 1361df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PerFunctionState &PFS) { 1362df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in call")) 1363df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1364a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1365df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (Lex.getKind() != lltok::rparen) { 1366df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this isn't the first argument, we need a comma. 1367df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ArgList.empty() && 1368df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' in argument list")) 1369df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1370a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1371df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Parse the argument. 1372df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy ArgLoc; 13731d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder ArgTy(Type::getVoidTy(Context)); 13741971556cc271710b683bc3ca8327c903791c910fVictor Hernandez unsigned ArgAttrs1 = Attribute::None; 13751971556cc271710b683bc3ca8327c903791c910fVictor Hernandez unsigned ArgAttrs2 = Attribute::None; 1376df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *V; 13771971556cc271710b683bc3ca8327c903791c910fVictor Hernandez if (ParseType(ArgTy, ArgLoc)) 1378df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 13791971556cc271710b683bc3ca8327c903791c910fVictor Hernandez 1380287881d51086c4c5b38d109142f97442c9283374Chris Lattner // Otherwise, handle normal operands. 1381287881d51086c4c5b38d109142f97442c9283374Chris Lattner if (ParseOptionalAttrs(ArgAttrs1, 0) || 1382287881d51086c4c5b38d109142f97442c9283374Chris Lattner ParseValue(ArgTy, V, PFS) || 1383287881d51086c4c5b38d109142f97442c9283374Chris Lattner // FIXME: Should not allow attributes after the argument, remove this 1384287881d51086c4c5b38d109142f97442c9283374Chris Lattner // in LLVM 3.0. 1385287881d51086c4c5b38d109142f97442c9283374Chris Lattner ParseOptionalAttrs(ArgAttrs2, 3)) 1386287881d51086c4c5b38d109142f97442c9283374Chris Lattner return true; 1387df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ArgList.push_back(ParamInfo(ArgLoc, V, ArgAttrs1|ArgAttrs2)); 1388df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1389df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1390df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // Lex the ')'. 1391df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1392df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1393df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1394df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1395df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1396dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner/// ParseArgumentList - Parse the argument list for a function type or function 1397dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner/// prototype. If 'inType' is true then we are parsing a FunctionType. 1398df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '(' ArgTypeListI ')' 1399df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ArgTypeListI 1400df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= /*empty*/ 1401df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '...' 1402df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= ArgTypeList ',' '...' 1403df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= ArgType (',' ArgType)* 1404dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner/// 1405df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseArgumentList(std::vector<ArgInfo> &ArgList, 1406dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner bool &isVarArg, bool inType) { 1407df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner isVarArg = false; 1408df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::lparen); 1409df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // eat the (. 1410a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1411df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::rparen) { 1412df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // empty 1413df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Lex.getKind() == lltok::dotdotdot) { 1414df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner isVarArg = true; 1415df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1416df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 1417df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy TypeLoc = Lex.getLoc(); 14181d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder ArgTy(Type::getVoidTy(Context)); 1419df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Attrs; 1420df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::string Name; 1421a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1422dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner // If we're parsing a type, use ParseTypeRec, because we allow recursive 1423dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner // types (such as a function returning a pointer to itself). If parsing a 1424dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner // function prototype, we require fully resolved types. 1425dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || 14263ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseOptionalAttrs(Attrs, 0)) return true; 1427a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1428cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (ArgTy->isVoidTy()) 1429a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner return Error(TypeLoc, "argument can not have void type"); 1430a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1431df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::LocalVar || 1432df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 1433df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Name = Lex.getStrVal(); 1434df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1435df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 14363ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner 1437a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!FunctionType::isValidArgumentType(ArgTy)) 14383ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return Error(TypeLoc, "invalid type for function argument"); 1439a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1440df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); 1441a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 14423ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner while (EatIfPresent(lltok::comma)) { 1443df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Handle ... at end of arg list. 14443ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (EatIfPresent(lltok::dotdotdot)) { 1445df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner isVarArg = true; 1446df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1447df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1448a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1449df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise must be an argument type. 1450df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner TypeLoc = Lex.getLoc(); 1451a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner if ((inType ? ParseTypeRec(ArgTy) : ParseType(ArgTy)) || 14523ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseOptionalAttrs(Attrs, 0)) return true; 14533ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner 1454cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (ArgTy->isVoidTy()) 1455a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner return Error(TypeLoc, "argument can not have void type"); 1456a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner 1457df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::LocalVar || 1458df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getKind() == lltok::StringConstant) { // FIXME: REMOVE IN LLVM 3.0 1459df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Name = Lex.getStrVal(); 1460df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1461df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 1462df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Name = ""; 1463df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 14643ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner 14653ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (!ArgTy->isFirstClassType() && !isa<OpaqueType>(ArgTy)) 14663ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return Error(TypeLoc, "invalid type for function argument"); 1467a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1468df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ArgList.push_back(ArgInfo(TypeLoc, ArgTy, Attrs, Name)); 1469df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1470df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1471a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 14723ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return ParseToken(lltok::rparen, "expected ')' at end of argument list"); 1473df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1474a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1475df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseFunctionType 1476df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= Type ArgumentList OptionalAttrs 1477df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseFunctionType(PATypeHolder &Result) { 1478df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::lparen); 1479df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1480d77d04c323f856b07c6e46450e7578dd09c0165fChris Lattner if (!FunctionType::isValidReturnType(Result)) 1481d77d04c323f856b07c6e46450e7578dd09c0165fChris Lattner return TokError("invalid function return type"); 1482a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1483df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<ArgInfo> ArgList; 1484df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool isVarArg; 1485df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Attrs; 1486dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner if (ParseArgumentList(ArgList, isVarArg, true) || 1487df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: Allow, but ignore attributes on function types! 1488df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: Remove in LLVM 3.0 1489df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAttrs(Attrs, 2)) 1490df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1491a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1492df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Reject names on the arguments lists. 1493df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 1494df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ArgList[i].Name.empty()) 1495df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ArgList[i].Loc, "argument name invalid in function type"); 1496df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ArgList[i].Attrs != 0) { 1497df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Allow but ignore attributes on function types; this permits 1498df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // auto-upgrade. 1499df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: REJECT ATTRIBUTES ON FUNCTION TYPES in LLVM 3.0 1500df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1501df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1502a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1503df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<const Type*> ArgListTy; 1504df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 1505df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ArgListTy.push_back(ArgList[i].Type); 1506a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1507debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Result = HandleUpRefs(FunctionType::get(Result.get(), 1508fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson ArgListTy, isVarArg)); 1509df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1510df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1511df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1512df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseStructType: Handles packed and unpacked types. </> parsed elsewhere. 1513df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// TypeRec 1514df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '{' '}' 1515df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '{' TypeRec (',' TypeRec)* '}' 1516df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '<' '{' '}' '>' 1517df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '<' '{' TypeRec (',' TypeRec)* '}' '>' 1518df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseStructType(PATypeHolder &Result, bool Packed) { 1519df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Lex.getKind() == lltok::lbrace); 1520df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // Consume the '{' 1521a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 15223ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (EatIfPresent(lltok::rbrace)) { 1523d7f2a6cb3fbc012763adb42fd967f6fefbb22a37Owen Anderson Result = StructType::get(Context, Packed); 1524df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1525df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1526df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1527df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<PATypeHolder> ParamsList; 1528a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner LocTy EltTyLoc = Lex.getLoc(); 1529df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeRec(Result)) return true; 1530df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParamsList.push_back(Result); 1531a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1532cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Result->isVoidTy()) 1533a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner return Error(EltTyLoc, "struct element can not have void type"); 1534a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!StructType::isValidElementType(Result)) 1535a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky return Error(EltTyLoc, "invalid element type for struct"); 1536a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 15373ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner while (EatIfPresent(lltok::comma)) { 1538a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner EltTyLoc = Lex.getLoc(); 1539df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeRec(Result)) return true; 1540a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1541cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Result->isVoidTy()) 1542a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner return Error(EltTyLoc, "struct element can not have void type"); 1543a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!StructType::isValidElementType(Result)) 1544a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky return Error(EltTyLoc, "invalid element type for struct"); 1545a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1546df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParamsList.push_back(Result); 1547df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1548a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 15493ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::rbrace, "expected '}' at end of struct")) 15503ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return true; 1551a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1552df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<const Type*> ParamsListTy; 1553df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ParamsList.size(); i != e; ++i) 1554df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParamsListTy.push_back(ParamsList[i].get()); 1555d7f2a6cb3fbc012763adb42fd967f6fefbb22a37Owen Anderson Result = HandleUpRefs(StructType::get(Context, ParamsListTy, Packed)); 1556df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1557df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1558df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1559df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseArrayVectorType - Parse an array or vector type, assuming the first 1560df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// token has already been consumed. 1561a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar/// TypeRec 1562df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '[' APSINTVAL 'x' Types ']' 1563df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '<' APSINTVAL 'x' Types '>' 1564df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseArrayVectorType(PATypeHolder &Result, bool isVector) { 1565df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() != lltok::APSInt || Lex.getAPSIntVal().isSigned() || 1566df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getAPSIntVal().getBitWidth() > 64) 1567df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected number in address space"); 1568a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1569df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy SizeLoc = Lex.getLoc(); 1570df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner uint64_t Size = Lex.getAPSIntVal().getZExtValue(); 15713ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); 1572a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 15733ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::kw_x, "expected 'x' after element count")) 15743ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return true; 1575df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1576df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy TypeLoc = Lex.getLoc(); 15771d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder EltTy(Type::getVoidTy(Context)); 1578df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeRec(EltTy)) return true; 1579a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1580cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (EltTy->isVoidTy()) 1581a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner return Error(TypeLoc, "array and vector element type cannot be void"); 1582a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner 15833ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(isVector ? lltok::greater : lltok::rsquare, 15843ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner "expected end of sequential type")) 15853ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return true; 1586a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1587df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (isVector) { 1588452e2627dc1de4fb5a2b1c9ac999f1b3396f82c7Chris Lattner if (Size == 0) 1589452e2627dc1de4fb5a2b1c9ac999f1b3396f82c7Chris Lattner return Error(SizeLoc, "zero element vector is illegal"); 1590df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if ((unsigned)Size != Size) 1591df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(SizeLoc, "size too large for vector"); 1592a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!VectorType::isValidElementType(EltTy)) 1593df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(TypeLoc, "vector element type must be fp or integer"); 1594debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Result = VectorType::get(EltTy, unsigned(Size)); 1595df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 1596a5f54a06b09acf5c4ed3571039f262128226145bNick Lewycky if (!ArrayType::isValidElementType(EltTy)) 1597df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(TypeLoc, "invalid array element type"); 1598debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Result = HandleUpRefs(ArrayType::get(EltTy, Size)); 1599df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1600df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1601df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1602df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1603df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 1604df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Function Semantic Analysis. 1605df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 1606df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 160709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris LattnerLLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f, 160809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner int functionNumber) 160909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner : P(p), F(f), FunctionNumber(functionNumber) { 1610df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1611df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Insert unnamed arguments into the NumberedVals list. 1612df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); 1613df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AI != E; ++AI) 1614df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!AI->hasName()) 1615df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NumberedVals.push_back(AI); 1616df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1617df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1618df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerLLParser::PerFunctionState::~PerFunctionState() { 1619df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If there were any forward referenced non-basicblock values, delete them. 1620df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (std::map<std::string, std::pair<Value*, LocTy> >::iterator 1621df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefVals.begin(), E = ForwardRefVals.end(); I != E; ++I) 1622df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<BasicBlock>(I->second.first)) { 1623b43eae745eb9a7c46fe76b0ed8053b782ca67536Owen Anderson I->second.first->replaceAllUsesWith( 16249e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson UndefValue::get(I->second.first->getType())); 1625df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner delete I->second.first; 1626df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I->second.first = 0; 1627df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1628a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1629df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (std::map<unsigned, std::pair<Value*, LocTy> >::iterator 1630df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefValIDs.begin(), E = ForwardRefValIDs.end(); I != E; ++I) 1631df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<BasicBlock>(I->second.first)) { 1632b43eae745eb9a7c46fe76b0ed8053b782ca67536Owen Anderson I->second.first->replaceAllUsesWith( 16339e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson UndefValue::get(I->second.first->getType())); 1634df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner delete I->second.first; 1635df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I->second.first = 0; 1636df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1637df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1638df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 163909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattnerbool LLParser::PerFunctionState::FinishFunction() { 164009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Check to see if someone took the address of labels in this block. 164109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (!P.ForwardRefBlockAddresses.empty()) { 164209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ValID FunctionID; 164309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (!F.getName().empty()) { 164409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner FunctionID.Kind = ValID::t_GlobalName; 164509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner FunctionID.StrVal = F.getName(); 164609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } else { 164709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner FunctionID.Kind = ValID::t_GlobalID; 164809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner FunctionID.UIntVal = FunctionNumber; 164909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 165009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 165109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > >::iterator 165209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner FRBAI = P.ForwardRefBlockAddresses.find(FunctionID); 165309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (FRBAI != P.ForwardRefBlockAddresses.end()) { 165409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Resolve all these references. 165509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (P.ResolveForwardRefBlockAddresses(&F, FRBAI->second, this)) 165609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return true; 165709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 165809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner P.ForwardRefBlockAddresses.erase(FRBAI); 165909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 166009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 166109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 1662df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ForwardRefVals.empty()) 1663df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return P.Error(ForwardRefVals.begin()->second.second, 1664df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "use of undefined value '%" + ForwardRefVals.begin()->first + 1665df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "'"); 1666df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ForwardRefValIDs.empty()) 1667df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return P.Error(ForwardRefValIDs.begin()->second.second, 1668df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "use of undefined value '%" + 1669df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner utostr(ForwardRefValIDs.begin()->first) + "'"); 1670df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1671df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1672df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1673df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1674df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// GetVal - Get a value with the specified name or ID, creating a 1675df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// forward reference record if needed. This can return null if the value 1676df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// exists but does not have the right type. 1677df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerValue *LLParser::PerFunctionState::GetVal(const std::string &Name, 1678df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const Type *Ty, LocTy Loc) { 1679df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Look this name up in the normal function symbol table. 1680df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val = F.getValueSymbolTable().lookup(Name); 1681a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1682df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this is a forward reference for the value, see if we already created a 1683df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // forward ref record. 1684df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val == 0) { 1685df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<std::string, std::pair<Value*, LocTy> >::iterator 1686df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefVals.find(Name); 1687df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefVals.end()) 1688df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val = I->second.first; 1689df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1690a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1691df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If we have the value in the symbol table or fwd-ref table, return it. 1692df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val) { 1693df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val->getType() == Ty) return Val; 1694cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isLabelTy()) 1695df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner P.Error(Loc, "'%" + Name + "' is not a basic block"); 1696df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 1697df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner P.Error(Loc, "'%" + Name + "' defined with type '" + 1698df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val->getType()->getDescription() + "'"); 1699df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 1700df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1701a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1702df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Don't make placeholders with invalid type. 17031d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) && 17041d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Ty != Type::getLabelTy(F.getContext())) { 1705df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner P.Error(Loc, "invalid use of a non-first-class type"); 1706df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 1707df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1708a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1709df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, create a new forward reference for this value and remember it. 1710df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *FwdVal; 1711cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isLabelTy()) 17121d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson FwdVal = BasicBlock::Create(F.getContext(), Name, &F); 1713df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 1714df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FwdVal = new Argument(Ty, Name); 1715a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1716df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals[Name] = std::make_pair(FwdVal, Loc); 1717df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return FwdVal; 1718df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1719df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1720df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerValue *LLParser::PerFunctionState::GetVal(unsigned ID, const Type *Ty, 1721df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc) { 1722df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Look this name up in the normal function symbol table. 1723df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val = ID < NumberedVals.size() ? NumberedVals[ID] : 0; 1724a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1725df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this is a forward reference for the value, see if we already created a 1726df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // forward ref record. 1727df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val == 0) { 1728df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<Value*, LocTy> >::iterator 1729df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner I = ForwardRefValIDs.find(ID); 1730df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefValIDs.end()) 1731df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val = I->second.first; 1732df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1733a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1734df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If we have the value in the symbol table or fwd-ref table, return it. 1735df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val) { 1736df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val->getType() == Ty) return Val; 1737cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isLabelTy()) 1738df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner P.Error(Loc, "'%" + utostr(ID) + "' is not a basic block"); 1739df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 1740df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner P.Error(Loc, "'%" + utostr(ID) + "' defined with type '" + 1741df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Val->getType()->getDescription() + "'"); 1742df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 1743df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1744a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 17451d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty) && 17461d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Ty != Type::getLabelTy(F.getContext())) { 1747df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner P.Error(Loc, "invalid use of a non-first-class type"); 1748df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return 0; 1749df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1750a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1751df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, create a new forward reference for this value and remember it. 1752df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *FwdVal; 1753cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isLabelTy()) 17541d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson FwdVal = BasicBlock::Create(F.getContext(), "", &F); 1755df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 1756df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FwdVal = new Argument(Ty); 1757a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1758df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs[ID] = std::make_pair(FwdVal, Loc); 1759df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return FwdVal; 1760df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1761df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1762df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// SetInstName - After an instruction is parsed and inserted into its 1763df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// basic block, this installs its name. 1764df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::PerFunctionState::SetInstName(int NameID, 1765df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const std::string &NameStr, 1766df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy NameLoc, Instruction *Inst) { 1767df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this instruction has void type, it cannot have a name or ID specified. 1768cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Inst->getType()->isVoidTy()) { 1769df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (NameID != -1 || !NameStr.empty()) 1770df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return P.Error(NameLoc, "instructions returning void cannot have a name"); 1771df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1772df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1773a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1774df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this was a numbered instruction, verify that the instruction is the 1775df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // expected value and resolve any forward references. 1776df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (NameStr.empty()) { 1777df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If neither a name nor an ID was specified, just use the next ID. 1778df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (NameID == -1) 1779df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NameID = NumberedVals.size(); 1780a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1781df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (unsigned(NameID) != NumberedVals.size()) 1782df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return P.Error(NameLoc, "instruction expected to be numbered '%" + 1783df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner utostr(NumberedVals.size()) + "'"); 1784a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1785df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<Value*, LocTy> >::iterator FI = 1786df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs.find(NameID); 1787df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FI != ForwardRefValIDs.end()) { 1788df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FI->second.first->getType() != Inst->getType()) 1789a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return P.Error(NameLoc, "instruction forward referenced with type '" + 1790df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI->second.first->getType()->getDescription() + "'"); 1791df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI->second.first->replaceAllUsesWith(Inst); 17922b4f28e270c5091a7e70991adc3e36aff0c85b0eNuno Lopes delete FI->second.first; 1793df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs.erase(FI); 1794df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1795df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1796df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NumberedVals.push_back(Inst); 1797df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1798df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1799df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1800df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Otherwise, the instruction had a name. Resolve forward refs and set it. 1801df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<std::string, std::pair<Value*, LocTy> >::iterator 1802df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI = ForwardRefVals.find(NameStr); 1803df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FI != ForwardRefVals.end()) { 1804df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FI->second.first->getType() != Inst->getType()) 1805a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return P.Error(NameLoc, "instruction forward referenced with type '" + 1806df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI->second.first->getType()->getDescription() + "'"); 1807df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FI->second.first->replaceAllUsesWith(Inst); 1808531552aaa24218c1b2043cf56d719f3d940aeed4Nuno Lopes delete FI->second.first; 1809df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals.erase(FI); 1810df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1811a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1812df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set the name on the instruction. 1813df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst->setName(NameStr); 1814a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1815df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Inst->getNameStr() != NameStr) 1816a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return P.Error(NameLoc, "multiple definition of local value named '" + 1817df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NameStr + "'"); 1818df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1819df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1820df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1821df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// GetBB - Get a basic block with the specified name or ID, creating a 1822df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// forward reference record if needed. 1823df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerBasicBlock *LLParser::PerFunctionState::GetBB(const std::string &Name, 1824df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc) { 18251d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson return cast_or_null<BasicBlock>(GetVal(Name, 18261d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Type::getLabelTy(F.getContext()), Loc)); 1827df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1828df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1829df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerBasicBlock *LLParser::PerFunctionState::GetBB(unsigned ID, LocTy Loc) { 18301d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson return cast_or_null<BasicBlock>(GetVal(ID, 18311d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Type::getLabelTy(F.getContext()), Loc)); 1832df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1833df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1834df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// DefineBB - Define the specified basic block, which is either named or 1835df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// unnamed. If there is an error, this returns null otherwise it returns 1836df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// the block being defined. 1837df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris LattnerBasicBlock *LLParser::PerFunctionState::DefineBB(const std::string &Name, 1838df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc) { 1839df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner BasicBlock *BB; 1840df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Name.empty()) 1841df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner BB = GetBB(NumberedVals.size(), Loc); 1842df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else 1843df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner BB = GetBB(Name, Loc); 1844df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (BB == 0) return 0; // Already diagnosed error. 1845a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1846df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Move the block to the end of the function. Forward ref'd blocks are 1847df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // inserted wherever they happen to be referenced. 1848df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner F.getBasicBlockList().splice(F.end(), F.getBasicBlockList(), BB); 1849a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1850df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Remove the block from forward ref sets. 1851df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Name.empty()) { 1852df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs.erase(NumberedVals.size()); 1853df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NumberedVals.push_back(BB); 1854df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 1855df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // BB forward references are already in the function symbol table. 1856df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals.erase(Name); 1857df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1858a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1859df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return BB; 1860df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 1861df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1862df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 1863df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Constants. 1864df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 1865df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1866df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseValID - Parse an abstract value that doesn't necessarily have a 1867df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// type implied. For example, if we parse "4" we don't know what integer type 1868df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// it has. The value will later be combined with its type and checked for 1869df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// sanity. 1870df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseValID(ValID &ID) { 1871df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Loc = Lex.getLoc(); 1872df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 1873df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: return TokError("expected value token"); 1874df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::GlobalID: // @42 1875df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.UIntVal = Lex.getUIntVal(); 1876df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_GlobalID; 1877df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1878df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::GlobalVar: // @foo 1879df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.StrVal = Lex.getStrVal(); 1880df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_GlobalName; 1881df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1882df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::LocalVarID: // %42 1883df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.UIntVal = Lex.getUIntVal(); 1884df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_LocalID; 1885df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1886df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::LocalVar: // %foo 1887df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::StringConstant: // "foo" - FIXME: REMOVE IN LLVM 3.0 1888df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.StrVal = Lex.getStrVal(); 1889df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_LocalName; 1890df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1891e434d277ca5183eeb6f881000732dcf4c8edd52eChris Lattner case lltok::exclaim: // !{...} MDNode, !"foo" MDString 189221cc4460efa104e8591b05a90f20130291614344Nick Lewycky Lex.Lex(); 1893442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner 1894442ffa1c5688f32b275f7657b5ee3646bfe8ffa3Chris Lattner // FIXME: This doesn't belong here. 18953f5132a024960b7d2e226a210c5923c094f036efChris Lattner if (EatIfPresent(lltok::lbrace)) { 1896cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky SmallVector<Value*, 16> Elts; 189721cc4460efa104e8591b05a90f20130291614344Nick Lewycky if (ParseMDNodeVector(Elts) || 189821cc4460efa104e8591b05a90f20130291614344Nick Lewycky ParseToken(lltok::rbrace, "expected end of metadata node")) 189921cc4460efa104e8591b05a90f20130291614344Nick Lewycky return true; 1900cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky 1901287881d51086c4c5b38d109142f97442c9283374Chris Lattner ID.MDNodeVal = MDNode::get(Context, Elts.data(), Elts.size()); 1902287881d51086c4c5b38d109142f97442c9283374Chris Lattner ID.Kind = ValID::t_MDNode; 190321cc4460efa104e8591b05a90f20130291614344Nick Lewycky return false; 190421cc4460efa104e8591b05a90f20130291614344Nick Lewycky } 190521cc4460efa104e8591b05a90f20130291614344Nick Lewycky 1906923078c65d5a37a4f135705300c9feea49487de5Devang Patel // Standalone metadata reference 1907923078c65d5a37a4f135705300c9feea49487de5Devang Patel // !{ ..., !42, ... } 1908860775c2b05a0d0ecadcbf2e9283912061fb5235Chris Lattner if (Lex.getKind() == lltok::APSInt) { 19094a72efc0ad18c1b9c98bb2f0cb881a39a7010b53Chris Lattner if (ParseMDNodeID(ID.MDNodeVal)) return true; 1910287881d51086c4c5b38d109142f97442c9283374Chris Lattner ID.Kind = ValID::t_MDNode; 1911923078c65d5a37a4f135705300c9feea49487de5Devang Patel return false; 1912287881d51086c4c5b38d109142f97442c9283374Chris Lattner } 1913287881d51086c4c5b38d109142f97442c9283374Chris Lattner 191421cc4460efa104e8591b05a90f20130291614344Nick Lewycky // MDString: 191521cc4460efa104e8591b05a90f20130291614344Nick Lewycky // ::= '!' STRINGCONSTANT 1916287881d51086c4c5b38d109142f97442c9283374Chris Lattner if (ParseMDString(ID.MDStringVal)) return true; 1917287881d51086c4c5b38d109142f97442c9283374Chris Lattner ID.Kind = ValID::t_MDString; 191821cc4460efa104e8591b05a90f20130291614344Nick Lewycky return false; 1919df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::APSInt: 1920a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar ID.APSIntVal = Lex.getAPSIntVal(); 1921df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_APSInt; 1922df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1923df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::APFloat: 1924df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.APFloatVal = Lex.getAPFloatVal(); 1925df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_APFloat; 1926df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1927df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_true: 19285defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson ID.ConstantVal = ConstantInt::getTrue(Context); 1929df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 1930df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1931df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_false: 19325defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson ID.ConstantVal = ConstantInt::getFalse(Context); 1933df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 1934df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 1935df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_null: ID.Kind = ValID::t_Null; break; 1936df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_undef: ID.Kind = ValID::t_Undef; break; 1937df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_zeroinitializer: ID.Kind = ValID::t_Zero; break; 1938a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1939df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::lbrace: { 1940df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // ValID ::= '{' ConstVector '}' 1941df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1942df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Constant*, 16> Elts; 1943df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalValueVector(Elts) || 1944df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rbrace, "expected end of struct constant")) 1945df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1946a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1947d7f2a6cb3fbc012763adb42fd967f6fefbb22a37Owen Anderson ID.ConstantVal = ConstantStruct::get(Context, Elts.data(), 1948d7f2a6cb3fbc012763adb42fd967f6fefbb22a37Owen Anderson Elts.size(), false); 1949df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 1950df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1951df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1952df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::less: { 1953df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // ValID ::= '<' ConstVector '>' --> Vector. 1954df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // ValID ::= '<' '{' ConstVector '}' '>' --> Packed Struct. 1955df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 19563ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner bool isPackedStruct = EatIfPresent(lltok::lbrace); 1957a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1958df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Constant*, 16> Elts; 1959df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy FirstEltLoc = Lex.getLoc(); 1960df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalValueVector(Elts) || 1961df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner (isPackedStruct && 1962df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rbrace, "expected end of packed struct")) || 1963df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::greater, "expected end of constant")) 1964df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1965a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1966df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (isPackedStruct) { 1967fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson ID.ConstantVal = 1968d7f2a6cb3fbc012763adb42fd967f6fefbb22a37Owen Anderson ConstantStruct::get(Context, Elts.data(), Elts.size(), true); 1969df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 1970df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1971df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1972a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1973df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.empty()) 1974df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "constant vector must not be empty"); 1975df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 1976df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Elts[0]->getType()->isInteger() && 1977df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !Elts[0]->getType()->isFloatingPoint()) 1978df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(FirstEltLoc, 1979df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "vector elements must have integer or floating point type"); 1980a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1981df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Verify that all the vector elements have the same type. 1982df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 1, e = Elts.size(); i != e; ++i) 1983df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts[i]->getType() != Elts[0]->getType()) 1984df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(FirstEltLoc, 1985df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "vector element #" + utostr(i) + 1986df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner " is not of type '" + Elts[0]->getType()->getDescription()); 1987a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 1988af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson ID.ConstantVal = ConstantVector::get(Elts.data(), Elts.size()); 1989df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 1990df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 1991df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 1992df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::lsquare: { // Array Constant 1993df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 1994df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Constant*, 16> Elts; 1995df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy FirstEltLoc = Lex.getLoc(); 1996df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalValueVector(Elts) || 1997df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rsquare, "expected end of array constant")) 1998df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 1999df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2000df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Handle empty element. 2001df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.empty()) { 2002df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Use undef instead of an array because it's inconvenient to determine 2003df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // the element type at this point, there being no elements to examine. 2004081b505f77b183b7b029818218245cf4986e8948Chris Lattner ID.Kind = ValID::t_EmptyArray; 2005df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2006df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2007a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2008df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Elts[0]->getType()->isFirstClassType()) 2009a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return Error(FirstEltLoc, "invalid array element type: " + 2010df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Elts[0]->getType()->getDescription()); 2011a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2012debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson ArrayType *ATy = ArrayType::get(Elts[0]->getType(), Elts.size()); 2013a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2014df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Verify all elements are correct type! 20156d6b3cc89b9d1911cff4931dadfe670f94fcbb3bChris Lattner for (unsigned i = 0, e = Elts.size(); i != e; ++i) { 2016df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts[i]->getType() != Elts[0]->getType()) 2017df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(FirstEltLoc, 2018df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "array element #" + utostr(i) + 2019df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner " is not of type '" +Elts[0]->getType()->getDescription()); 2020df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2021a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 20221fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson ID.ConstantVal = ConstantArray::get(ATy, Elts.data(), Elts.size()); 2023df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2024df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2025df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2026df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_c: // c "foo" 2027df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 20281d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ID.ConstantVal = ConstantArray::get(Context, Lex.getStrVal(), false); 2029df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::StringConstant, "expected string")) return true; 2030df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2031df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2032df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2033df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_asm: { 20348ba2d5befc05ca73d3bac8708819bbbe759e2cf9Dale Johannesen // ValID ::= 'asm' SideEffect? AlignStack? STRINGCONSTANT ',' STRINGCONSTANT 20358ba2d5befc05ca73d3bac8708819bbbe759e2cf9Dale Johannesen bool HasSideEffect, AlignStack; 2036df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2037df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalToken(lltok::kw_sideeffect, HasSideEffect) || 20388ba2d5befc05ca73d3bac8708819bbbe759e2cf9Dale Johannesen ParseOptionalToken(lltok::kw_alignstack, AlignStack) || 20393ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseStringConstant(ID.StrVal) || 20403ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseToken(lltok::comma, "expected comma in inline asm expression") || 2041df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::StringConstant, "expected constraint string")) 2042df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2043df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.StrVal2 = Lex.getStrVal(); 2044f0bb41c078d657c70ce6b95d5b56645c72ca7db4Daniel Dunbar ID.UIntVal = unsigned(HasSideEffect) | (unsigned(AlignStack)<<1); 2045df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_InlineAsm; 2046df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2047df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2048a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 204909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner case lltok::kw_blockaddress: { 205009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // ValID ::= 'blockaddress' '(' @foo ',' %bar ')' 205109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner Lex.Lex(); 205209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 205309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ValID Fn, Label; 205409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner LocTy FnLoc, LabelLoc; 205509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 205609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in block address expression") || 205709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ParseValID(Fn) || 205809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ParseToken(lltok::comma, "expected comma in block address expression")|| 205909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ParseValID(Label) || 206009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ParseToken(lltok::rparen, "expected ')' in block address expression")) 206109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return true; 2062cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner 206309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName) 206409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return Error(Fn.Loc, "expected function name in blockaddress"); 2065cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner if (Label.Kind != ValID::t_LocalID && Label.Kind != ValID::t_LocalName) 206609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return Error(Label.Loc, "expected basic block name in blockaddress"); 206709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 206809d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner // Make a global variable as a placeholder for this reference. 206909d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner GlobalVariable *FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), 207009d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner false, GlobalValue::InternalLinkage, 207109d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 0, ""); 207209d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ForwardRefBlockAddresses[Fn].push_back(std::make_pair(Label, FwdRef)); 207309d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ID.ConstantVal = FwdRef; 207409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner ID.Kind = ValID::t_Constant; 207509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return false; 207609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner } 207709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 2078df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_trunc: 2079df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_zext: 2080df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sext: 2081df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fptrunc: 2082df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fpext: 2083df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_bitcast: 2084df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_uitofp: 2085df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sitofp: 2086df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fptoui: 2087a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar case lltok::kw_fptosi: 2088df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_inttoptr: 2089a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar case lltok::kw_ptrtoint: { 2090df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc = Lex.getUIntVal(); 20911d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder DestTy(Type::getVoidTy(Context)); 2092df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *SrcVal; 2093df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2094df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' after constantexpr cast") || 2095df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(SrcVal) || 209624b108bc8ca75922d4cb8e7f197934b8269d4fc3Dan Gohman ParseToken(lltok::kw_to, "expected 'to' in constantexpr cast") || 2097df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseType(DestTy) || 2098df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' at end of constantexpr cast")) 2099df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2100df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!CastInst::castIsValid((Instruction::CastOps)Opc, SrcVal, DestTy)) 2101df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid cast opcode for cast from '" + 2102df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SrcVal->getType()->getDescription() + "' to '" + 2103df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner DestTy->getDescription() + "'"); 2104a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar ID.ConstantVal = ConstantExpr::getCast((Instruction::CastOps)Opc, 2105fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson SrcVal, DestTy); 2106df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2107df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2108df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2109df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_extractvalue: { 2110df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2111df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Val; 2112df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<unsigned, 4> Indices; 2113df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in extractvalue constantexpr")|| 2114df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val) || 2115df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseIndexList(Indices) || 2116df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in extractvalue constantexpr")) 2117df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2118e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 2119e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (ParseOptionalCustomMetadata()) return true; 2120e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel 2121df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) 2122df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "extractvalue operand must be array or struct"); 2123df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), 2124df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.end())) 2125df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid indices for extractvalue"); 2126e3e51c0038bd6ba2add82e2246e97edec0ab2204Jay Foad ID.ConstantVal = 2127baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ConstantExpr::getExtractValue(Val, Indices.data(), Indices.size()); 2128df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2129df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2130df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2131df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_insertvalue: { 2132df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2133df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Val0, *Val1; 2134df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<unsigned, 4> Indices; 2135df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in insertvalue constantexpr")|| 2136df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val0) || 2137df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected comma in insertvalue constantexpr")|| 2138df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val1) || 2139df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseIndexList(Indices) || 2140df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in insertvalue constantexpr")) 2141df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2142e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 2143e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (ParseOptionalCustomMetadata()) return true; 2144df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType())) 2145df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "extractvalue operand must be array or struct"); 2146df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), 2147df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.end())) 2148df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid indices for insertvalue"); 2149baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ID.ConstantVal = ConstantExpr::getInsertValue(Val0, Val1, 2150fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson Indices.data(), Indices.size()); 2151df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2152df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2153df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2154df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_icmp: 21557f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky case lltok::kw_fcmp: { 2156df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned PredVal, Opc = Lex.getUIntVal(); 2157df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Val0, *Val1; 2158df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2159df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseCmpPredicate(PredVal, Opc) || 2160df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::lparen, "expected '(' in compare constantexpr") || 2161df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val0) || 2162df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected comma in compare constantexpr") || 2163df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val1) || 2164df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in compare constantexpr")) 2165df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2166a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2167df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val0->getType() != Val1->getType()) 2168df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "compare operands must have the same type"); 2169a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2170df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)PredVal; 2171a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2172df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Opc == Instruction::FCmp) { 2173df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Val0->getType()->isFPOrFPVector()) 2174df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "fcmp requires floating point operands"); 2175baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ID.ConstantVal = ConstantExpr::getFCmp(Pred, Val0, Val1); 21767f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky } else { 21777f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky assert(Opc == Instruction::ICmp && "Unexpected opcode for CmpInst!"); 2178df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Val0->getType()->isIntOrIntVector() && 2179df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !isa<PointerType>(Val0->getType())) 2180df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "icmp requires pointer or integer operands"); 2181baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ID.ConstantVal = ConstantExpr::getICmp(Pred, Val0, Val1); 2182df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2183df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2184df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2185df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2186a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2187df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Binary Operators. 2188df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_add: 2189ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case lltok::kw_fadd: 2190df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sub: 2191ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case lltok::kw_fsub: 2192df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_mul: 2193ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case lltok::kw_fmul: 2194df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_udiv: 2195df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sdiv: 2196df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fdiv: 2197df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_urem: 2198df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_srem: 2199df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_frem: { 220059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool NUW = false; 220159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool NSW = false; 220259858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool Exact = false; 2203df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc = Lex.getUIntVal(); 2204df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Val0, *Val1; 2205df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 220659858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman LocTy ModifierLoc = Lex.getLoc(); 220759858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (Opc == Instruction::Add || 220859858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman Opc == Instruction::Sub || 220959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman Opc == Instruction::Mul) { 221059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_nuw)) 221159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman NUW = true; 221259858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_nsw)) { 221359858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman NSW = true; 221459858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_nuw)) 221559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman NUW = true; 221659858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 221759858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } else if (Opc == Instruction::SDiv) { 221859858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_exact)) 221959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman Exact = true; 222059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 2221df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in binary constantexpr") || 2222df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val0) || 2223df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected comma in binary constantexpr") || 2224df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val1) || 2225df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in binary constantexpr")) 2226df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2227df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val0->getType() != Val1->getType()) 2228df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "operands of constexpr must have same type"); 222959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (!Val0->getType()->isIntOrIntVector()) { 223059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (NUW) 223159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman return Error(ModifierLoc, "nuw only applies to integer operations"); 223259858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (NSW) 223359858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman return Error(ModifierLoc, "nsw only applies to integer operations"); 223459858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 223559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman // API compatibility: Accept either integer or floating-point types with 223659858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman // add, sub, and mul. 2237df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Val0->getType()->isIntOrIntVector() && 2238df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !Val0->getType()->isFPOrFPVector()) 2239df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc,"constexpr requires integer, fp, or vector operands"); 2240f8dbee7cea072eb63ae343759975109553697bcbDan Gohman unsigned Flags = 0; 2241f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (NUW) Flags |= OverflowingBinaryOperator::NoUnsignedWrap; 2242f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (NSW) Flags |= OverflowingBinaryOperator::NoSignedWrap; 2243f8dbee7cea072eb63ae343759975109553697bcbDan Gohman if (Exact) Flags |= SDivOperator::IsExact; 2244f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Constant *C = ConstantExpr::get(Opc, Val0, Val1, Flags); 224559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman ID.ConstantVal = C; 2246df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2247df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2248df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2249a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2250df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Logical Operations 2251df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_shl: 2252df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_lshr: 2253df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ashr: 2254df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_and: 2255df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_or: 2256df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_xor: { 2257df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc = Lex.getUIntVal(); 2258df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *Val0, *Val1; 2259df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2260df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in logical constantexpr") || 2261df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val0) || 2262df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected comma in logical constantexpr") || 2263df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalTypeAndValue(Val1) || 2264df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in logical constantexpr")) 2265df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2266df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Val0->getType() != Val1->getType()) 2267df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "operands of constexpr must have same type"); 2268df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Val0->getType()->isIntOrIntVector()) 2269df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, 2270df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner "constexpr requires integer or integer vector operands"); 2271baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ID.ConstantVal = ConstantExpr::get(Opc, Val0, Val1); 2272df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2273df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2274a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar } 2275a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2276df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_getelementptr: 2277df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_shufflevector: 2278df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_insertelement: 2279df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_extractelement: 2280df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_select: { 2281df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc = Lex.getUIntVal(); 2282df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Constant*, 16> Elts; 2283dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman bool InBounds = false; 2284df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2285dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman if (Opc == Instruction::GetElementPtr) 2286dcb40a3c1c747c88c4e634e34d1b4d7533a86adaDan Gohman InBounds = EatIfPresent(lltok::kw_inbounds); 2287df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::lparen, "expected '(' in constantexpr") || 2288df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalValueVector(Elts) || 2289df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rparen, "expected ')' in constantexpr")) 2290df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2291a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2292df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Opc == Instruction::GetElementPtr) { 2293df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.size() == 0 || !isa<PointerType>(Elts[0]->getType())) 2294df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "getelementptr requires pointer operand"); 2295a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2296df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!GetElementPtrInst::getIndexedType(Elts[0]->getType(), 22974e9bac3769cb668aad20f1ac2d6a35d9ba452f3aEli Friedman (Value**)(Elts.data() + 1), 22984e9bac3769cb668aad20f1ac2d6a35d9ba452f3aEli Friedman Elts.size() - 1)) 2299df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid indices for getelementptr"); 2300f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ID.ConstantVal = InBounds ? 2301f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ConstantExpr::getInBoundsGetElementPtr(Elts[0], 2302f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Elts.data() + 1, 2303f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Elts.size() - 1) : 2304f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ConstantExpr::getGetElementPtr(Elts[0], 2305f8dbee7cea072eb63ae343759975109553697bcbDan Gohman Elts.data() + 1, Elts.size() - 1); 2306df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Opc == Instruction::Select) { 2307df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.size() != 3) 2308df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "expected three operands to select"); 2309df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (const char *Reason = SelectInst::areInvalidOperands(Elts[0], Elts[1], 2310df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Elts[2])) 2311df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, Reason); 2312baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ID.ConstantVal = ConstantExpr::getSelect(Elts[0], Elts[1], Elts[2]); 2313df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Opc == Instruction::ShuffleVector) { 2314df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.size() != 3) 2315df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "expected three operands to shufflevector"); 2316df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ShuffleVectorInst::isValidOperands(Elts[0], Elts[1], Elts[2])) 2317df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid operands to shufflevector"); 2318fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson ID.ConstantVal = 2319baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ConstantExpr::getShuffleVector(Elts[0], Elts[1],Elts[2]); 2320df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Opc == Instruction::ExtractElement) { 2321df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.size() != 2) 2322df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "expected two operands to extractelement"); 2323df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractElementInst::isValidOperands(Elts[0], Elts[1])) 2324df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid extractelement operands"); 2325baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ID.ConstantVal = ConstantExpr::getExtractElement(Elts[0], Elts[1]); 2326df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 2327df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner assert(Opc == Instruction::InsertElement && "Unknown opcode"); 2328df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Elts.size() != 3) 2329df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "expected three operands to insertelement"); 2330df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!InsertElementInst::isValidOperands(Elts[0], Elts[1], Elts[2])) 2331df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid insertelement operands"); 2332fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson ID.ConstantVal = 2333baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ConstantExpr::getInsertElement(Elts[0], Elts[1],Elts[2]); 2334df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2335a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2336df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.Kind = ValID::t_Constant; 2337df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2338df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2339df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2340a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2341df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2342df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2343df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2344df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2345df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseGlobalValue - Parse a global value with the specified type. 2346df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGlobalValue(const Type *Ty, Constant *&V) { 2347df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner V = 0; 2348df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ValID ID; 23493ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return ParseValID(ID) || 23503ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ConvertGlobalValIDToValue(Ty, ID, V); 2351df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2352df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2353df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ConvertGlobalValIDToValue - Apply a type to a ValID to get a fully resolved 2354df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// constant. 2355df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, 2356df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *&V) { 2357df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (isa<FunctionType>(Ty)) 2358df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "functions are not values, refer to them as pointers"); 2359a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2360df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (ID.Kind) { 2361a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar default: llvm_unreachable("Unknown ValID!"); 2362287881d51086c4c5b38d109142f97442c9283374Chris Lattner case ValID::t_MDNode: 2363287881d51086c4c5b38d109142f97442c9283374Chris Lattner case ValID::t_MDString: 2364e54abc90fe9942ef3902040a7ac475ce0c369dc9Devang Patel return Error(ID.Loc, "invalid use of metadata"); 2365df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_LocalID: 2366df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_LocalName: 2367df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid use of function-local name"); 2368df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_InlineAsm: 2369df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "inline asm can only be an operand of call/invoke"); 2370df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_GlobalName: 2371df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner V = GetGlobalVal(ID.StrVal, Ty, ID.Loc); 2372df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return V == 0; 2373df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_GlobalID: 2374df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner V = GetGlobalVal(ID.UIntVal, Ty, ID.Loc); 2375df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return V == 0; 2376df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_APSInt: 2377df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<IntegerType>(Ty)) 2378df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "integer constant must have integer type"); 2379df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.APSIntVal.extOrTrunc(Ty->getPrimitiveSizeInBits()); 2380eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson V = ConstantInt::get(Context, ID.APSIntVal); 2381df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2382df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_APFloat: 2383df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Ty->isFloatingPoint() || 2384df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !ConstantFP::isValueValidForType(Ty, ID.APFloatVal)) 2385df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "floating point constant invalid for type"); 2386a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2387df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // The lexer has no type info, so builds all float and double FP constants 2388df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // as double. Fix this here. Long double does not need this. 2389df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (&ID.APFloatVal.getSemantics() == &APFloat::IEEEdouble && 2390cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner Ty->isFloatTy()) { 2391df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool Ignored; 2392df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ID.APFloatVal.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, 2393df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner &Ignored); 2394df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 23956f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson V = ConstantFP::get(Context, ID.APFloatVal); 2396a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2397959873d2da763c0e3b3c67c39aab179fc43c5a52Chris Lattner if (V->getType() != Ty) 2398959873d2da763c0e3b3c67c39aab179fc43c5a52Chris Lattner return Error(ID.Loc, "floating point constant does not have type '" + 2399959873d2da763c0e3b3c67c39aab179fc43c5a52Chris Lattner Ty->getDescription() + "'"); 2400a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2401df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2402df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_Null: 2403df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<PointerType>(Ty)) 2404df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "null must be a pointer type"); 24059e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = ConstantPointerNull::get(cast<PointerType>(Ty)); 2406df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2407df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_Undef: 2408e67c1aa3986cf98f2021a31a6ad502857c757b7bChris Lattner // FIXME: LabelTy should not be a first-class type. 2409cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if ((!Ty->isFirstClassType() || Ty->isLabelTy()) && 24100b6163506359223fb0f74d856099ee4d5e768ebeChris Lattner !isa<OpaqueType>(Ty)) 2411e67c1aa3986cf98f2021a31a6ad502857c757b7bChris Lattner return Error(ID.Loc, "invalid type for undef constant"); 24129e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(Ty); 2413df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2414081b505f77b183b7b029818218245cf4986e8948Chris Lattner case ValID::t_EmptyArray: 2415081b505f77b183b7b029818218245cf4986e8948Chris Lattner if (!isa<ArrayType>(Ty) || cast<ArrayType>(Ty)->getNumElements() != 0) 2416081b505f77b183b7b029818218245cf4986e8948Chris Lattner return Error(ID.Loc, "invalid empty array initializer"); 24179e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson V = UndefValue::get(Ty); 2418081b505f77b183b7b029818218245cf4986e8948Chris Lattner return false; 2419df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_Zero: 2420e67c1aa3986cf98f2021a31a6ad502857c757b7bChris Lattner // FIXME: LabelTy should not be a first-class type. 2421cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (!Ty->isFirstClassType() || Ty->isLabelTy()) 2422df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid type for null constant"); 2423a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson V = Constant::getNullValue(Ty); 2424df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2425df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case ValID::t_Constant: 2426df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ID.ConstantVal->getType() != Ty) 2427df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "constant expression type mismatch"); 2428df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner V = ID.ConstantVal; 2429df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2430df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2431df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2432a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2433a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner/// ConvertGlobalOrMetadataValIDToValue - Apply a type to a ValID to get a fully 2434a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner/// resolved constant or metadata value. 2435a73523958d39ca10a322fd8b177104ebc2045130Chris Lattnerbool LLParser::ConvertGlobalOrMetadataValIDToValue(const Type *Ty, ValID &ID, 2436a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner Value *&V) { 2437a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner switch (ID.Kind) { 2438a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner case ValID::t_MDNode: 2439a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner if (!Ty->isMetadataTy()) 2440a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return Error(ID.Loc, "metadata value must have metadata type"); 2441a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner V = ID.MDNodeVal; 2442a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return false; 2443a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner case ValID::t_MDString: 2444a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner if (!Ty->isMetadataTy()) 2445a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return Error(ID.Loc, "metadata value must have metadata type"); 2446a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner V = ID.MDStringVal; 2447a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return false; 2448a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner default: 2449a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner Constant *C; 2450a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner if (ConvertGlobalValIDToValue(Ty, ID, C)) return true; 2451a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner V = C; 2452a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return false; 2453a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner } 2454a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner} 2455a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner 2456a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner 2457df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGlobalTypeAndValue(Constant *&V) { 24581d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Type(Type::getVoidTy(Context)); 2459df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseType(Type) || 2460df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseGlobalValue(Type, V); 2461a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar} 2462df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 24633ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ParseGlobalValueVector 24643ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ::= /*empty*/ 24653ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner/// ::= TypeAndValue (',' TypeAndValue)* 2466df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts) { 2467df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Empty list. 2468df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::rbrace || 2469df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getKind() == lltok::rsquare || 2470df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getKind() == lltok::greater || 2471df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getKind() == lltok::rparen) 2472df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2473a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2474df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Constant *C; 2475df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalTypeAndValue(C)) return true; 2476df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Elts.push_back(C); 2477a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 24783ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner while (EatIfPresent(lltok::comma)) { 2479df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseGlobalTypeAndValue(C)) return true; 2480df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Elts.push_back(C); 2481df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2482a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2483df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2484df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2485df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2486df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2487df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 2488df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Function Parsing. 2489df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 2490df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2491df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, 2492df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PerFunctionState &PFS) { 2493287881d51086c4c5b38d109142f97442c9283374Chris Lattner switch (ID.Kind) { 2494287881d51086c4c5b38d109142f97442c9283374Chris Lattner case ValID::t_LocalID: V = PFS.GetVal(ID.UIntVal, Ty, ID.Loc); break; 2495287881d51086c4c5b38d109142f97442c9283374Chris Lattner case ValID::t_LocalName: V = PFS.GetVal(ID.StrVal, Ty, ID.Loc); break; 2496287881d51086c4c5b38d109142f97442c9283374Chris Lattner case ValID::t_InlineAsm: { 2497df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const PointerType *PTy = dyn_cast<PointerType>(Ty); 2498c49363bcd92a9b60171199d38e57234757cf00fcChris Lattner const FunctionType *FTy = 2499c49363bcd92a9b60171199d38e57234757cf00fcChris Lattner PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0; 2500df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!FTy || !InlineAsm::Verify(FTy, ID.StrVal2)) 2501df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ID.Loc, "invalid type for inline asm constraint string"); 25024360298d2bf3c1ba8595a415cfa235df0bc76335Dale Johannesen V = InlineAsm::get(FTy, ID.StrVal, ID.StrVal2, ID.UIntVal&1, ID.UIntVal>>1); 2503df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2504287881d51086c4c5b38d109142f97442c9283374Chris Lattner } 2505a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner default: 2506a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return ConvertGlobalOrMetadataValIDToValue(Ty, ID, V); 2507287881d51086c4c5b38d109142f97442c9283374Chris Lattner } 2508df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2509df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return V == 0; 2510df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2511df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2512df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS) { 2513df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner V = 0; 2514df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ValID ID; 25153ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return ParseValID(ID) || 25163ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ConvertValIDToValue(Ty, ID, V, PFS); 2517df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2518df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2519df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseTypeAndValue(Value *&V, PerFunctionState &PFS) { 25201d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder T(Type::getVoidTy(Context)); 25213ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return ParseType(T) || 25223ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseValue(T, V, PFS); 2523df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2524df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2525f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattnerbool LLParser::ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc, 2526f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner PerFunctionState &PFS) { 2527f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Value *V; 2528f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Loc = Lex.getLoc(); 2529f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (ParseTypeAndValue(V, PFS)) return true; 2530f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (!isa<BasicBlock>(V)) 2531f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return Error(Loc, "expected a basic block"); 2532f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner BB = cast<BasicBlock>(V); 2533f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return false; 2534f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner} 2535f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 2536f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 2537df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// FunctionHeader 2538df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= OptionalLinkage OptionalVisibility OptionalCallingConv OptRetAttrs 2539df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// Type GlobalName '(' ArgList ')' OptFuncAttrs OptSection 2540df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// OptionalAlign OptGC 2541df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) { 2542df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Parse the linkage. 2543df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy LinkageLoc = Lex.getLoc(); 2544df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Linkage; 2545a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 254665c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel unsigned Visibility, RetAttrs; 254765c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel CallingConv::ID CC; 25481d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder RetType(Type::getVoidTy(Context)); 2549df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy RetTypeLoc = Lex.getLoc(); 2550df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalLinkage(Linkage) || 2551df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalVisibility(Visibility) || 2552df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalCallingConv(CC) || 2553df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAttrs(RetAttrs, 1) || 2554a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner ParseType(RetType, RetTypeLoc, true /*void allowed*/)) 2555df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2556df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2557df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Verify that the linkage is ok. 2558df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch ((GlobalValue::LinkageTypes)Linkage) { 2559df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case GlobalValue::ExternalLinkage: 2560df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; // always ok. 2561df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case GlobalValue::DLLImportLinkage: 25625f4ee1fc5d00ae55c30fa2ce450c69be4c6d6e63Duncan Sands case GlobalValue::ExternalWeakLinkage: 2563df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (isDefine) 2564df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(LinkageLoc, "invalid linkage for function definition"); 2565df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 2566bb46f52027416598a662dc1c58f48d9d56b1a65bRafael Espindola case GlobalValue::PrivateLinkage: 25673d10a5a75794356a0a568ce283713adc3a963200Bill Wendling case GlobalValue::LinkerPrivateLinkage: 2568df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case GlobalValue::InternalLinkage: 256955f64dbb398cc8d967d1e32a8bb2190a60f5b61eNick Lewycky case GlobalValue::AvailableExternallyLinkage: 2570667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands case GlobalValue::LinkOnceAnyLinkage: 2571667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands case GlobalValue::LinkOnceODRLinkage: 2572667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands case GlobalValue::WeakAnyLinkage: 2573667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands case GlobalValue::WeakODRLinkage: 2574df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case GlobalValue::DLLExportLinkage: 2575df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isDefine) 2576df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(LinkageLoc, "invalid linkage for function declaration"); 2577df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 2578df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case GlobalValue::AppendingLinkage: 2579df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case GlobalValue::GhostLinkage: 25804dc2b39bf89d7c87868008ef8a0f807e0419aca6Duncan Sands case GlobalValue::CommonLinkage: 2581df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(LinkageLoc, "invalid function linkage type"); 2582df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2583a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 258499bb315f32a5f82f9e4978345ee39177db973242Chris Lattner if (!FunctionType::isValidReturnType(RetType) || 258599bb315f32a5f82f9e4978345ee39177db973242Chris Lattner isa<OpaqueType>(RetType)) 2586df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(RetTypeLoc, "invalid function return type"); 2587a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2588f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner LocTy NameLoc = Lex.getLoc(); 2589f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner 2590f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner std::string FunctionName; 2591f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner if (Lex.getKind() == lltok::GlobalVar) { 2592f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner FunctionName = Lex.getStrVal(); 2593f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner } else if (Lex.getKind() == lltok::GlobalID) { // @42 is ok. 2594f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner unsigned NameID = Lex.getUIntVal(); 2595f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner 2596f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner if (NameID != NumberedVals.size()) 2597f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner return TokError("function expected to be numbered '%" + 2598f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner utostr(NumberedVals.size()) + "'"); 2599f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner } else { 2600df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected function name"); 2601f570e621ab6eec6c7656cc4c511e19aba12b42cdChris Lattner } 2602a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 26033ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner Lex.Lex(); 2604a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 26053ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (Lex.getKind() != lltok::lparen) 2606df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected '(' in function argument list"); 2607a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2608df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<ArgInfo> ArgList; 2609df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool isVarArg; 2610df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned FuncAttrs; 2611df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::string Section; 2612df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Alignment; 26133ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner std::string GC; 26143ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner 2615dfd19ddcfa7568d2118fbc3c6da612295200c31cChris Lattner if (ParseArgumentList(ArgList, isVarArg, false) || 26163ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseOptionalAttrs(FuncAttrs, 2) || 26173ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner (EatIfPresent(lltok::kw_section) && 26183ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseStringConstant(Section)) || 26193ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseOptionalAlignment(Alignment) || 26203ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner (EatIfPresent(lltok::kw_gc) && 26213ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseStringConstant(GC))) 26223ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner return true; 2623df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2624df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If the alignment was parsed as an attribute, move to the alignment field. 2625df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FuncAttrs & Attribute::Alignment) { 2626df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Alignment = Attribute::getAlignmentFromAttrs(FuncAttrs); 2627df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FuncAttrs &= ~Attribute::Alignment; 2628df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2629a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2630df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Okay, if we got here, the function is syntactically valid. Convert types 2631df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // and do semantic checks. 2632df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<const Type*> ParamTypeList; 2633df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<AttributeWithIndex, 8> Attrs; 2634a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar // FIXME : In 3.0, stop accepting zext, sext and inreg as optional function 2635df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // attributes. 2636df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; 2637df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FuncAttrs & ObsoleteFuncAttrs) { 2638df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner RetAttrs |= FuncAttrs & ObsoleteFuncAttrs; 2639df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FuncAttrs &= ~ObsoleteFuncAttrs; 2640df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2641a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2642df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (RetAttrs != Attribute::None) 2643df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); 2644a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2645df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 2646df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParamTypeList.push_back(ArgList[i].Type); 2647df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ArgList[i].Attrs != Attribute::None) 2648df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); 2649df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2650df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2651df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FuncAttrs != Attribute::None) 2652df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(~0, FuncAttrs)); 2653df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2654df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); 2655a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2656a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner if (PAL.paramHasAttr(1, Attribute::StructRet) && 26571d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson RetType != Type::getVoidTy(Context)) 2658a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar return Error(RetTypeLoc, "functions with 'sret' argument must return void"); 2659a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2660fba933c823a2862067e0696bd5032ab18185bd77Owen Anderson const FunctionType *FT = 2661debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson FunctionType::get(RetType, ParamTypeList, isVarArg); 2662debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson const PointerType *PFT = PointerType::getUnqual(FT); 2663df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2664df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn = 0; 2665df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!FunctionName.empty()) { 2666df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this was a definition of a forward reference, remove the definition 2667df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // from the forward reference table and fill in the forward ref. 2668df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<std::string, std::pair<GlobalValue*, LocTy> >::iterator FRVI = 2669df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals.find(FunctionName); 2670df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FRVI != ForwardRefVals.end()) { 2671df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn = M->getFunction(FunctionName); 2672df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefVals.erase(FRVI); 2673df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if ((Fn = M->getFunction(FunctionName))) { 2674df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this function already exists in the symbol table, then it is 2675df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // multiply defined. We accept a few cases for old backwards compat. 2676df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: Remove this stuff for LLVM 3.0. 2677df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Fn->getType() != PFT || Fn->getAttributes() != PAL || 2678df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner (!Fn->isDeclaration() && isDefine)) { 2679df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If the redefinition has different type or different attributes, 2680df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // reject it. If both have bodies, reject it. 2681df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(NameLoc, "invalid redefinition of function '" + 2682df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FunctionName + "'"); 2683df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Fn->isDeclaration()) { 2684df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Make sure to strip off any argument names so we can't get conflicts. 2685df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end(); 2686df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AI != AE; ++AI) 2687df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AI->setName(""); 2688df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 26891d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner } else if (M->getNamedValue(FunctionName)) { 26901d871c5e547996a8dd5192e48d22aadf11cd2a9dChris Lattner return Error(NameLoc, "redefinition of function '@" + FunctionName + "'"); 2691df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2692a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2693419055453cdc4f9be4a3ad80f9b49e881d528fe9Dan Gohman } else { 2694df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this is a definition of a forward referenced function, make sure the 2695df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // types agree. 2696df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::map<unsigned, std::pair<GlobalValue*, LocTy> >::iterator I 2697df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner = ForwardRefValIDs.find(NumberedVals.size()); 2698df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != ForwardRefValIDs.end()) { 2699df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn = cast<Function>(I->second.first); 2700df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Fn->getType() != PFT) 2701df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(NameLoc, "type of definition and forward reference of '@" + 2702df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner utostr(NumberedVals.size()) +"' disagree"); 2703df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ForwardRefValIDs.erase(I); 2704df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2705df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2706df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2707df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Fn == 0) 2708df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M); 2709df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner else // Move the forward-reference to the correct spot in the module. 2710df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn); 2711df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2712df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FunctionName.empty()) 2713df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NumberedVals.push_back(Fn); 2714a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2715df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn->setLinkage((GlobalValue::LinkageTypes)Linkage); 2716df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn->setVisibility((GlobalValue::VisibilityTypes)Visibility); 2717df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn->setCallingConv(CC); 2718df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn->setAttributes(PAL); 2719df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn->setAlignment(Alignment); 2720df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Fn->setSection(Section); 2721df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!GC.empty()) Fn->setGC(GC.c_str()); 2722a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2723df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Add all of the arguments we parsed to the function. 2724df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Function::arg_iterator ArgIt = Fn->arg_begin(); 2725df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i, ++ArgIt) { 27265bda3792b44c8f5e1f9b974a18eb6061c3d27f89Chris Lattner // If we run out of arguments in the Function prototype, exit early. 27275bda3792b44c8f5e1f9b974a18eb6061c3d27f89Chris Lattner // FIXME: REMOVE THIS IN LLVM 3.0, this is just for the mismatch case above. 27285bda3792b44c8f5e1f9b974a18eb6061c3d27f89Chris Lattner if (ArgIt == Fn->arg_end()) break; 27295bda3792b44c8f5e1f9b974a18eb6061c3d27f89Chris Lattner 2730df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If the argument has a name, insert it into the argument symbol table. 2731df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ArgList[i].Name.empty()) continue; 2732a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2733df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set the name, if it conflicted, it will be auto-renamed. 2734df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ArgIt->setName(ArgList[i].Name); 2735a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2736df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ArgIt->getNameStr() != ArgList[i].Name) 2737df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ArgList[i].Loc, "redefinition of argument '%" + 2738df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ArgList[i].Name + "'"); 2739df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2740a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2741df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2742df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2743df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2744df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2745df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseFunctionBody 2746df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= '{' BasicBlock+ '}' 2747df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'begin' BasicBlock+ 'end' // FIXME: remove in LLVM 3.0 2748df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 2749df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseFunctionBody(Function &Fn) { 2750df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() != lltok::lbrace && Lex.getKind() != lltok::kw_begin) 2751df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected '{' in function body"); 2752df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // eat the {. 2753a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 275409d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner int FunctionNumber = -1; 275509d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner if (!Fn.hasName()) FunctionNumber = NumberedVals.size()-1; 275609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner 275709d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner PerFunctionState PFS(*this, Fn, FunctionNumber); 2758a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2759df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (Lex.getKind() != lltok::rbrace && Lex.getKind() != lltok::kw_end) 2760df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseBasicBlock(PFS)) return true; 2761a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2762df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Eat the }. 2763df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2764a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2765df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Verify function is ok. 276609d9ef4122414a1a2ec95f52d660d6500f2819d0Chris Lattner return PFS.FinishFunction(); 2767df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2768df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2769df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseBasicBlock 2770df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= LabelStr? Instruction* 2771df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseBasicBlock(PerFunctionState &PFS) { 2772df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If this basic block starts out with a name, remember it. 2773df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::string Name; 2774df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy NameLoc = Lex.getLoc(); 2775df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::LabelStr) { 2776df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Name = Lex.getStrVal(); 2777df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2778df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2779a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2780df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner BasicBlock *BB = PFS.DefineBB(Name, NameLoc); 2781df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (BB == 0) return true; 2782a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2783df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::string NameStr; 2784a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2785df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Parse the instructions in this block until we get a terminator. 2786df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Instruction *Inst; 2787df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner do { 2788df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // This instruction may have three possibilities for a name: a) none 2789df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // specified, b) name specified "%foo =", c) number specified: "%4 =". 2790df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy NameLoc = Lex.getLoc(); 2791df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner int NameID = -1; 2792df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NameStr = ""; 2793a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2794df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Lex.getKind() == lltok::LocalVarID) { 2795df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NameID = Lex.getUIntVal(); 2796df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2797df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::equal, "expected '=' after instruction id")) 2798df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2799df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (Lex.getKind() == lltok::LocalVar || 2800df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: REMOVE IN LLVM 3.0 2801df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.getKind() == lltok::StringConstant) { 2802df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner NameStr = Lex.getStrVal(); 2803df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2804df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::equal, "expected '=' after instruction name")) 2805df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 2806df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2807f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 2808df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseInstruction(Inst, BB, PFS)) return true; 2809f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (EatIfPresent(lltok::comma)) 28100475c9170e9621292a48c688c3976031be5650bbDevang Patel ParseOptionalCustomMetadata(); 2811f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 2812f633a065de959b32892c51d741d4db010c5d25b1Devang Patel // Set metadata attached with this instruction. 2813a2148402ce39fb3aad09e98a32078d3853a01ae9Devang Patel for (SmallVector<std::pair<unsigned, MDNode *>, 2>::iterator 2814a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar MDI = MDsOnInst.begin(), MDE = MDsOnInst.end(); MDI != MDE; ++MDI) 28153990b121cf4a0b280ed3e54cf13870cbf4259e78Chris Lattner Inst->setMetadata(MDI->first, MDI->second); 2816f633a065de959b32892c51d741d4db010c5d25b1Devang Patel MDsOnInst.clear(); 2817f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 2818df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner BB->getInstList().push_back(Inst); 2819df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2820df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set the name on the instruction. 2821df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (PFS.SetInstName(NameID, NameStr, NameLoc, Inst)) return true; 2822df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } while (!isa<TerminatorInst>(Inst)); 2823a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2824df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2825df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2826df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2827df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 2828df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Instruction Parsing. 2829df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 2830df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2831df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseInstruction - Parse one of the many different instructions. 2832df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// 2833df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseInstruction(Instruction *&Inst, BasicBlock *BB, 2834df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PerFunctionState &PFS) { 2835df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner lltok::Kind Token = Lex.getKind(); 2836df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Token == lltok::Eof) 2837df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("found end of file when expecting more instructions"); 2838df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc = Lex.getLoc(); 2839f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner unsigned KeywordVal = Lex.getUIntVal(); 2840df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // Eat the keyword. 2841a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 2842df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Token) { 2843df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: return Error(Loc, "expected instruction opcode"); 2844df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Terminator Instructions. 28451d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson case lltok::kw_unwind: Inst = new UnwindInst(Context); return false; 28461d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson case lltok::kw_unreachable: Inst = new UnreachableInst(Context); return false; 2847df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ret: return ParseRet(Inst, BB, PFS); 2848df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_br: return ParseBr(Inst, PFS); 2849df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_switch: return ParseSwitch(Inst, PFS); 2850ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner case lltok::kw_indirectbr: return ParseIndirectBr(Inst, PFS); 2851df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_invoke: return ParseInvoke(Inst, PFS); 2852df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Binary Operators. 2853df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_add: 2854df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sub: 285559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman case lltok::kw_mul: { 285659858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool NUW = false; 285759858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool NSW = false; 285859858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman LocTy ModifierLoc = Lex.getLoc(); 285959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_nuw)) 286059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman NUW = true; 286159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_nsw)) { 286259858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman NSW = true; 286359858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_nuw)) 286459858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman NUW = true; 286559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 2866ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman // API compatibility: Accept either integer or floating-point types. 286759858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 0); 286859858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (!Result) { 286959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (!Inst->getType()->isIntOrIntVector()) { 287059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (NUW) 287159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman return Error(ModifierLoc, "nuw only applies to integer operations"); 287259858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (NSW) 287359858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman return Error(ModifierLoc, "nsw only applies to integer operations"); 287459858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 287559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (NUW) 2876f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<BinaryOperator>(Inst)->setHasNoUnsignedWrap(true); 287759858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (NSW) 2878f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<BinaryOperator>(Inst)->setHasNoSignedWrap(true); 287959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 288059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman return Result; 288159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 2882ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case lltok::kw_fadd: 2883ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case lltok::kw_fsub: 2884ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case lltok::kw_fmul: return ParseArithmetic(Inst, PFS, KeywordVal, 2); 2885ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman 288659858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman case lltok::kw_sdiv: { 288759858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool Exact = false; 288859858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (EatIfPresent(lltok::kw_exact)) 288959858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman Exact = true; 289059858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman bool Result = ParseArithmetic(Inst, PFS, KeywordVal, 1); 289159858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (!Result) 289259858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman if (Exact) 2893f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<BinaryOperator>(Inst)->setIsExact(true); 289459858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman return Result; 289559858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman } 289659858cf7926702596cf708daf21aeaf5b6feedf8Dan Gohman 2897df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_udiv: 2898df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_urem: 2899f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner case lltok::kw_srem: return ParseArithmetic(Inst, PFS, KeywordVal, 1); 2900e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner case lltok::kw_fdiv: 2901f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner case lltok::kw_frem: return ParseArithmetic(Inst, PFS, KeywordVal, 2); 2902df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_shl: 2903df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_lshr: 2904df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ashr: 2905df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_and: 2906df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_or: 2907f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner case lltok::kw_xor: return ParseLogical(Inst, PFS, KeywordVal); 2908df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_icmp: 29097f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky case lltok::kw_fcmp: return ParseCompare(Inst, PFS, KeywordVal); 2910df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Casts. 2911df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_trunc: 2912df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_zext: 2913df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sext: 2914df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fptrunc: 2915df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fpext: 2916df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_bitcast: 2917df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_uitofp: 2918df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sitofp: 2919df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_fptoui: 2920a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar case lltok::kw_fptosi: 2921df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_inttoptr: 2922f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner case lltok::kw_ptrtoint: return ParseCast(Inst, PFS, KeywordVal); 2923df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Other. 2924df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_select: return ParseSelect(Inst, PFS); 29250088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner case lltok::kw_va_arg: return ParseVA_Arg(Inst, PFS); 2926df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_extractelement: return ParseExtractElement(Inst, PFS); 2927df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_insertelement: return ParseInsertElement(Inst, PFS); 2928df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_shufflevector: return ParseShuffleVector(Inst, PFS); 2929df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_phi: return ParsePHI(Inst, PFS); 2930df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_call: return ParseCall(Inst, PFS, false); 2931df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_tail: return ParseCall(Inst, PFS, true); 2932df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Memory. 293313ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez case lltok::kw_alloca: return ParseAlloc(Inst, PFS); 293413ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez case lltok::kw_malloc: return ParseAlloc(Inst, PFS, BB, false); 293566284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandez case lltok::kw_free: return ParseFree(Inst, PFS, BB); 2936df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_load: return ParseLoad(Inst, PFS, false); 2937df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_store: return ParseStore(Inst, PFS, false); 2938df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_volatile: 29393ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (EatIfPresent(lltok::kw_load)) 2940df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseLoad(Inst, PFS, true); 29413ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner else if (EatIfPresent(lltok::kw_store)) 2942df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return ParseStore(Inst, PFS, true); 29433ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner else 2944df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return TokError("expected 'load' or 'store'"); 2945df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_getresult: return ParseGetResult(Inst, PFS); 2946df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_getelementptr: return ParseGetElementPtr(Inst, PFS); 2947df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_extractvalue: return ParseExtractValue(Inst, PFS); 2948df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_insertvalue: return ParseInsertValue(Inst, PFS); 2949df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2950df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2951df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2952df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseCmpPredicate - Parse an integer or fp predicate, based on Kind. 2953df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseCmpPredicate(unsigned &P, unsigned Opc) { 29547f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky if (Opc == Instruction::FCmp) { 2955df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 2956df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: TokError("expected fcmp predicate (e.g. 'oeq')"); 2957df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_oeq: P = CmpInst::FCMP_OEQ; break; 2958df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_one: P = CmpInst::FCMP_ONE; break; 2959df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_olt: P = CmpInst::FCMP_OLT; break; 2960df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ogt: P = CmpInst::FCMP_OGT; break; 2961df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ole: P = CmpInst::FCMP_OLE; break; 2962df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_oge: P = CmpInst::FCMP_OGE; break; 2963df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ord: P = CmpInst::FCMP_ORD; break; 2964df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_uno: P = CmpInst::FCMP_UNO; break; 2965df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ueq: P = CmpInst::FCMP_UEQ; break; 2966df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_une: P = CmpInst::FCMP_UNE; break; 2967df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ult: P = CmpInst::FCMP_ULT; break; 2968df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ugt: P = CmpInst::FCMP_UGT; break; 2969df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ule: P = CmpInst::FCMP_ULE; break; 2970df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_uge: P = CmpInst::FCMP_UGE; break; 2971df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_true: P = CmpInst::FCMP_TRUE; break; 2972df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_false: P = CmpInst::FCMP_FALSE; break; 2973df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2974df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else { 2975df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner switch (Lex.getKind()) { 2976df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner default: TokError("expected icmp predicate (e.g. 'eq')"); 2977df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_eq: P = CmpInst::ICMP_EQ; break; 2978df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ne: P = CmpInst::ICMP_NE; break; 2979df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_slt: P = CmpInst::ICMP_SLT; break; 2980df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sgt: P = CmpInst::ICMP_SGT; break; 2981df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sle: P = CmpInst::ICMP_SLE; break; 2982df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_sge: P = CmpInst::ICMP_SGE; break; 2983df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ult: P = CmpInst::ICMP_ULT; break; 2984df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ugt: P = CmpInst::ICMP_UGT; break; 2985df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_ule: P = CmpInst::ICMP_ULE; break; 2986df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner case lltok::kw_uge: P = CmpInst::ICMP_UGE; break; 2987df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2988df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 2989df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); 2990df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 2991df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 2992df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2993df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 2994df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Terminator Instructions. 2995df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 2996df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 2997df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseRet - Parse a return instruction. 29983f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner/// ::= 'ret' void (',' !dbg, !1)* 29993f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner/// ::= 'ret' TypeAndValue (',' !dbg, !1)* 30003f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner/// ::= 'ret' TypeAndValue (',' TypeAndValue)+ (',' !dbg, !1)* 3001f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// [[obsolete: LLVM 3.0]] 3002df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseRet(Instruction *&Inst, BasicBlock *BB, 3003df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PerFunctionState &PFS) { 30041d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 3005a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner if (ParseType(Ty, true /*void allowed*/)) return true; 3006a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3007cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isVoidTy()) { 30081d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Inst = ReturnInst::Create(Context); 3009df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3010df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3011a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3012df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *RV; 3013df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseValue(Ty, RV, PFS)) return true; 3014df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3015f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (EatIfPresent(lltok::comma)) { 30160475c9170e9621292a48c688c3976031be5650bbDevang Patel // Parse optional custom metadata, e.g. !dbg 30170475c9170e9621292a48c688c3976031be5650bbDevang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) { 30180475c9170e9621292a48c688c3976031be5650bbDevang Patel if (ParseOptionalCustomMetadata()) return true; 3019f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } else { 3020f633a065de959b32892c51d741d4db010c5d25b1Devang Patel // The normal case is one return value. 30213f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner // FIXME: LLVM 3.0 remove MRV support for 'ret i32 1, i32 2', requiring 30223f3a0f6b498e80ffaeb83f03c8697e5d54fd9337Chris Lattner // use of 'ret {i32,i32} {i32 1, i32 2}' 3023f633a065de959b32892c51d741d4db010c5d25b1Devang Patel SmallVector<Value*, 8> RVs; 3024f633a065de959b32892c51d741d4db010c5d25b1Devang Patel RVs.push_back(RV); 3025a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3026f633a065de959b32892c51d741d4db010c5d25b1Devang Patel do { 30270475c9170e9621292a48c688c3976031be5650bbDevang Patel // If optional custom metadata, e.g. !dbg is seen then this is the 30280475c9170e9621292a48c688c3976031be5650bbDevang Patel // end of MRV. 30290475c9170e9621292a48c688c3976031be5650bbDevang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 3030a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar break; 3031a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar if (ParseTypeAndValue(RV, PFS)) return true; 3032a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar RVs.push_back(RV); 3033f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } while (EatIfPresent(lltok::comma)); 3034f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 3035f633a065de959b32892c51d741d4db010c5d25b1Devang Patel RV = UndefValue::get(PFS.getFunction().getReturnType()); 3036f633a065de959b32892c51d741d4db010c5d25b1Devang Patel for (unsigned i = 0, e = RVs.size(); i != e; ++i) { 3037a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar Instruction *I = InsertValueInst::Create(RV, RVs[i], i, "mrv"); 3038a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar BB->getInstList().push_back(I); 3039a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar RV = I; 3040f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } 3041df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3042df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3043f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 30441d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Inst = ReturnInst::Create(Context, RV); 3045df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3046df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3047df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3048df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3049df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseBr 3050df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'br' TypeAndValue 3051df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'br' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3052df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseBr(Instruction *&Inst, PerFunctionState &PFS) { 3053df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc, Loc2; 3054f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Value *Op0; 3055f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner BasicBlock *Op1, *Op2; 3056df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op0, Loc, PFS)) return true; 3057a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3058df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (BasicBlock *BB = dyn_cast<BasicBlock>(Op0)) { 3059df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = BranchInst::Create(BB); 3060df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3061df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3062a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 30631d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Op0->getType() != Type::getInt1Ty(Context)) 3064df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "branch condition must have 'i1' type"); 3065a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3066df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseToken(lltok::comma, "expected ',' after branch condition") || 3067f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner ParseTypeAndBasicBlock(Op1, Loc, PFS) || 3068df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after true destination") || 3069f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner ParseTypeAndBasicBlock(Op2, Loc2, PFS)) 3070df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3071a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3072f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Inst = BranchInst::Create(Op1, Op2, Op0); 3073df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3074df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3075df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3076df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseSwitch 3077df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// Instruction 3078df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'switch' TypeAndValue ',' TypeAndValue '[' JumpTable ']' 3079df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// JumpTable 3080df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= (TypeAndValue ',' TypeAndValue)* 3081df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseSwitch(Instruction *&Inst, PerFunctionState &PFS) { 3082df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy CondLoc, BBLoc; 3083f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Value *Cond; 3084f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner BasicBlock *DefaultBB; 3085df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Cond, CondLoc, PFS) || 3086df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after switch condition") || 3087f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner ParseTypeAndBasicBlock(DefaultBB, BBLoc, PFS) || 3088df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::lsquare, "expected '[' with switch table")) 3089df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3090df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3091df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<IntegerType>(Cond->getType())) 3092df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(CondLoc, "switch condition must have integer type"); 3093a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3094df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Parse the jump table pairs. 3095df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallPtrSet<Value*, 32> SeenCases; 3096df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table; 3097df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (Lex.getKind() != lltok::rsquare) { 3098f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Value *Constant; 3099f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner BasicBlock *DestBB; 3100a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3101df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Constant, CondLoc, PFS) || 3102df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after case value") || 3103f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner ParseTypeAndBasicBlock(DestBB, PFS)) 3104df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3105f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3106df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!SeenCases.insert(Constant)) 3107df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(CondLoc, "duplicate case value in switch"); 3108df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<ConstantInt>(Constant)) 3109df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(CondLoc, "case value is not a constant integer"); 3110a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3111f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB)); 3112df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3113a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3114df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Lex.Lex(); // Eat the ']'. 3115a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3116f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner SwitchInst *SI = SwitchInst::Create(Cond, DefaultBB, Table.size()); 3117df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = Table.size(); i != e; ++i) 3118df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SI->addCase(Table[i].first, Table[i].second); 3119df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = SI; 3120df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3121df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3122df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3123ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner/// ParseIndirectBr 3124f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner/// Instruction 3125ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner/// ::= 'indirectbr' TypeAndValue ',' '[' LabelList ']' 3126ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattnerbool LLParser::ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS) { 3127f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner LocTy AddrLoc; 3128f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Value *Address; 3129f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (ParseTypeAndValue(Address, AddrLoc, PFS) || 3130ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner ParseToken(lltok::comma, "expected ',' after indirectbr address") || 3131ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner ParseToken(lltok::lsquare, "expected '[' with indirectbr")) 3132f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return true; 3133f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3134f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (!isa<PointerType>(Address->getType())) 3135ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner return Error(AddrLoc, "indirectbr address must have pointer type"); 3136f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3137f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner // Parse the destination list. 3138f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner SmallVector<BasicBlock*, 16> DestList; 3139f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3140f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (Lex.getKind() != lltok::rsquare) { 3141f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner BasicBlock *DestBB; 3142f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (ParseTypeAndBasicBlock(DestBB, PFS)) 3143f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return true; 3144f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner DestList.push_back(DestBB); 3145f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3146f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner while (EatIfPresent(lltok::comma)) { 3147f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (ParseTypeAndBasicBlock(DestBB, PFS)) 3148f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return true; 3149f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner DestList.push_back(DestBB); 3150f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner } 3151f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner } 3152f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3153f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner if (ParseToken(lltok::rsquare, "expected ']' at end of block list")) 3154f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return true; 3155f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3156ab21db79ef1d2530880ad11f21f0b87ffca02dd4Chris Lattner IndirectBrInst *IBI = IndirectBrInst::Create(Address, DestList.size()); 3157f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner for (unsigned i = 0, e = DestList.size(); i != e; ++i) 3158f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner IBI->addDestination(DestList[i]); 3159f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner Inst = IBI; 3160f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner return false; 3161f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner} 3162f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3163f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner 3164df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseInvoke 3165df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'invoke' OptionalCallingConv OptionalAttrs Type Value ParamList 3166df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// OptionalAttrs 'to' TypeAndValue 'unwind' TypeAndValue 3167df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) { 3168df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy CallLoc = Lex.getLoc(); 316965c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel unsigned RetAttrs, FnAttrs; 317065c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel CallingConv::ID CC; 31711d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder RetType(Type::getVoidTy(Context)); 3172df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy RetTypeLoc; 3173df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ValID CalleeID; 3174df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<ParamInfo, 16> ArgList; 3175df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3176f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner BasicBlock *NormalBB, *UnwindBB; 3177df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseOptionalCallingConv(CC) || 3178df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAttrs(RetAttrs, 1) || 3179a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner ParseType(RetType, RetTypeLoc, true /*void allowed*/) || 3180df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValID(CalleeID) || 3181df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseParameterList(ArgList, PFS) || 3182df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAttrs(FnAttrs, 2) || 3183df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::kw_to, "expected 'to' in invoke") || 3184f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner ParseTypeAndBasicBlock(NormalBB, PFS) || 3185df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::kw_unwind, "expected 'unwind' in invoke") || 3186f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner ParseTypeAndBasicBlock(UnwindBB, PFS)) 3187df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3188a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3189df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If RetType is a non-function pointer type, then this is the short syntax 3190df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // for the call, which means that RetType is just the return type. Infer the 3191df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // rest of the function argument types from the arguments that are present. 3192df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const PointerType *PFTy = 0; 3193df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const FunctionType *Ty = 0; 3194df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!(PFTy = dyn_cast<PointerType>(RetType)) || 3195df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { 3196df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Pull out the types of all of the arguments... 3197df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<const Type*> ParamTypes; 3198df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 3199df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParamTypes.push_back(ArgList[i].V->getType()); 3200a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3201df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!FunctionType::isValidReturnType(RetType)) 3202df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(RetTypeLoc, "Invalid result type for LLVM function"); 3203a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3204debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Ty = FunctionType::get(RetType, ParamTypes, false); 3205debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson PFTy = PointerType::getUnqual(Ty); 3206df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3207a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3208df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Look up the callee. 3209df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Callee; 3210df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true; 3211a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3212df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional 3213df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // function attributes. 3214df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; 3215df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FnAttrs & ObsoleteFuncAttrs) { 3216df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner RetAttrs |= FnAttrs & ObsoleteFuncAttrs; 3217df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FnAttrs &= ~ObsoleteFuncAttrs; 3218df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3219a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3220df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set up the Attributes for the function. 3221df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<AttributeWithIndex, 8> Attrs; 3222df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (RetAttrs != Attribute::None) 3223df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); 3224a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3225df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Value*, 8> Args; 3226a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3227df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Loop through FunctionType's arguments and ensure they are specified 3228df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // correctly. Also, gather any parameter attributes. 3229df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FunctionType::param_iterator I = Ty->param_begin(); 3230df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FunctionType::param_iterator E = Ty->param_end(); 3231df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3232df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const Type *ExpectedTy = 0; 3233df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != E) { 3234df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ExpectedTy = *I++; 3235df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (!Ty->isVarArg()) { 3236df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ArgList[i].Loc, "too many arguments specified"); 3237df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3238a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3239df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) 3240df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ArgList[i].Loc, "argument is not of expected type '" + 3241df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ExpectedTy->getDescription() + "'"); 3242df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Args.push_back(ArgList[i].V); 3243df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ArgList[i].Attrs != Attribute::None) 3244df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); 3245df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3246a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3247df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != E) 3248df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(CallLoc, "not enough parameters specified for call"); 3249a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3250df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FnAttrs != Attribute::None) 3251df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); 3252a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3253df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Finish off the Attributes and check them 3254df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); 3255a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3256f9be95f867745b6754b2402b9b72f9eaeabd637fChris Lattner InvokeInst *II = InvokeInst::Create(Callee, NormalBB, UnwindBB, 3257df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Args.begin(), Args.end()); 3258df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner II->setCallingConv(CC); 3259df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner II->setAttributes(PAL); 3260df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = II; 3261df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3262df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3263df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3264df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3265df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3266df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 3267df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Binary Operators. 3268df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 3269df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3270df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseArithmetic 3271e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner/// ::= ArithmeticOps TypeAndValue ',' Value 3272e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner/// 3273e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner/// If OperandType is 0, then any FP or integer operand is allowed. If it is 1, 3274e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner/// then any integer operand is allowed, if it is 2, any fp operand is allowed. 3275df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseArithmetic(Instruction *&Inst, PerFunctionState &PFS, 3276e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner unsigned Opc, unsigned OperandType) { 3277df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; Value *LHS, *RHS; 3278df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(LHS, Loc, PFS) || 3279df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' in arithmetic operation") || 3280df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValue(LHS->getType(), RHS, PFS)) 3281df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3282df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3283e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner bool Valid; 3284e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner switch (OperandType) { 3285c23197a26f34f559ea9797de51e187087c039c42Torok Edwin default: llvm_unreachable("Unknown operand type!"); 3286e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner case 0: // int or FP. 3287e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner Valid = LHS->getType()->isIntOrIntVector() || 3288e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner LHS->getType()->isFPOrFPVector(); 3289e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner break; 3290e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner case 1: Valid = LHS->getType()->isIntOrIntVector(); break; 3291e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner case 2: Valid = LHS->getType()->isFPOrFPVector(); break; 3292e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner } 3293a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3294e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner if (!Valid) 3295e914b59c008745204c49fcf0751f9cc4d91f44bbChris Lattner return Error(Loc, "invalid operand type for instruction"); 3296a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3297df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 3298df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3299df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3300df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3301df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseLogical 3302df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= ArithmeticOps TypeAndValue ',' Value { 3303df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseLogical(Instruction *&Inst, PerFunctionState &PFS, 3304df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc) { 3305df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; Value *LHS, *RHS; 3306df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(LHS, Loc, PFS) || 3307df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' in logical operation") || 3308df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValue(LHS->getType(), RHS, PFS)) 3309df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3310df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3311df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!LHS->getType()->isIntOrIntVector()) 3312df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc,"instruction requires integer or integer vector operands"); 3313df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3314df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = BinaryOperator::Create((Instruction::BinaryOps)Opc, LHS, RHS); 3315df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3316df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3317df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3318df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3319df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseCompare 3320df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'icmp' IPredicates TypeAndValue ',' Value 3321df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'fcmp' FPredicates TypeAndValue ',' Value 3322df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseCompare(Instruction *&Inst, PerFunctionState &PFS, 3323df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc) { 3324df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Parse the integer/fp comparison predicate. 3325df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; 3326df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Pred; 3327df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *LHS, *RHS; 3328df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseCmpPredicate(Pred, Opc) || 3329df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(LHS, Loc, PFS) || 3330df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after compare value") || 3331df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValue(LHS->getType(), RHS, PFS)) 3332df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3333a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3334df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (Opc == Instruction::FCmp) { 3335df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!LHS->getType()->isFPOrFPVector()) 3336df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "fcmp requires floating point operands"); 33371c8a23c440b1665ba422778cdc74a0c59ecaf39eDan Gohman Inst = new FCmpInst(CmpInst::Predicate(Pred), LHS, RHS); 33387f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky } else { 33397f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky assert(Opc == Instruction::ICmp && "Unknown opcode for CmpInst!"); 3340df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!LHS->getType()->isIntOrIntVector() && 3341df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !isa<PointerType>(LHS->getType())) 3342df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "icmp requires integer operands"); 33431c8a23c440b1665ba422778cdc74a0c59ecaf39eDan Gohman Inst = new ICmpInst(CmpInst::Predicate(Pred), LHS, RHS); 3344df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3345df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3346df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3347df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3348df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 3349df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Other Instructions. 3350df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 3351df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3352df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3353df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseCast 3354df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= CastOpc TypeAndValue 'to' Type 3355df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseCast(Instruction *&Inst, PerFunctionState &PFS, 3356df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Opc) { 3357df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; Value *Op; 33581d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder DestTy(Type::getVoidTy(Context)); 3359df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op, Loc, PFS) || 3360df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::kw_to, "expected 'to' after cast value") || 3361df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseType(DestTy)) 3362df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3363a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3364f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) { 3365f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy); 3366df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "invalid cast opcode for cast from '" + 3367df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Op->getType()->getDescription() + "' to '" + 3368df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner DestTy->getDescription() + "'"); 3369f6f0bdfec336b596b095b4db8126149bbb33fec1Chris Lattner } 3370df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy); 3371df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3372df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3373df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3374df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseSelect 3375df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3376df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseSelect(Instruction *&Inst, PerFunctionState &PFS) { 3377df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; 3378df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Op0, *Op1, *Op2; 3379df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op0, Loc, PFS) || 3380df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after select condition") || 3381df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op1, PFS) || 3382df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after select value") || 3383df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op2, PFS)) 3384df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3385a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3386df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (const char *Reason = SelectInst::areInvalidOperands(Op0, Op1, Op2)) 3387df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, Reason); 3388a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3389df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = SelectInst::Create(Op0, Op1, Op2); 3390df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3391df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3392df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 33930088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner/// ParseVA_Arg 33940088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner/// ::= 'va_arg' TypeAndValue ',' Type 33950088a5cc722b9e32820d31c70175a7650ad4772dChris Lattnerbool LLParser::ParseVA_Arg(Instruction *&Inst, PerFunctionState &PFS) { 3396df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Op; 33971d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder EltTy(Type::getVoidTy(Context)); 33980088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner LocTy TypeLoc; 3399df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op, PFS) || 3400df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after vaarg operand") || 34010088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner ParseType(EltTy, TypeLoc)) 3402df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3403a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 34040088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner if (!EltTy->isFirstClassType()) 34050088a5cc722b9e32820d31c70175a7650ad4772dChris Lattner return Error(TypeLoc, "va_arg requires operand with first class type"); 3406df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3407df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = new VAArgInst(Op, EltTy); 3408df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3409df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3410df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3411df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseExtractElement 3412df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'extractelement' TypeAndValue ',' TypeAndValue 3413df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseExtractElement(Instruction *&Inst, PerFunctionState &PFS) { 3414df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; 3415df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Op0, *Op1; 3416df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op0, Loc, PFS) || 3417df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after extract value") || 3418df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op1, PFS)) 3419df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3420a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3421df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractElementInst::isValidOperands(Op0, Op1)) 3422df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "invalid extractelement operands"); 3423a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3424a3500da5592aee83675d6714d4f1e9d5ad96d1f2Eric Christopher Inst = ExtractElementInst::Create(Op0, Op1); 3425df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3426df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3427df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3428df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseInsertElement 3429df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'insertelement' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3430df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseInsertElement(Instruction *&Inst, PerFunctionState &PFS) { 3431df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; 3432df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Op0, *Op1, *Op2; 3433df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op0, Loc, PFS) || 3434df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after insertelement value") || 3435df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op1, PFS) || 3436df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after insertelement value") || 3437df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op2, PFS)) 3438df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3439a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3440df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!InsertElementInst::isValidOperands(Op0, Op1, Op2)) 34410aaf4e91c2961585c160af0cc87f040301aafbd2Eric Christopher return Error(Loc, "invalid insertelement operands"); 3442a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3443df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = InsertElementInst::Create(Op0, Op1, Op2); 3444df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3445df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3446df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3447df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseShuffleVector 3448df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'shufflevector' TypeAndValue ',' TypeAndValue ',' TypeAndValue 3449df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseShuffleVector(Instruction *&Inst, PerFunctionState &PFS) { 3450df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy Loc; 3451df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Op0, *Op1, *Op2; 3452df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Op0, Loc, PFS) || 3453df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after shuffle mask") || 3454df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op1, PFS) || 3455df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after shuffle value") || 3456df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Op2, PFS)) 3457df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3458a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3459df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ShuffleVectorInst::isValidOperands(Op0, Op1, Op2)) 3460df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "invalid extractelement operands"); 3461a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3462df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = new ShuffleVectorInst(Op0, Op1, Op2); 3463df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3464df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3465df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3466df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParsePHI 3467c6e200960812992f1124c92f801166bd1b387971Chris Lattner/// ::= 'phi' Type '[' Value ',' Value ']' (',' '[' Value ',' Value ']')* 3468df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParsePHI(Instruction *&Inst, PerFunctionState &PFS) { 34691d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 3470df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Op0, *Op1; 3471df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy TypeLoc = Lex.getLoc(); 3472a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3473df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseType(Ty) || 3474df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::lsquare, "expected '[' in phi value list") || 3475df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValue(Ty, Op0, PFS) || 3476df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after insertelement value") || 34771d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ParseValue(Type::getLabelTy(Context), Op1, PFS) || 3478df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rsquare, "expected ']' in phi value list")) 3479df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3480a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3481df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<std::pair<Value*, BasicBlock*>, 16> PHIVals; 3482df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner while (1) { 3483df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PHIVals.push_back(std::make_pair(Op0, cast<BasicBlock>(Op1))); 3484a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 34853ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (!EatIfPresent(lltok::comma)) 3486df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner break; 3487df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3488a43d46f523dff4b784ee28a3b196a065a15d90f2Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 3489a43d46f523dff4b784ee28a3b196a065a15d90f2Devang Patel break; 3490a43d46f523dff4b784ee28a3b196a065a15d90f2Devang Patel 34913ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseToken(lltok::lsquare, "expected '[' in phi value list") || 3492df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValue(Ty, Op0, PFS) || 3493df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after insertelement value") || 34941d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson ParseValue(Type::getLabelTy(Context), Op1, PFS) || 3495df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::rsquare, "expected ']' in phi value list")) 3496df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3497df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3498a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3499a43d46f523dff4b784ee28a3b196a065a15d90f2Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 3500a43d46f523dff4b784ee28a3b196a065a15d90f2Devang Patel if (ParseOptionalCustomMetadata()) return true; 3501a43d46f523dff4b784ee28a3b196a065a15d90f2Devang Patel 3502df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Ty->isFirstClassType()) 3503df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(TypeLoc, "phi node must have first class type"); 3504df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3505df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PHINode *PN = PHINode::Create(Ty); 3506df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PN->reserveOperandSpace(PHIVals.size()); 3507df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = PHIVals.size(); i != e; ++i) 3508df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner PN->addIncoming(PHIVals[i].first, PHIVals[i].second); 3509df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = PN; 3510df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3511df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3512df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3513df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseCall 3514df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'tail'? 'call' OptionalCallingConv OptionalAttrs Type Value 3515df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParameterList OptionalAttrs 3516df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS, 3517df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool isTail) { 351865c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel unsigned RetAttrs, FnAttrs; 351965c3c8f323198b99b88b109654194540cf9b3fa5Sandeep Patel CallingConv::ID CC; 35201d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder RetType(Type::getVoidTy(Context)); 3521df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy RetTypeLoc; 3522df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ValID CalleeID; 3523df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<ParamInfo, 16> ArgList; 3524df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner LocTy CallLoc = Lex.getLoc(); 3525a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3526df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if ((isTail && ParseToken(lltok::kw_call, "expected 'tail call'")) || 3527df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalCallingConv(CC) || 3528df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAttrs(RetAttrs, 1) || 3529a9a9e07d1c5d3c73835e716d81c2ec94ad0b865fChris Lattner ParseType(RetType, RetTypeLoc, true /*void allowed*/) || 3530df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseValID(CalleeID) || 3531df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseParameterList(ArgList, PFS) || 3532df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseOptionalAttrs(FnAttrs, 2)) 3533df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3534a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3535df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // If RetType is a non-function pointer type, then this is the short syntax 3536df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // for the call, which means that RetType is just the return type. Infer the 3537df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // rest of the function argument types from the arguments that are present. 3538df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const PointerType *PFTy = 0; 3539df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const FunctionType *Ty = 0; 3540df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!(PFTy = dyn_cast<PointerType>(RetType)) || 3541df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { 3542df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Pull out the types of all of the arguments... 3543df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner std::vector<const Type*> ParamTypes; 3544df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) 3545df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParamTypes.push_back(ArgList[i].V->getType()); 3546a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3547df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!FunctionType::isValidReturnType(RetType)) 3548df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(RetTypeLoc, "Invalid result type for LLVM function"); 3549a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3550debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson Ty = FunctionType::get(RetType, ParamTypes, false); 3551debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson PFTy = PointerType::getUnqual(Ty); 3552df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3553a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3554df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Look up the callee. 3555df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Callee; 3556df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ConvertValIDToValue(PFTy, CalleeID, Callee, PFS)) return true; 3557a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3558df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // FIXME: In LLVM 3.0, stop accepting zext, sext and inreg as optional 3559df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // function attributes. 3560df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned ObsoleteFuncAttrs = Attribute::ZExt|Attribute::SExt|Attribute::InReg; 3561df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FnAttrs & ObsoleteFuncAttrs) { 3562df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner RetAttrs |= FnAttrs & ObsoleteFuncAttrs; 3563df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FnAttrs &= ~ObsoleteFuncAttrs; 3564df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3565df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3566df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Set up the Attributes for the function. 3567df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<AttributeWithIndex, 8> Attrs; 3568df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (RetAttrs != Attribute::None) 3569df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(0, RetAttrs)); 3570a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3571df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Value*, 8> Args; 3572a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3573df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Loop through FunctionType's arguments and ensure they are specified 3574df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // correctly. Also, gather any parameter attributes. 3575df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FunctionType::param_iterator I = Ty->param_begin(); 3576df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner FunctionType::param_iterator E = Ty->param_end(); 3577df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner for (unsigned i = 0, e = ArgList.size(); i != e; ++i) { 3578df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner const Type *ExpectedTy = 0; 3579df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != E) { 3580df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ExpectedTy = *I++; 3581df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } else if (!Ty->isVarArg()) { 3582df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ArgList[i].Loc, "too many arguments specified"); 3583df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3584a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3585df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ExpectedTy && ExpectedTy != ArgList[i].V->getType()) 3586df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ArgList[i].Loc, "argument is not of expected type '" + 3587df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ExpectedTy->getDescription() + "'"); 3588df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Args.push_back(ArgList[i].V); 3589df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ArgList[i].Attrs != Attribute::None) 3590df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(i+1, ArgList[i].Attrs)); 3591df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3592a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3593df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (I != E) 3594df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(CallLoc, "not enough parameters specified for call"); 3595df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3596df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (FnAttrs != Attribute::None) 3597df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Attrs.push_back(AttributeWithIndex::get(~0, FnAttrs)); 3598df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3599df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner // Finish off the Attributes and check them 3600df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner AttrListPtr PAL = AttrListPtr::get(Attrs.begin(), Attrs.end()); 3601a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3602df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner CallInst *CI = CallInst::Create(Callee, Args.begin(), Args.end()); 3603df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner CI->setTailCall(isTail); 3604df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner CI->setCallingConv(CC); 3605df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner CI->setAttributes(PAL); 3606df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = CI; 3607df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3608df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3609df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3610df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 3611df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner// Memory Instructions. 3612df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner//===----------------------------------------------------------------------===// 3613df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3614df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseAlloc 3615f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// ::= 'malloc' Type (',' TypeAndValue)? (',' OptionalInfo)? 3616f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// ::= 'alloca' Type (',' TypeAndValue)? (',' OptionalInfo)? 3617df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS, 361813ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez BasicBlock* BB, bool isAlloca) { 36191d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson PATypeHolder Ty(Type::getVoidTy(Context)); 3620df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Size = 0; 3621eeb4a84ac8d91fb1d5a7c484a1c7047409faee30Chris Lattner LocTy SizeLoc; 3622df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Alignment = 0; 36233ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseType(Ty)) return true; 3624df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 36253ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (EatIfPresent(lltok::comma)) { 36260475c9170e9621292a48c688c3976031be5650bbDevang Patel if (Lex.getKind() == lltok::kw_align 36270475c9170e9621292a48c688c3976031be5650bbDevang Patel || Lex.getKind() == lltok::NamedOrCustomMD) { 3628f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (ParseOptionalInfo(Alignment)) return true; 3629f633a065de959b32892c51d741d4db010c5d25b1Devang Patel } else { 3630f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (ParseTypeAndValue(Size, SizeLoc, PFS)) return true; 3631f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (EatIfPresent(lltok::comma)) 3632a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar if (ParseOptionalInfo(Alignment)) return true; 3633df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3634df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 3635df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 36361d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Size && Size->getType() != Type::getInt32Ty(Context)) 3637df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(SizeLoc, "element count must be i32"); 3638df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 363968afa54033eccda0f55e920cb548588e71a45418Victor Hernandez if (isAlloca) { 364050dead06ffc107edb7e84857baaeeb09039c631cOwen Anderson Inst = new AllocaInst(Ty, Size, Alignment); 364168afa54033eccda0f55e920cb548588e71a45418Victor Hernandez return false; 364213ad5aaaff8a446758b402fd5e9aea22f5bc5682Victor Hernandez } 364368afa54033eccda0f55e920cb548588e71a45418Victor Hernandez 364468afa54033eccda0f55e920cb548588e71a45418Victor Hernandez // Autoupgrade old malloc instruction to malloc call. 364568afa54033eccda0f55e920cb548588e71a45418Victor Hernandez // FIXME: Remove in LLVM 3.0. 364668afa54033eccda0f55e920cb548588e71a45418Victor Hernandez const Type *IntPtrTy = Type::getInt32Ty(Context); 36479d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez Constant *AllocSize = ConstantExpr::getSizeOf(Ty); 36489d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez AllocSize = ConstantExpr::getTruncOrBitCast(AllocSize, IntPtrTy); 364968afa54033eccda0f55e920cb548588e71a45418Victor Hernandez if (!MallocF) 365068afa54033eccda0f55e920cb548588e71a45418Victor Hernandez // Prototype malloc as "void *(int32)". 365168afa54033eccda0f55e920cb548588e71a45418Victor Hernandez // This function is renamed as "malloc" in ValidateEndOfModule(). 3652336ea06493dfa03352d04d94cc8bc2c3c29f8165Victor Hernandez MallocF = cast<Function>( 3653336ea06493dfa03352d04d94cc8bc2c3c29f8165Victor Hernandez M->getOrInsertFunction("", Type::getInt8PtrTy(Context), IntPtrTy, NULL)); 36549d0b704e3ea418441001dac4d1a56c2c224cdbf5Victor Hernandez Inst = CallInst::CreateMalloc(BB, IntPtrTy, Ty, AllocSize, Size, MallocF); 3655df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3656df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3657df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3658df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseFree 3659df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'free' TypeAndValue 366066284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandezbool LLParser::ParseFree(Instruction *&Inst, PerFunctionState &PFS, 366166284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandez BasicBlock* BB) { 3662df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val; LocTy Loc; 3663df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Val, Loc, PFS)) return true; 3664df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<PointerType>(Val->getType())) 3665df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "operand to free must be a pointer"); 366666284e063a1e46500acae48bdc0e4a00652021d1Victor Hernandez Inst = CallInst::CreateFree(Val, BB); 3667df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3668df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3669df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3670df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseLoad 3671f633a065de959b32892c51d741d4db010c5d25b1Devang Patel/// ::= 'volatile'? 'load' TypeAndValue (',' OptionalInfo)? 3672df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS, 3673df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool isVolatile) { 3674df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val; LocTy Loc; 3675f633a065de959b32892c51d741d4db010c5d25b1Devang Patel unsigned Alignment = 0; 3676f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (ParseTypeAndValue(Val, Loc, PFS)) return true; 3677a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3678f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (EatIfPresent(lltok::comma)) 3679f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (ParseOptionalInfo(Alignment)) return true; 3680df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3681df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<PointerType>(Val->getType()) || 3682df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner !cast<PointerType>(Val->getType())->getElementType()->isFirstClassType()) 3683df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "load operand must be a pointer to a first class type"); 3684a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3685df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = new LoadInst(Val, "", isVolatile, Alignment); 3686df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3687df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3688df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3689df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseStore 3690a119de86a064414622562cfe32953de7f9b0ee40Dan Gohman/// ::= 'volatile'? 'store' TypeAndValue ',' TypeAndValue (',' 'align' i32)? 3691df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseStore(Instruction *&Inst, PerFunctionState &PFS, 3692df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner bool isVolatile) { 3693df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val, *Ptr; LocTy Loc, PtrLoc; 3694f633a065de959b32892c51d741d4db010c5d25b1Devang Patel unsigned Alignment = 0; 3695df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Val, Loc, PFS) || 3696df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after store operand") || 3697f633a065de959b32892c51d741d4db010c5d25b1Devang Patel ParseTypeAndValue(Ptr, PtrLoc, PFS)) 3698df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3699f633a065de959b32892c51d741d4db010c5d25b1Devang Patel 3700f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (EatIfPresent(lltok::comma)) 3701f633a065de959b32892c51d741d4db010c5d25b1Devang Patel if (ParseOptionalInfo(Alignment)) return true; 3702a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3703df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<PointerType>(Ptr->getType())) 3704df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(PtrLoc, "store operand must be a pointer"); 3705df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!Val->getType()->isFirstClassType()) 3706df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "store operand must be a first class value"); 3707df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (cast<PointerType>(Ptr->getType())->getElementType() != Val->getType()) 3708df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "stored value and pointer type do not match"); 3709a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3710df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = new StoreInst(Val, Ptr, isVolatile, Alignment); 3711df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3712df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3713df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3714df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseGetResult 3715a119de86a064414622562cfe32953de7f9b0ee40Dan Gohman/// ::= 'getresult' TypeAndValue ',' i32 3716df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// FIXME: Remove support for getresult in LLVM 3.0 3717df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGetResult(Instruction *&Inst, PerFunctionState &PFS) { 3718df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val; LocTy ValLoc, EltLoc; 3719df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner unsigned Element; 3720df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Val, ValLoc, PFS) || 3721df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected ',' after getresult operand") || 37223ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner ParseUInt32(Element, EltLoc)) 3723df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3724a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3725df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) 3726df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(ValLoc, "getresult inst requires an aggregate operand"); 3727df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractValueInst::getIndexedType(Val->getType(), Element)) 3728df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(EltLoc, "invalid getresult index for value"); 3729df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = ExtractValueInst::Create(Val, Element); 3730df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3731df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3732df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3733df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseGetElementPtr 3734dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman/// ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)* 3735df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) { 3736df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Ptr, *Val; LocTy Loc, EltLoc; 3737dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman 3738dcb40a3c1c747c88c4e634e34d1b4d7533a86adaDan Gohman bool InBounds = EatIfPresent(lltok::kw_inbounds); 3739dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman 37403ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseTypeAndValue(Ptr, Loc, PFS)) return true; 3741a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3742df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<PointerType>(Ptr->getType())) 3743df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "base of getelementptr must be a pointer"); 3744a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3745df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<Value*, 16> Indices; 37463ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner while (EatIfPresent(lltok::comma)) { 37476225d64ba244cdf4af3c44e113fc8c589fa39508Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 37486225d64ba244cdf4af3c44e113fc8c589fa39508Devang Patel break; 37493ed88efb03c63aae5542efcdfc5cedec9bc4c18aChris Lattner if (ParseTypeAndValue(Val, EltLoc, PFS)) return true; 3750df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<IntegerType>(Val->getType())) 3751df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(EltLoc, "getelementptr index must be an integer"); 3752df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.push_back(Val); 3753df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner } 37546225d64ba244cdf4af3c44e113fc8c589fa39508Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 37556225d64ba244cdf4af3c44e113fc8c589fa39508Devang Patel if (ParseOptionalCustomMetadata()) return true; 3756a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3757df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!GetElementPtrInst::getIndexedType(Ptr->getType(), 3758df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.begin(), Indices.end())) 3759df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "invalid getelementptr indices"); 3760df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = GetElementPtrInst::Create(Ptr, Indices.begin(), Indices.end()); 3761dd8004dc73d091ccb3927dbbc3b41639a3738ae3Dan Gohman if (InBounds) 3762f8dbee7cea072eb63ae343759975109553697bcbDan Gohman cast<GetElementPtrInst>(Inst)->setIsInBounds(true); 3763df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3764df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3765df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3766df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseExtractValue 3767df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'extractvalue' TypeAndValue (',' uint32)+ 3768df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseExtractValue(Instruction *&Inst, PerFunctionState &PFS) { 3769df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val; LocTy Loc; 3770df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<unsigned, 4> Indices; 3771df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Val, Loc, PFS) || 3772df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseIndexList(Indices)) 3773df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3774e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 3775e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (ParseOptionalCustomMetadata()) return true; 3776df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3777df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<StructType>(Val->getType()) && !isa<ArrayType>(Val->getType())) 3778df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "extractvalue operand must be array or struct"); 3779df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3780df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractValueInst::getIndexedType(Val->getType(), Indices.begin(), 3781df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.end())) 3782df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc, "invalid indices for extractvalue"); 3783df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = ExtractValueInst::Create(Val, Indices.begin(), Indices.end()); 3784df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3785df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 3786df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner 3787df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ParseInsertValue 3788df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner/// ::= 'insertvalue' TypeAndValue ',' TypeAndValue (',' uint32)+ 3789df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattnerbool LLParser::ParseInsertValue(Instruction *&Inst, PerFunctionState &PFS) { 3790df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Value *Val0, *Val1; LocTy Loc0, Loc1; 3791df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner SmallVector<unsigned, 4> Indices; 3792df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (ParseTypeAndValue(Val0, Loc0, PFS) || 3793df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseToken(lltok::comma, "expected comma after insertvalue operand") || 3794df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseTypeAndValue(Val1, Loc1, PFS) || 3795df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner ParseIndexList(Indices)) 3796df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return true; 3797e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (Lex.getKind() == lltok::NamedOrCustomMD) 3798e8bc45a645f1df1c9f8b23c6f29247a61af14f19Devang Patel if (ParseOptionalCustomMetadata()) return true; 3799a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3800df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!isa<StructType>(Val0->getType()) && !isa<ArrayType>(Val0->getType())) 3801df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc0, "extractvalue operand must be array or struct"); 3802a279bc3da55691784064cb47200a1c584408b8abDaniel Dunbar 3803df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner if (!ExtractValueInst::getIndexedType(Val0->getType(), Indices.begin(), 3804df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Indices.end())) 3805df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return Error(Loc0, "invalid indices for insertvalue"); 3806df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner Inst = InsertValueInst::Create(Val0, Val1, Indices.begin(), Indices.end()); 3807df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner return false; 3808df98617b23315e427cc4fad8ccfdd50d68bec2f9Chris Lattner} 380921cc4460efa104e8591b05a90f20130291614344Nick Lewycky 381021cc4460efa104e8591b05a90f20130291614344Nick Lewycky//===----------------------------------------------------------------------===// 381121cc4460efa104e8591b05a90f20130291614344Nick Lewycky// Embedded metadata. 381221cc4460efa104e8591b05a90f20130291614344Nick Lewycky//===----------------------------------------------------------------------===// 381321cc4460efa104e8591b05a90f20130291614344Nick Lewycky 381421cc4460efa104e8591b05a90f20130291614344Nick Lewycky/// ParseMDNodeVector 3815cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky/// ::= Element (',' Element)* 3816cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky/// Element 3817cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky/// ::= 'null' | TypeAndValue 3818cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewyckybool LLParser::ParseMDNodeVector(SmallVectorImpl<Value*> &Elts) { 381921cc4460efa104e8591b05a90f20130291614344Nick Lewycky do { 3820a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner // Null is a special case since it is typeless. 3821a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner if (EatIfPresent(lltok::kw_null)) { 3822a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner Elts.push_back(0); 3823a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner continue; 3824cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky } 3825a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner 3826a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner Value *V = 0; 3827a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner PATypeHolder Ty(Type::getVoidTy(Context)); 3828a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner ValID ID; 3829a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner if (ParseType(Ty) || ParseValID(ID) || 3830a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner ConvertGlobalOrMetadataValIDToValue(Ty, ID, V)) 3831a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner return true; 3832a73523958d39ca10a322fd8b177104ebc2045130Chris Lattner 3833cb33799b9f4e152e3460faa83e59b53ff604c87dNick Lewycky Elts.push_back(V); 383421cc4460efa104e8591b05a90f20130291614344Nick Lewycky } while (EatIfPresent(lltok::comma)); 383521cc4460efa104e8591b05a90f20130291614344Nick Lewycky 383621cc4460efa104e8591b05a90f20130291614344Nick Lewycky return false; 383721cc4460efa104e8591b05a90f20130291614344Nick Lewycky} 3838