| //===-- llvmAsmParser.y - Parser for llvm assembly files ---------*- C++ -*--=// |
| // |
| // This file implements the bison parser for LLVM assembly languages files. |
| // |
| //===------------------------------------------------------------------------=// |
| |
| // |
| // TODO: Parse comments and add them to an internal node... so that they may |
| // be saved in the bytecode format as well as everything else. Very important |
| // for a general IR format. |
| // |
| |
| %{ |
| #include "ParserInternals.h" |
| #include "llvm/BasicBlock.h" |
| #include "llvm/Method.h" |
| #include "llvm/SymbolTable.h" |
| #include "llvm/Module.h" |
| #include "llvm/Type.h" |
| #include "llvm/DerivedTypes.h" |
| #include "llvm/Assembly/Parser.h" |
| #include "llvm/ConstantPool.h" |
| #include "llvm/iTerminators.h" |
| #include "llvm/iMemory.h" |
| #include <list> |
| #include <utility> // Get definition of pair class |
| #include <stdio.h> // This embarasment is due to our flex lexer... |
| |
| int yyerror(char *ErrorMsg); // Forward declarations to prevent "implicit |
| int yylex(); // declaration" of xxx warnings. |
| int yyparse(); |
| |
| static Module *ParserResult; |
| const ToolCommandLine *CurOptions = 0; |
| |
| // This contains info used when building the body of a method. It is destroyed |
| // when the method is completed. |
| // |
| typedef vector<Value *> ValueList; // Numbered defs |
| static void ResolveDefinitions(vector<ValueList> &LateResolvers); |
| |
| static struct PerModuleInfo { |
| Module *CurrentModule; |
| vector<ValueList> Values; // Module level numbered definitions |
| vector<ValueList> LateResolveValues; |
| |
| void ModuleDone() { |
| // If we could not resolve some blocks at parsing time (forward branches) |
| // resolve the branches now... |
| ResolveDefinitions(LateResolveValues); |
| |
| Values.clear(); // Clear out method local definitions |
| CurrentModule = 0; |
| } |
| } CurModule; |
| |
| static struct PerMethodInfo { |
| Method *CurrentMethod; // Pointer to current method being created |
| |
| vector<ValueList> Values; // Keep track of numbered definitions |
| vector<ValueList> LateResolveValues; |
| |
| inline PerMethodInfo() { |
| CurrentMethod = 0; |
| } |
| |
| inline ~PerMethodInfo() {} |
| |
| inline void MethodStart(Method *M) { |
| CurrentMethod = M; |
| } |
| |
| void MethodDone() { |
| // If we could not resolve some blocks at parsing time (forward branches) |
| // resolve the branches now... |
| ResolveDefinitions(LateResolveValues); |
| |
| Values.clear(); // Clear out method local definitions |
| CurrentMethod = 0; |
| } |
| } CurMeth; // Info for the current method... |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Code to handle definitions of all the types |
| //===----------------------------------------------------------------------===// |
| |
| static void InsertValue(Value *D, vector<ValueList> &ValueTab = CurMeth.Values) { |
| if (!D->hasName()) { // Is this a numbered definition? |
| unsigned type = D->getType()->getUniqueID(); |
| if (ValueTab.size() <= type) |
| ValueTab.resize(type+1, ValueList()); |
| //printf("Values[%d][%d] = %d\n", type, ValueTab[type].size(), D); |
| ValueTab[type].push_back(D); |
| } |
| } |
| |
| static Value *getVal(const Type *Type, ValID &D, |
| bool DoNotImprovise = false) { |
| switch (D.Type) { |
| case 0: { // Is it a numbered definition? |
| unsigned type = Type->getUniqueID(); |
| unsigned Num = (unsigned)D.Num; |
| |
| // Module constants occupy the lowest numbered slots... |
| if (type < CurModule.Values.size()) { |
| if (Num < CurModule.Values[type].size()) |
| return CurModule.Values[type][Num]; |
| |
| Num -= CurModule.Values[type].size(); |
| } |
| |
| // Make sure that our type is within bounds |
| if (CurMeth.Values.size() <= type) |
| break; |
| |
| // Check that the number is within bounds... |
| if (CurMeth.Values[type].size() <= Num) |
| break; |
| |
| return CurMeth.Values[type][Num]; |
| } |
| case 1: { // Is it a named definition? |
| string Name(D.Name); |
| SymbolTable *SymTab = 0; |
| if (CurMeth.CurrentMethod) |
| SymTab = CurMeth.CurrentMethod->getSymbolTable(); |
| Value *N = SymTab ? SymTab->lookup(Type, Name) : 0; |
| |
| if (N == 0) { |
| SymTab = CurModule.CurrentModule->getSymbolTable(); |
| if (SymTab) |
| N = SymTab->lookup(Type, Name); |
| if (N == 0) break; |
| } |
| |
| D.destroy(); // Free old strdup'd memory... |
| return N; |
| } |
| |
| case 2: // Is it a constant pool reference?? |
| case 3: // Is it an unsigned const pool reference? |
| case 4:{ // Is it a string const pool reference? |
| ConstPoolVal *CPV = 0; |
| |
| // Check to make sure that "Type" is an integral type, and that our |
| // value will fit into the specified type... |
| switch (D.Type) { |
| case 2: |
| if (Type == Type::BoolTy) { // Special handling for boolean data |
| CPV = new ConstPoolBool(D.ConstPool64 != 0); |
| } else { |
| if (!ConstPoolSInt::isValueValidForType(Type, D.ConstPool64)) |
| ThrowException("Symbolic constant pool reference is invalid!"); |
| CPV = new ConstPoolSInt(Type, D.ConstPool64); |
| } |
| break; |
| case 3: |
| if (!ConstPoolUInt::isValueValidForType(Type, D.UConstPool64)) { |
| if (!ConstPoolSInt::isValueValidForType(Type, D.ConstPool64)) { |
| ThrowException("Symbolic constant pool reference is invalid!"); |
| } else { // This is really a signed reference. Transmogrify. |
| CPV = new ConstPoolSInt(Type, D.ConstPool64); |
| } |
| } else { |
| CPV = new ConstPoolUInt(Type, D.UConstPool64); |
| } |
| break; |
| case 4: |
| cerr << "FIXME: TODO: String constants [sbyte] not implemented yet!\n"; |
| abort(); |
| //CPV = new ConstPoolString(D.Name); |
| D.destroy(); // Free the string memory |
| break; |
| } |
| assert(CPV && "How did we escape creating a constant??"); |
| |
| // Scan through the constant table and see if we already have loaded this |
| // constant. |
| // |
| ConstantPool &CP = CurMeth.CurrentMethod ? |
| CurMeth.CurrentMethod->getConstantPool() : |
| CurModule.CurrentModule->getConstantPool(); |
| ConstPoolVal *C = CP.find(CPV); // Already have this constant? |
| if (C) { |
| delete CPV; // Didn't need this after all, oh well. |
| return C; // Yup, we already have one, recycle it! |
| } |
| CP.insert(CPV); |
| |
| // Success, everything is kosher. Lets go! |
| return CPV; |
| } // End of case 2,3,4 |
| } // End of switch |
| |
| |
| // If we reached here, we referenced either a symbol that we don't know about |
| // or an id number that hasn't been read yet. We may be referencing something |
| // forward, so just create an entry to be resolved later and get to it... |
| // |
| if (DoNotImprovise) return 0; // Do we just want a null to be returned? |
| |
| // TODO: Attempt to coallecse nodes that are the same with previous ones. |
| Value *d = 0; |
| switch (Type->getPrimitiveID()) { |
| case Type::LabelTyID: d = new BBPlaceHolder(Type, D); break; |
| case Type::MethodTyID: |
| d = new MethPlaceHolder(Type, D); |
| InsertValue(d, CurModule.LateResolveValues); |
| return d; |
| //case Type::ClassTyID: d = new ClassPlaceHolder(Type, D); break; |
| default: d = new DefPlaceHolder(Type, D); break; |
| } |
| |
| assert(d != 0 && "How did we not make something?"); |
| InsertValue(d, CurMeth.LateResolveValues); |
| return d; |
| } |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Code to handle forward references in instructions |
| //===----------------------------------------------------------------------===// |
| // |
| // This code handles the late binding needed with statements that reference |
| // values not defined yet... for example, a forward branch, or the PHI node for |
| // a loop body. |
| // |
| // This keeps a table (CurMeth.LateResolveValues) of all such forward references |
| // and back patchs after we are done. |
| // |
| |
| // ResolveDefinitions - If we could not resolve some defs at parsing |
| // time (forward branches, phi functions for loops, etc...) resolve the |
| // defs now... |
| // |
| static void ResolveDefinitions(vector<ValueList> &LateResolvers) { |
| // Loop over LateResolveDefs fixing up stuff that couldn't be resolved |
| for (unsigned ty = 0; ty < LateResolvers.size(); ty++) { |
| while (!LateResolvers[ty].empty()) { |
| Value *V = LateResolvers[ty].back(); |
| LateResolvers[ty].pop_back(); |
| ValID &DID = getValIDFromPlaceHolder(V); |
| |
| Value *TheRealValue = getVal(Type::getUniqueIDType(ty), DID, true); |
| |
| if (TheRealValue == 0 && DID.Type == 1) |
| ThrowException("Reference to an invalid definition: '" +DID.getName() + |
| "' of type '" + V->getType()->getName() + "'"); |
| else if (TheRealValue == 0) |
| ThrowException("Reference to an invalid definition: #" +itostr(DID.Num)+ |
| " of type '" + V->getType()->getName() + "'"); |
| |
| V->replaceAllUsesWith(TheRealValue); |
| assert(V->use_empty()); |
| delete V; |
| } |
| } |
| |
| LateResolvers.clear(); |
| } |
| |
| // addConstValToConstantPool - This code is used to insert a constant into the |
| // current constant pool. This is designed to make maximal (but not more than |
| // possible) reuse (merging) of constants in the constant pool. This means that |
| // multiple references to %4, for example will all get merged. |
| // |
| static ConstPoolVal *addConstValToConstantPool(ConstPoolVal *C) { |
| vector<ValueList> &ValTab = CurMeth.CurrentMethod ? |
| CurMeth.Values : CurModule.Values; |
| ConstantPool &CP = CurMeth.CurrentMethod ? |
| CurMeth.CurrentMethod->getConstantPool() : |
| CurModule.CurrentModule->getConstantPool(); |
| |
| if (ConstPoolVal *CPV = CP.find(C)) { |
| // Constant already in constant pool. Try to merge the two constants |
| if (CPV->hasName() && !C->hasName()) { |
| // Merge the two values, we inherit the existing CPV's name. |
| // InsertValue requires that the value have no name to insert correctly |
| // (because we want to fill the slot this constant would have filled) |
| // |
| string Name = CPV->getName(); |
| CPV->setName(""); |
| InsertValue(CPV, ValTab); |
| CPV->setName(Name); |
| delete C; |
| return CPV; |
| } else if (!CPV->hasName() && C->hasName()) { |
| // If we have a name on this value and there isn't one in the const |
| // pool val already, propogate it. |
| // |
| CPV->setName(C->getName()); |
| delete C; // Sorry, you're toast |
| return CPV; |
| } else if (CPV->hasName() && C->hasName()) { |
| // Both values have distinct names. We cannot merge them. |
| CP.insert(C); |
| InsertValue(C, ValTab); |
| return C; |
| } else if (!CPV->hasName() && !C->hasName()) { |
| // Neither value has a name, trivially merge them. |
| InsertValue(CPV, ValTab); |
| delete C; |
| return CPV; |
| } |
| |
| assert(0 && "Not reached!"); |
| return 0; |
| } else { // No duplication of value. |
| CP.insert(C); |
| InsertValue(C, ValTab); |
| return C; |
| } |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // RunVMAsmParser - Define an interface to this parser |
| //===----------------------------------------------------------------------===// |
| // |
| Module *RunVMAsmParser(const ToolCommandLine &Opts, FILE *F) { |
| llvmAsmin = F; |
| CurOptions = &Opts; |
| llvmAsmlineno = 1; // Reset the current line number... |
| |
| CurModule.CurrentModule = new Module(); // Allocate a new module to read |
| yyparse(); // Parse the file. |
| Module *Result = ParserResult; |
| CurOptions = 0; |
| llvmAsmin = stdin; // F is about to go away, don't use it anymore... |
| ParserResult = 0; |
| |
| return Result; |
| } |
| |
| %} |
| |
| %union { |
| Module *ModuleVal; |
| Method *MethodVal; |
| MethodArgument *MethArgVal; |
| BasicBlock *BasicBlockVal; |
| TerminatorInst *TermInstVal; |
| Instruction *InstVal; |
| ConstPoolVal *ConstVal; |
| const Type *TypeVal; |
| |
| list<MethodArgument*> *MethodArgList; |
| list<Value*> *ValueList; |
| list<const Type*> *TypeList; |
| list<pair<ConstPoolVal*, BasicBlock*> > *JumpTable; |
| vector<ConstPoolVal*> *ConstVector; |
| |
| int64_t SInt64Val; |
| uint64_t UInt64Val; |
| int SIntVal; |
| unsigned UIntVal; |
| |
| char *StrVal; // This memory is allocated by strdup! |
| ValID ValIDVal; // May contain memory allocated by strdup |
| |
| Instruction::UnaryOps UnaryOpVal; |
| Instruction::BinaryOps BinaryOpVal; |
| Instruction::TermOps TermOpVal; |
| Instruction::MemoryOps MemOpVal; |
| } |
| |
| %type <ModuleVal> Module MethodList |
| %type <MethodVal> Method MethodHeader BasicBlockList |
| %type <BasicBlockVal> BasicBlock InstructionList |
| %type <TermInstVal> BBTerminatorInst |
| %type <InstVal> Inst InstVal MemoryInst |
| %type <ConstVal> ConstVal |
| %type <ConstVector> ConstVector |
| %type <MethodArgList> ArgList ArgListH |
| %type <MethArgVal> ArgVal |
| %type <ValueList> ValueRefList ValueRefListE |
| %type <TypeList> TypeList |
| %type <JumpTable> JumpTable |
| |
| %type <ValIDVal> ValueRef ConstValueRef // Reference to a definition or BB |
| |
| // Tokens and types for handling constant integer values |
| // |
| // ESINT64VAL - A negative number within long long range |
| %token <SInt64Val> ESINT64VAL |
| |
| // EUINT64VAL - A positive number within uns. long long range |
| %token <UInt64Val> EUINT64VAL |
| %type <SInt64Val> EINT64VAL |
| |
| %token <SIntVal> SINTVAL // Signed 32 bit ints... |
| %token <UIntVal> UINTVAL // Unsigned 32 bit ints... |
| %type <SIntVal> INTVAL |
| |
| // Built in types... |
| %type <TypeVal> Types TypesV SIntType UIntType IntType |
| %token <TypeVal> VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG |
| %token <TypeVal> FLOAT DOUBLE STRING TYPE LABEL |
| |
| %token <StrVal> VAR_ID LABELSTR STRINGCONSTANT |
| %type <StrVal> OptVAR_ID OptAssign |
| |
| |
| %token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE |
| %token PHI CALL |
| |
| // Basic Block Terminating Operators |
| %token <TermOpVal> RET BR SWITCH |
| |
| // Unary Operators |
| %type <UnaryOpVal> UnaryOps // all the unary operators |
| %token <UnaryOpVal> NEG NOT |
| |
| // Unary Conversion Operators |
| %token <UnaryOpVal> TOINT TOUINT |
| |
| // Binary Operators |
| %type <BinaryOpVal> BinaryOps // all the binary operators |
| %token <BinaryOpVal> ADD SUB MUL DIV REM |
| |
| // Binary Comarators |
| %token <BinaryOpVal> SETLE SETGE SETLT SETGT SETEQ SETNE |
| |
| // Memory Instructions |
| %token <MemoryOpVal> MALLOC ALLOCA FREE LOAD STORE GETFIELD PUTFIELD |
| |
| %start Module |
| %% |
| |
| // Handle constant integer size restriction and conversion... |
| // |
| |
| INTVAL : SINTVAL |
| INTVAL : UINTVAL { |
| if ($1 > (uint32_t)INT32_MAX) // Outside of my range! |
| ThrowException("Value too large for type!"); |
| $$ = (int32_t)$1; |
| } |
| |
| |
| EINT64VAL : ESINT64VAL // These have same type and can't cause problems... |
| EINT64VAL : EUINT64VAL { |
| if ($1 > (uint64_t)INT64_MAX) // Outside of my range! |
| ThrowException("Value too large for type!"); |
| $$ = (int64_t)$1; |
| } |
| |
| // Types includes all predefined types... except void, because you can't do |
| // anything with it except for certain specific things... |
| // |
| // User defined types are added latter... |
| // |
| Types : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT |
| Types : LONG | ULONG | FLOAT | DOUBLE | STRING | TYPE | LABEL |
| |
| // TypesV includes all of 'Types', but it also includes the void type. |
| TypesV : Types | VOID |
| |
| // Operations that are notably excluded from this list include: |
| // RET, BR, & SWITCH because they end basic blocks and are treated specially. |
| // |
| UnaryOps : NEG | NOT | TOINT | TOUINT |
| BinaryOps : ADD | SUB | MUL | DIV | REM |
| BinaryOps : SETLE | SETGE | SETLT | SETGT | SETEQ | SETNE |
| |
| // Valueine some types that allow classification if we only want a particular |
| // thing... |
| SIntType : LONG | INT | SHORT | SBYTE |
| UIntType : ULONG | UINT | USHORT | UBYTE |
| IntType : SIntType | UIntType |
| |
| OptAssign : VAR_ID '=' { |
| $$ = $1; |
| } |
| | /*empty*/ { |
| $$ = 0; |
| } |
| |
| ConstVal : SIntType EINT64VAL { // integral constants |
| if (!ConstPoolSInt::isValueValidForType($1, $2)) |
| ThrowException("Constant value doesn't fit in type!"); |
| $$ = new ConstPoolSInt($1, $2); |
| } |
| | UIntType EUINT64VAL { // integral constants |
| if (!ConstPoolUInt::isValueValidForType($1, $2)) |
| ThrowException("Constant value doesn't fit in type!"); |
| $$ = new ConstPoolUInt($1, $2); |
| } |
| | BOOL TRUE { // Boolean constants |
| $$ = new ConstPoolBool(true); |
| } |
| | BOOL FALSE { // Boolean constants |
| $$ = new ConstPoolBool(false); |
| } |
| | STRING STRINGCONSTANT { // String constants |
| cerr << "FIXME: TODO: String constants [sbyte] not implemented yet!\n"; |
| abort(); |
| //$$ = new ConstPoolString($2); |
| free($2); |
| } |
| | TYPE Types { // Type constants |
| $$ = new ConstPoolType($2); |
| } |
| | '[' Types ']' '[' ConstVector ']' { // Nonempty array constant |
| // Verify all elements are correct type! |
| const ArrayType *AT = ArrayType::getArrayType($2); |
| for (unsigned i = 0; i < $5->size(); i++) { |
| if ($2 != (*$5)[i]->getType()) |
| ThrowException("Element #" + utostr(i) + " is not of type '" + |
| $2->getName() + "' as required!\nIt is of type '" + |
| (*$5)[i]->getType()->getName() + "'."); |
| } |
| |
| $$ = new ConstPoolArray(AT, *$5); |
| delete $5; |
| } |
| | '[' Types ']' '[' ']' { // Empty array constant |
| vector<ConstPoolVal*> Empty; |
| $$ = new ConstPoolArray(ArrayType::getArrayType($2), Empty); |
| } |
| | '[' EUINT64VAL 'x' Types ']' '[' ConstVector ']' { |
| // Verify all elements are correct type! |
| const ArrayType *AT = ArrayType::getArrayType($4, (int)$2); |
| if ($2 != $7->size()) |
| ThrowException("Type mismatch: constant sized array initialized with " + |
| utostr($7->size()) + " arguments, but has size of " + |
| itostr((int)$2) + "!"); |
| |
| for (unsigned i = 0; i < $7->size(); i++) { |
| if ($4 != (*$7)[i]->getType()) |
| ThrowException("Element #" + utostr(i) + " is not of type '" + |
| $4->getName() + "' as required!\nIt is of type '" + |
| (*$7)[i]->getType()->getName() + "'."); |
| } |
| |
| $$ = new ConstPoolArray(AT, *$7); |
| delete $7; |
| } |
| | '[' EUINT64VAL 'x' Types ']' '[' ']' { |
| if ($2 != 0) |
| ThrowException("Type mismatch: constant sized array initialized with 0" |
| " arguments, but has size of " + itostr((int)$2) + "!"); |
| vector<ConstPoolVal*> Empty; |
| $$ = new ConstPoolArray(ArrayType::getArrayType($4, 0), Empty); |
| } |
| | '{' TypeList '}' '{' ConstVector '}' { |
| StructType::ElementTypes Types($2->begin(), $2->end()); |
| delete $2; |
| |
| const StructType *St = StructType::getStructType(Types); |
| $$ = new ConstPoolStruct(St, *$5); |
| delete $5; |
| } |
| | '{' '}' '{' '}' { |
| const StructType *St = |
| StructType::getStructType(StructType::ElementTypes()); |
| vector<ConstPoolVal*> Empty; |
| $$ = new ConstPoolStruct(St, Empty); |
| } |
| /* |
| | Types '*' ConstVal { |
| assert(0); |
| $$ = 0; |
| } |
| */ |
| |
| |
| ConstVector : ConstVector ',' ConstVal { |
| ($$ = $1)->push_back(addConstValToConstantPool($3)); |
| } |
| | ConstVal { |
| $$ = new vector<ConstPoolVal*>(); |
| $$->push_back(addConstValToConstantPool($1)); |
| } |
| |
| |
| ConstPool : ConstPool OptAssign ConstVal { |
| if ($2) { |
| $3->setName($2); |
| free($2); |
| } |
| |
| addConstValToConstantPool($3); |
| } |
| | /* empty: end of list */ { |
| } |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Rules to match Modules |
| //===----------------------------------------------------------------------===// |
| |
| // Module rule: Capture the result of parsing the whole file into a result |
| // variable... |
| // |
| Module : MethodList { |
| $$ = ParserResult = $1; |
| CurModule.ModuleDone(); |
| } |
| |
| MethodList : MethodList Method { |
| $1->getMethodList().push_back($2); |
| CurMeth.MethodDone(); |
| $$ = $1; |
| } |
| | ConstPool IMPLEMENTATION { |
| $$ = CurModule.CurrentModule; |
| } |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Rules to match Method Headers |
| //===----------------------------------------------------------------------===// |
| |
| OptVAR_ID : VAR_ID | /*empty*/ { $$ = 0; } |
| |
| ArgVal : Types OptVAR_ID { |
| $$ = new MethodArgument($1); |
| if ($2) { // Was the argument named? |
| $$->setName($2); |
| free($2); // The string was strdup'd, so free it now. |
| } |
| } |
| |
| ArgListH : ArgVal ',' ArgListH { |
| $$ = $3; |
| $3->push_front($1); |
| } |
| | ArgVal { |
| $$ = new list<MethodArgument*>(); |
| $$->push_front($1); |
| } |
| |
| ArgList : ArgListH { |
| $$ = $1; |
| } |
| | /* empty */ { |
| $$ = 0; |
| } |
| |
| MethodHeaderH : TypesV STRINGCONSTANT '(' ArgList ')' { |
| MethodType::ParamTypes ParamTypeList; |
| if ($4) |
| for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); I++) |
| ParamTypeList.push_back((*I)->getType()); |
| |
| const MethodType *MT = MethodType::getMethodType($1, ParamTypeList); |
| |
| Method *M = new Method(MT, $2); |
| free($2); // Free strdup'd memory! |
| |
| InsertValue(M, CurModule.Values); |
| |
| CurMeth.MethodStart(M); |
| |
| // Add all of the arguments we parsed to the method... |
| if ($4) { // Is null if empty... |
| Method::ArgumentListType &ArgList = M->getArgumentList(); |
| |
| for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); I++) { |
| InsertValue(*I); |
| ArgList.push_back(*I); |
| } |
| delete $4; // We're now done with the argument list |
| } |
| } |
| |
| MethodHeader : MethodHeaderH ConstPool BEGINTOK { |
| $$ = CurMeth.CurrentMethod; |
| } |
| |
| Method : BasicBlockList END { |
| $$ = $1; |
| } |
| |
| |
| //===----------------------------------------------------------------------===// |
| // Rules to match Basic Blocks |
| //===----------------------------------------------------------------------===// |
| |
| ConstValueRef : ESINT64VAL { // A reference to a direct constant |
| $$ = ValID::create($1); |
| } |
| | EUINT64VAL { |
| $$ = ValID::create($1); |
| } |
| | TRUE { |
| $$ = ValID::create((int64_t)1); |
| } |
| | FALSE { |
| $$ = ValID::create((int64_t)0); |
| } |
| | STRINGCONSTANT { // Quoted strings work too... especially for methods |
| $$ = ValID::create_conststr($1); |
| } |
| |
| // ValueRef - A reference to a definition... |
| ValueRef : INTVAL { // Is it an integer reference...? |
| $$ = ValID::create($1); |
| } |
| | VAR_ID { // It must be a named reference then... |
| $$ = ValID::create($1); |
| } |
| | ConstValueRef { |
| $$ = $1; |
| } |
| |
| // The user may refer to a user defined type by its typeplane... check for this |
| // now... |
| // |
| Types : ValueRef { |
| Value *D = getVal(Type::TypeTy, $1, true); |
| if (D == 0) ThrowException("Invalid user defined type: " + $1.getName()); |
| assert (D->getValueType() == Value::ConstantVal && |
| "Internal error! User defined type not in const pool!"); |
| ConstPoolType *CPT = (ConstPoolType*)D; |
| $$ = CPT->getValue(); |
| } |
| | TypesV '(' TypeList ')' { // Method derived type? |
| MethodType::ParamTypes Params($3->begin(), $3->end()); |
| delete $3; |
| $$ = MethodType::getMethodType($1, Params); |
| } |
| | TypesV '(' ')' { // Method derived type? |
| MethodType::ParamTypes Params; // Empty list |
| $$ = MethodType::getMethodType($1, Params); |
| } |
| | '[' Types ']' { |
| $$ = ArrayType::getArrayType($2); |
| } |
| | '[' EUINT64VAL 'x' Types ']' { |
| $$ = ArrayType::getArrayType($4, (int)$2); |
| } |
| | '{' TypeList '}' { |
| StructType::ElementTypes Elements($2->begin(), $2->end()); |
| delete $2; |
| $$ = StructType::getStructType(Elements); |
| } |
| | '{' '}' { |
| $$ = StructType::getStructType(StructType::ElementTypes()); |
| } |
| | Types '*' { |
| $$ = PointerType::getPointerType($1); |
| } |
| |
| |
| TypeList : Types { |
| $$ = new list<const Type*>(); |
| $$->push_back($1); |
| } |
| | TypeList ',' Types { |
| ($$=$1)->push_back($3); |
| } |
| |
| |
| BasicBlockList : BasicBlockList BasicBlock { |
| $1->getBasicBlocks().push_back($2); |
| $$ = $1; |
| } |
| | MethodHeader BasicBlock { // Do not allow methods with 0 basic blocks |
| $$ = $1; // in them... |
| $1->getBasicBlocks().push_back($2); |
| } |
| |
| |
| // Basic blocks are terminated by branching instructions: |
| // br, br/cc, switch, ret |
| // |
| BasicBlock : InstructionList BBTerminatorInst { |
| $1->getInstList().push_back($2); |
| InsertValue($1); |
| $$ = $1; |
| } |
| | LABELSTR InstructionList BBTerminatorInst { |
| $2->getInstList().push_back($3); |
| $2->setName($1); |
| free($1); // Free the strdup'd memory... |
| |
| InsertValue($2); |
| $$ = $2; |
| } |
| |
| InstructionList : InstructionList Inst { |
| $1->getInstList().push_back($2); |
| $$ = $1; |
| } |
| | /* empty */ { |
| $$ = new BasicBlock(); |
| } |
| |
| BBTerminatorInst : RET Types ValueRef { // Return with a result... |
| $$ = new ReturnInst(getVal($2, $3)); |
| } |
| | RET VOID { // Return with no result... |
| $$ = new ReturnInst(); |
| } |
| | BR LABEL ValueRef { // Unconditional Branch... |
| $$ = new BranchInst((BasicBlock*)getVal(Type::LabelTy, $3)); |
| } // Conditional Branch... |
| | BR BOOL ValueRef ',' LABEL ValueRef ',' LABEL ValueRef { |
| $$ = new BranchInst((BasicBlock*)getVal(Type::LabelTy, $6), |
| (BasicBlock*)getVal(Type::LabelTy, $9), |
| getVal(Type::BoolTy, $3)); |
| } |
| | SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' { |
| SwitchInst *S = new SwitchInst(getVal($2, $3), |
| (BasicBlock*)getVal(Type::LabelTy, $6)); |
| $$ = S; |
| |
| list<pair<ConstPoolVal*, BasicBlock*> >::iterator I = $8->begin(), |
| end = $8->end(); |
| for (; I != end; I++) |
| S->dest_push_back(I->first, I->second); |
| } |
| |
| JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef { |
| $$ = $1; |
| ConstPoolVal *V = (ConstPoolVal*)getVal($2, $3, true); |
| if (V == 0) |
| ThrowException("May only switch on a constant pool value!"); |
| |
| $$->push_back(make_pair(V, (BasicBlock*)getVal($5, $6))); |
| } |
| | IntType ConstValueRef ',' LABEL ValueRef { |
| $$ = new list<pair<ConstPoolVal*, BasicBlock*> >(); |
| ConstPoolVal *V = (ConstPoolVal*)getVal($1, $2, true); |
| |
| if (V == 0) |
| ThrowException("May only switch on a constant pool value!"); |
| |
| $$->push_back(make_pair(V, (BasicBlock*)getVal($4, $5))); |
| } |
| |
| Inst : OptAssign InstVal { |
| if ($1) // Is this definition named?? |
| $2->setName($1); // if so, assign the name... |
| |
| InsertValue($2); |
| $$ = $2; |
| } |
| |
| ValueRefList : Types ValueRef { // Used for PHI nodes and call statements... |
| $$ = new list<Value*>(); |
| $$->push_back(getVal($1, $2)); |
| } |
| | ValueRefList ',' ValueRef { |
| $$ = $1; |
| $1->push_back(getVal($1->front()->getType(), $3)); |
| } |
| |
| // ValueRefListE - Just like ValueRefList, except that it may also be empty! |
| ValueRefListE : ValueRefList | /*empty*/ { $$ = 0; } |
| |
| InstVal : BinaryOps Types ValueRef ',' ValueRef { |
| $$ = Instruction::getBinaryOperator($1, getVal($2, $3), getVal($2, $5)); |
| if ($$ == 0) |
| ThrowException("binary operator returned null!"); |
| } |
| | UnaryOps Types ValueRef { |
| $$ = Instruction::getUnaryOperator($1, getVal($2, $3)); |
| if ($$ == 0) |
| ThrowException("unary operator returned null!"); |
| } |
| | PHI ValueRefList { |
| $$ = new PHINode($2->front()->getType()); |
| while ($2->begin() != $2->end()) { |
| // TODO: Ensure all types are the same... |
| ((PHINode*)$$)->addIncoming($2->front()); |
| $2->pop_front(); |
| } |
| delete $2; // Free the list... |
| } |
| | CALL Types ValueRef '(' ValueRefListE ')' { |
| if (!$2->isMethodType()) |
| ThrowException("Can only call methods: invalid type '" + |
| $2->getName() + "'!"); |
| |
| const MethodType *Ty = (const MethodType*)$2; |
| |
| Value *V = getVal(Ty, $3); |
| if (V->getValueType() != Value::MethodVal || V->getType() != Ty) |
| ThrowException("Cannot call: " + $3.getName() + "!"); |
| |
| // Create or access a new type that corresponds to the function call... |
| vector<Value *> Params; |
| |
| if ($5) { |
| // Pull out just the arguments... |
| Params.insert(Params.begin(), $5->begin(), $5->end()); |
| delete $5; |
| |
| // Loop through MethodType's arguments and ensure they are specified |
| // correctly! |
| // |
| MethodType::ParamTypes::const_iterator I = Ty->getParamTypes().begin(); |
| unsigned i; |
| for (i = 0; i < Params.size() && I != Ty->getParamTypes().end(); ++i,++I){ |
| if (Params[i]->getType() != *I) |
| ThrowException("Parameter " + utostr(i) + " is not of type '" + |
| (*I)->getName() + "'!"); |
| } |
| |
| if (i != Params.size() || I != Ty->getParamTypes().end()) |
| ThrowException("Invalid number of parameters detected!"); |
| } |
| |
| // Create the call node... |
| $$ = new CallInst((Method*)V, Params); |
| } |
| | MemoryInst { |
| $$ = $1; |
| } |
| |
| MemoryInst : MALLOC Types { |
| ConstPoolVal *TyVal = new ConstPoolType(PointerType::getPointerType($2)); |
| TyVal = addConstValToConstantPool(TyVal); |
| $$ = new MallocInst((ConstPoolType*)TyVal); |
| } |
| | MALLOC Types ',' UINT ValueRef { |
| if (!$2->isArrayType() || ((const ArrayType*)$2)->isSized()) |
| ThrowException("Trying to allocate " + $2->getName() + |
| " as unsized array!"); |
| |
| Value *ArrSize = getVal($4, $5); |
| ConstPoolVal *TyVal = new ConstPoolType(PointerType::getPointerType($2)); |
| TyVal = addConstValToConstantPool(TyVal); |
| $$ = new MallocInst((ConstPoolType*)TyVal, ArrSize); |
| } |
| | ALLOCA Types { |
| ConstPoolVal *TyVal = new ConstPoolType(PointerType::getPointerType($2)); |
| TyVal = addConstValToConstantPool(TyVal); |
| $$ = new AllocaInst((ConstPoolType*)TyVal); |
| } |
| | ALLOCA Types ',' UINT ValueRef { |
| if (!$2->isArrayType() || ((const ArrayType*)$2)->isSized()) |
| ThrowException("Trying to allocate " + $2->getName() + |
| " as unsized array!"); |
| |
| Value *ArrSize = getVal($4, $5); |
| ConstPoolVal *TyVal = new ConstPoolType(PointerType::getPointerType($2)); |
| TyVal = addConstValToConstantPool(TyVal); |
| $$ = new AllocaInst((ConstPoolType*)TyVal, ArrSize); |
| } |
| | FREE Types ValueRef { |
| if (!$2->isPointerType()) |
| ThrowException("Trying to free nonpointer type " + $2->getName() + "!"); |
| $$ = new FreeInst(getVal($2, $3)); |
| } |
| |
| %% |
| int yyerror(char *ErrorMsg) { |
| ThrowException(string("Parse error: ") + ErrorMsg); |
| return 0; |
| } |