LLParser.h revision bf170d4c2ffd9dc99fad1fabfbf1f90f980a9782
14a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project//===-- LLParser.h - Parser Class -------------------------------*- C++ -*-===// 24a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// 34a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// The LLVM Compiler Infrastructure 44a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// 54a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// This file is distributed under the University of Illinois Open Source 64a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// License. See LICENSE.TXT for details. 74a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// 84a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project//===----------------------------------------------------------------------===// 94a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// 104a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// This file defines the parser class for .ll files. 114a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project// 124a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project//===----------------------------------------------------------------------===// 134a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 144a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#ifndef LLVM_ASMPARSER_LLPARSER_H 154a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#define LLVM_ASMPARSER_LLPARSER_H 164a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 174a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#include "LLLexer.h" 184a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#include "llvm/Module.h" 194a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#include "llvm/Type.h" 204a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#include "llvm/Support/ValueHandle.h" 214a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project#include <map> 224a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 234a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Projectnamespace llvm { 244a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class Module; 254a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class OpaqueType; 264a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class Function; 274a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class Value; 284a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class BasicBlock; 294a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class Instruction; 304a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class Constant; 314a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class GlobalValue; 324a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class MetadataBase; 334a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class MDString; 344a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class MDNode; 354a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 364a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// ValID - Represents a reference of a definition of some sort with no type. 374a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// There are several cases where we have to parse the value but where the 384a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// type can depend on later context. This may either be a numeric reference 394a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// or a symbolic (%var) reference. This is just a discriminated union. 404a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project struct ValID { 414a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project enum { 424a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_LocalID, t_GlobalID, // ID in UIntVal. 434a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_LocalName, t_GlobalName, // Name in StrVal. 444a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_APSInt, t_APFloat, // Value in APSIntVal/APFloatVal. 454a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_Null, t_Undef, t_Zero, // No value. 464a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_EmptyArray, // No value: [] 474a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_Constant, // Value in ConstantVal. 484a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_InlineAsm, // Value in StrVal/StrVal2/UIntVal. 494a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_MDNode, // Value in MDNodeVal. 504a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project t_MDString // Value in MDStringVal. 514a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } Kind; 524a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 534a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project LLLexer::LocTy Loc; 544a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project unsigned UIntVal; 554a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::string StrVal, StrVal2; 564a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project APSInt APSIntVal; 574a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project APFloat APFloatVal; 584a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Constant *ConstantVal; 594a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project MDNode *MDNodeVal; 604a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project MDString *MDStringVal; 614a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project ValID() : APFloatVal(0.0) {} 624a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 634a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool operator<(const ValID &RHS) const { 644a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project if (Kind == t_LocalID || Kind == t_GlobalID) 654a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return UIntVal < RHS.UIntVal; 664a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project assert((Kind == t_LocalName || Kind == t_GlobalName) && 674a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project "Ordering not defined for this ValID kind yet"); 684a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return StrVal < RHS.StrVal; 694a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 704a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project }; 714a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 724a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project class LLParser { 734a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project public: 744a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project typedef LLLexer::LocTy LocTy; 754a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project private: 764a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project LLVMContext& Context; 774a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project LLLexer Lex; 784a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Module *M; 794a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 804a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project // Type resolution handling data structures. 814a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::map<std::string, std::pair<PATypeHolder, LocTy> > ForwardRefTypes; 824a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::map<unsigned, std::pair<PATypeHolder, LocTy> > ForwardRefTypeIDs; 834a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::vector<PATypeHolder> NumberedTypes; 844a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::vector<TrackingVH<MDNode> > NumberedMetadata; 854a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::map<unsigned, std::pair<TrackingVH<MDNode>, LocTy> > ForwardRefMDNodes; 864a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project struct UpRefRecord { 874a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// Loc - This is the location of the upref. 884a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project LocTy Loc; 894a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 904a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// NestingLevel - The number of nesting levels that need to be popped 914a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// before this type is resolved. 924a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project unsigned NestingLevel; 934a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 944a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// LastContainedTy - This is the type at the current binding level for 954a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// the type. Every time we reduce the nesting level, this gets updated. 964a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project const Type *LastContainedTy; 974a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 984a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// UpRefTy - This is the actual opaque type that the upreference is 994a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// represented with. 1004a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project OpaqueType *UpRefTy; 1014a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1024a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project UpRefRecord(LocTy L, unsigned NL, OpaqueType *URTy) 1034a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project : Loc(L), NestingLevel(NL), LastContainedTy((Type*)URTy), 1044a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project UpRefTy(URTy) {} 1054a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project }; 1064a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::vector<UpRefRecord> UpRefs; 1074a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1084a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project // Global Value reference information. 1094a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::map<std::string, std::pair<GlobalValue*, LocTy> > ForwardRefVals; 1104a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::map<unsigned, std::pair<GlobalValue*, LocTy> > ForwardRefValIDs; 1114a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::vector<GlobalValue*> NumberedVals; 1124a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1134a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project // References to blockaddress. The key is the function ValID, the value is 1144a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project // a list of references to blocks in that function. 1154a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project std::map<ValID, std::vector<std::pair<ValID, GlobalValue*> > > 1164a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project ForwardRefBlockAddresses; 1174a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1184a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Function *MallocF; 1194a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project public: 1204a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project LLParser(MemoryBuffer *F, SourceMgr &SM, SMDiagnostic &Err, Module *m) : 1214a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Context(m->getContext()), Lex(F, SM, Err, m->getContext()), 1224a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project M(m), MallocF(NULL) {} 1234a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool Run(); 1244a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1254a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project LLVMContext& getContext() { return Context; } 1264a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1274a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project private: 1284a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1294a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool Error(LocTy L, const std::string &Msg) const { 1304a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return Lex.Error(L, Msg); 1314a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 1324a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool TokError(const std::string &Msg) const { 1334a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return Error(Lex.getLoc(), Msg); 1344a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 1354a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1364a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// GetGlobalVal - Get a value with the specified name or ID, creating a 1374a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// forward reference record if needed. This can return null if the value 1384a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project /// exists but does not have the right type. 1394a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project GlobalValue *GetGlobalVal(const std::string &N, const Type *Ty, LocTy Loc); 1404a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project GlobalValue *GetGlobalVal(unsigned ID, const Type *Ty, LocTy Loc); 1414a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project 1424a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project // Helper Routines. 1434a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool ParseToken(lltok::Kind T, const char *ErrMsg); 1444a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool EatIfPresent(lltok::Kind T) { 1454a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project if (Lex.getKind() != T) return false; 1464a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Lex.Lex(); 1474a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return true; 1484a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 1494a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool ParseOptionalToken(lltok::Kind T, bool &Present) { 1504a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project if (Lex.getKind() != T) { 1514a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Present = false; 1524a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } else { 1534a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Lex.Lex(); 1544a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Present = true; 1554a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 1564a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return false; 1574a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 1584a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool ParseStringConstant(std::string &Result); 1594a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool ParseUInt32(unsigned &Val); 1604a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool ParseUInt32(unsigned &Val, LocTy &Loc) { 1614a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project Loc = Lex.getLoc(); 1624a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project return ParseUInt32(Val); 1634a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project } 1644a68b3365c8c50aa93505e99ead2565ab73dcdb0The Android Open Source Project bool ParseOptionalAddrSpace(unsigned &AddrSpace); 165 bool ParseOptionalAttrs(unsigned &Attrs, unsigned AttrKind); 166 bool ParseOptionalLinkage(unsigned &Linkage, bool &HasLinkage); 167 bool ParseOptionalLinkage(unsigned &Linkage) { 168 bool HasLinkage; return ParseOptionalLinkage(Linkage, HasLinkage); 169 } 170 bool ParseOptionalVisibility(unsigned &Visibility); 171 bool ParseOptionalCallingConv(CallingConv::ID &CC); 172 bool ParseOptionalAlignment(unsigned &Alignment); 173 bool ParseInstructionMetadata(SmallVectorImpl<std::pair<unsigned, 174 MDNode *> > &); 175 bool ParseOptionalCommaAlign(unsigned &Alignment, bool &AteExtraComma); 176 bool ParseIndexList(SmallVectorImpl<unsigned> &Indices,bool &AteExtraComma); 177 bool ParseIndexList(SmallVectorImpl<unsigned> &Indices) { 178 bool AteExtraComma; 179 if (ParseIndexList(Indices, AteExtraComma)) return true; 180 if (AteExtraComma) 181 return TokError("expected index"); 182 return false; 183 } 184 185 // Top-Level Entities 186 bool ParseTopLevelEntities(); 187 bool ValidateEndOfModule(); 188 bool ParseTargetDefinition(); 189 bool ParseDepLibs(); 190 bool ParseModuleAsm(); 191 bool ParseUnnamedType(); 192 bool ParseNamedType(); 193 bool ParseDeclare(); 194 bool ParseDefine(); 195 196 bool ParseGlobalType(bool &IsConstant); 197 bool ParseUnnamedGlobal(); 198 bool ParseNamedGlobal(); 199 bool ParseGlobal(const std::string &Name, LocTy Loc, unsigned Linkage, 200 bool HasLinkage, unsigned Visibility); 201 bool ParseAlias(const std::string &Name, LocTy Loc, unsigned Visibility); 202 bool ParseStandaloneMetadata(); 203 bool ParseNamedMetadata(); 204 bool ParseMDString(MDString *&Result); 205 bool ParseMDNodeID(MDNode *&Result); 206 207 // Type Parsing. 208 bool ParseType(PATypeHolder &Result, bool AllowVoid = false); 209 bool ParseType(PATypeHolder &Result, LocTy &Loc, bool AllowVoid = false) { 210 Loc = Lex.getLoc(); 211 return ParseType(Result, AllowVoid); 212 } 213 bool ParseTypeRec(PATypeHolder &H); 214 bool ParseStructType(PATypeHolder &H, bool Packed); 215 bool ParseArrayVectorType(PATypeHolder &H, bool isVector); 216 bool ParseFunctionType(PATypeHolder &Result); 217 PATypeHolder HandleUpRefs(const Type *Ty); 218 219 // Function Semantic Analysis. 220 class PerFunctionState { 221 LLParser &P; 222 Function &F; 223 std::map<std::string, std::pair<Value*, LocTy> > ForwardRefVals; 224 std::map<unsigned, std::pair<Value*, LocTy> > ForwardRefValIDs; 225 std::vector<Value*> NumberedVals; 226 227 /// FunctionNumber - If this is an unnamed function, this is the slot 228 /// number of it, otherwise it is -1. 229 int FunctionNumber; 230 public: 231 PerFunctionState(LLParser &p, Function &f, int FunctionNumber); 232 ~PerFunctionState(); 233 234 Function &getFunction() const { return F; } 235 236 bool FinishFunction(); 237 238 /// GetVal - Get a value with the specified name or ID, creating a 239 /// forward reference record if needed. This can return null if the value 240 /// exists but does not have the right type. 241 Value *GetVal(const std::string &Name, const Type *Ty, LocTy Loc); 242 Value *GetVal(unsigned ID, const Type *Ty, LocTy Loc); 243 244 /// SetInstName - After an instruction is parsed and inserted into its 245 /// basic block, this installs its name. 246 bool SetInstName(int NameID, const std::string &NameStr, LocTy NameLoc, 247 Instruction *Inst); 248 249 /// GetBB - Get a basic block with the specified name or ID, creating a 250 /// forward reference record if needed. This can return null if the value 251 /// is not a BasicBlock. 252 BasicBlock *GetBB(const std::string &Name, LocTy Loc); 253 BasicBlock *GetBB(unsigned ID, LocTy Loc); 254 255 /// DefineBB - Define the specified basic block, which is either named or 256 /// unnamed. If there is an error, this returns null otherwise it returns 257 /// the block being defined. 258 BasicBlock *DefineBB(const std::string &Name, LocTy Loc); 259 }; 260 261 bool ConvertValIDToValue(const Type *Ty, ValID &ID, Value *&V, 262 PerFunctionState &PFS); 263 264 bool ParseValue(const Type *Ty, Value *&V, PerFunctionState &PFS); 265 bool ParseValue(const Type *Ty, Value *&V, LocTy &Loc, 266 PerFunctionState &PFS) { 267 Loc = Lex.getLoc(); 268 return ParseValue(Ty, V, PFS); 269 } 270 271 bool ParseTypeAndValue(Value *&V, PerFunctionState &PFS); 272 bool ParseTypeAndValue(Value *&V, LocTy &Loc, PerFunctionState &PFS) { 273 Loc = Lex.getLoc(); 274 return ParseTypeAndValue(V, PFS); 275 } 276 bool ParseTypeAndBasicBlock(BasicBlock *&BB, LocTy &Loc, 277 PerFunctionState &PFS); 278 bool ParseTypeAndBasicBlock(BasicBlock *&BB, PerFunctionState &PFS) { 279 LocTy Loc; 280 return ParseTypeAndBasicBlock(BB, Loc, PFS); 281 } 282 283 struct ParamInfo { 284 LocTy Loc; 285 Value *V; 286 unsigned Attrs; 287 ParamInfo(LocTy loc, Value *v, unsigned attrs) 288 : Loc(loc), V(v), Attrs(attrs) {} 289 }; 290 bool ParseParameterList(SmallVectorImpl<ParamInfo> &ArgList, 291 PerFunctionState &PFS); 292 293 // Constant Parsing. 294 bool ParseValID(ValID &ID, PerFunctionState *PFS = NULL); 295 bool ConvertGlobalValIDToValue(const Type *Ty, ValID &ID, Constant *&V); 296 bool ConvertGlobalOrMetadataValIDToValue(const Type *Ty, ValID &ID, 297 Value *&V, PerFunctionState *PFS); 298 bool ParseGlobalValue(const Type *Ty, Constant *&V); 299 bool ParseGlobalTypeAndValue(Constant *&V); 300 bool ParseGlobalValueVector(SmallVectorImpl<Constant*> &Elts); 301 bool ParseMDNodeVector(SmallVectorImpl<Value*> &, PerFunctionState *PFS); 302 303 // Function Parsing. 304 struct ArgInfo { 305 LocTy Loc; 306 PATypeHolder Type; 307 unsigned Attrs; 308 std::string Name; 309 ArgInfo(LocTy L, PATypeHolder Ty, unsigned Attr, const std::string &N) 310 : Loc(L), Type(Ty), Attrs(Attr), Name(N) {} 311 }; 312 bool ParseArgumentList(std::vector<ArgInfo> &ArgList, 313 bool &isVarArg, bool inType); 314 bool ParseFunctionHeader(Function *&Fn, bool isDefine); 315 bool ParseFunctionBody(Function &Fn); 316 bool ParseBasicBlock(PerFunctionState &PFS); 317 318 // Instruction Parsing. Each instruction parsing routine can return with a 319 // normal result, an error result, or return having eaten an extra comma. 320 enum InstResult { InstNormal = 0, InstError = 1, InstExtraComma = 2 }; 321 int ParseInstruction(Instruction *&Inst, BasicBlock *BB, 322 PerFunctionState &PFS); 323 bool ParseCmpPredicate(unsigned &Pred, unsigned Opc); 324 325 int ParseRet(Instruction *&Inst, BasicBlock *BB, PerFunctionState &PFS); 326 bool ParseBr(Instruction *&Inst, PerFunctionState &PFS); 327 bool ParseSwitch(Instruction *&Inst, PerFunctionState &PFS); 328 bool ParseIndirectBr(Instruction *&Inst, PerFunctionState &PFS); 329 bool ParseInvoke(Instruction *&Inst, PerFunctionState &PFS); 330 331 bool ParseArithmetic(Instruction *&I, PerFunctionState &PFS, unsigned Opc, 332 unsigned OperandType); 333 bool ParseLogical(Instruction *&I, PerFunctionState &PFS, unsigned Opc); 334 bool ParseCompare(Instruction *&I, PerFunctionState &PFS, unsigned Opc); 335 bool ParseCast(Instruction *&I, PerFunctionState &PFS, unsigned Opc); 336 bool ParseSelect(Instruction *&I, PerFunctionState &PFS); 337 bool ParseVA_Arg(Instruction *&I, PerFunctionState &PFS); 338 bool ParseExtractElement(Instruction *&I, PerFunctionState &PFS); 339 bool ParseInsertElement(Instruction *&I, PerFunctionState &PFS); 340 bool ParseShuffleVector(Instruction *&I, PerFunctionState &PFS); 341 int ParsePHI(Instruction *&I, PerFunctionState &PFS); 342 bool ParseCall(Instruction *&I, PerFunctionState &PFS, bool isTail); 343 int ParseAlloc(Instruction *&I, PerFunctionState &PFS, 344 BasicBlock *BB = 0, bool isAlloca = true); 345 bool ParseFree(Instruction *&I, PerFunctionState &PFS, BasicBlock *BB); 346 int ParseLoad(Instruction *&I, PerFunctionState &PFS, bool isVolatile); 347 int ParseStore(Instruction *&I, PerFunctionState &PFS, bool isVolatile); 348 bool ParseGetResult(Instruction *&I, PerFunctionState &PFS); 349 int ParseGetElementPtr(Instruction *&I, PerFunctionState &PFS); 350 int ParseExtractValue(Instruction *&I, PerFunctionState &PFS); 351 int ParseInsertValue(Instruction *&I, PerFunctionState &PFS); 352 353 bool ResolveForwardRefBlockAddresses(Function *TheFn, 354 std::vector<std::pair<ValID, GlobalValue*> > &Refs, 355 PerFunctionState *PFS); 356 }; 357} // End llvm namespace 358 359#endif 360