6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 21:29:20 +00:00
Code Issues Projects Releases Wiki Activity

* Enable the use of escaped literal strings

Browse Source 
* Unresolved variable names now have the correct line number for their
  error messages
* Rename Def* to Value*
* Check for symbol table collisions before inserting values
* Remove the STRING keyword
* Enable the use of string literals to initialize constant arrays
* Enable the use of extended constants in more locations: eg ret [int] [4, 5]
* Allow method prototypes to appear in the constant pool of the program
* Support varargs methods better.  Enable varargs methods with 0 fixed
  arguments
* Allow the entire method prototype to optionally be specified in a call inst


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@321 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2001-07-28 17:48:55 +00:00
parent 0add2d33e4
commit 93750fa4f8
3 changed files with 173 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
lib/AsmParser/Lexer.l
View File

@ -24,6 +24,8 @@
#include "llvm/Module.h"
#include <list>
#include "llvmAsmParser.h"
#include <ctype.h>
#include <stdlib.h>
#define RET_TOK(type, Enum, sym) \
llvmAsmlval.type = Instruction::Enum; return sym
@ -51,6 +53,34 @@ uint64_t atoull(const char *Buffer) {
}
// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
// appropriate character. If AllowNull is set to false, a \00 value will cause
// an exception to be thrown.
//
// If AllowNull is set to true, the return value of the function points to the
// last character of the string in memory.
//
char *UnEscapeLexed(char *Buffer, bool AllowNull = false) {
char *BOut = Buffer;
for (char *BIn = Buffer; *BIn; ) {
if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
char Tmp = BIn[3]; BIn[3] = 0; // Terminate string
*BOut = strtol(BIn+1, 0, 16); // Convert to number
if (!AllowNull && !*BOut)
ThrowException("String literal cannot accept \\00 escape!");
BIn[3] = Tmp; // Restore character
BIn += 3; // Skip over handled chars
++BOut;
} else {
*BOut++ = *BIn++;
}
}
return BOut;
}
#define YY_NEVER_INTERACTIVE 1
%}
@ -95,6 +125,7 @@ false { return FALSE; }
declare { return DECLARE; }
implementation { return IMPLEMENTATION; }
\.\.\. { return DOTDOTDOT; }
string { return STRING; }
void { llvmAsmlval.TypeVal = Type::VoidTy ; return VOID; }
bool { llvmAsmlval.TypeVal = Type::BoolTy ; return BOOL; }
@ -148,18 +179,27 @@ store { RET_TOK(MemOpVal, Store, STORE); }
getelementptr { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
{VarID} { llvmAsmlval.StrVal = strdup(yytext+1); return VAR_ID; }
{Label} {
{VarID} {
UnEscapeLexed(yytext+1);
llvmAsmlval.StrVal = strdup(yytext+1); // Skip %
return VAR_ID;
}
{Label} {
yytext[strlen(yytext)-1] = 0; // nuke colon
llvmAsmlval.StrVal = strdup(yytext);
UnEscapeLexed(yytext);
llvmAsmlval.StrVal = strdup(yytext);
return LABELSTR;
}
{StringConstant} {
{StringConstant} { // Note that we cannot unescape a string constant here! The
// string constant might contain a \00 which would not be
// understood by the string stuff. It is valid to make a
// [sbyte] c"Hello World\00" constant, for example.
//
yytext[strlen(yytext)-1] = 0; // nuke end quote
llvmAsmlval.StrVal = strdup(yytext+1); // Nuke start quote
llvmAsmlval.StrVal = strdup(yytext+1); // Nuke start quote
return STRINGCONSTANT;
}
}
{PInteger} { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }

52
lib/AsmParser/ParserInternals.h
View File

@ -31,15 +31,27 @@ extern string CurFilename;
Module *RunVMAsmParser(const string &Filename, FILE *F);
// UnEscapeLexed - Run through the specified buffer and change \xx codes to the
// appropriate character. If AllowNull is set to false, a \00 value will cause
// an exception to be thrown.
//
// If AllowNull is set to true, the return value of the function points to the
// last character of the string in memory.
//
char *UnEscapeLexed(char *Buffer, bool AllowNull = false);
// ThrowException - Wrapper around the ParseException class that automatically
// fills in file line number and column number and options info.
//
// This also helps me because I keep typing 'throw new ParseException' instead
// of just 'throw ParseException'... sigh...
//
static inline void ThrowException(const string &message) {
static inline void ThrowException(const string &message,
int LineNo = -1) {
if (LineNo == -1) LineNo = llvmAsmlineno;
// TODO: column number in exception
throw ParseException(CurFilename, message, llvmAsmlineno);
throw ParseException(CurFilename, message, LineNo);
}
// ValID - Represents a reference of a definition of some sort. This may either
@ -111,13 +123,15 @@ struct ValID {
template<class SuperType>
class PlaceholderDef : public SuperType {
class PlaceholderValue : public SuperType {
ValID D;
// TODO: Placeholder def should hold Line #/Column # of definition in case
// there is an error resolving the defintition!
int LineNum;
public:
PlaceholderDef(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) {}
PlaceholderValue(const Type *Ty, const ValID &d) : SuperType(Ty), D(d) {
LineNum = llvmAsmlineno;
}
ValID &getDef() { return D; }
int getLineNum() const { return LineNum; }
};
struct InstPlaceHolderHelper : public Instruction {
@ -140,17 +154,23 @@ struct MethPlaceHolderHelper : public Method {
}
};
typedef PlaceholderDef<InstPlaceHolderHelper> DefPlaceHolder;
typedef PlaceholderDef<BBPlaceHolderHelper> BBPlaceHolder;
typedef PlaceholderDef<MethPlaceHolderHelper> MethPlaceHolder;
//typedef PlaceholderDef<ModulePlaceHolderHelper> ModulePlaceHolder;
typedef PlaceholderValue<InstPlaceHolderHelper> ValuePlaceHolder;
typedef PlaceholderValue<BBPlaceHolderHelper> BBPlaceHolder;
typedef PlaceholderValue<MethPlaceHolderHelper> MethPlaceHolder;
static inline ValID &getValIDFromPlaceHolder(Value *Def) {
switch (Def->getType()->getPrimitiveID()) {
case Type::LabelTyID: return ((BBPlaceHolder*)Def)->getDef();
case Type::MethodTyID: return ((MethPlaceHolder*)Def)->getDef();
//case Type::ModuleTyID: return ((ModulePlaceHolder*)Def)->getDef();
default: return ((DefPlaceHolder*)Def)->getDef();
static inline ValID &getValIDFromPlaceHolder(Value *Val) {
switch (Val->getType()->getPrimitiveID()) {
case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getDef();
case Type::MethodTyID: return ((MethPlaceHolder*)Val)->getDef();
default: return ((ValuePlaceHolder*)Val)->getDef();
}
}
static inline int getLineNumFromPlaceHolder(Value *Val) {
switch (Val->getType()->getPrimitiveID()) {
case Type::LabelTyID: return ((BBPlaceHolder*)Val)->getLineNum();
case Type::MethodTyID: return ((MethPlaceHolder*)Val)->getLineNum();
default: return ((ValuePlaceHolder*)Val)->getLineNum();
}
}

131
lib/AsmParser/llvmAsmParser.y
View File

@ -89,7 +89,7 @@ static struct PerMethodInfo {
// Code to handle definitions of all the types
//===----------------------------------------------------------------------===//
static void InsertValue(Value *D, vector<ValueList> &ValueTab = CurMeth.Values) {
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)
@ -176,8 +176,6 @@ static Value *getVal(const Type *Type, const ValID &D,
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;
case 5:
if (!ConstPoolFP::isValueValidForType(Type, D.ConstPoolFP))
@ -215,18 +213,17 @@ static Value *getVal(const Type *Type, const ValID &D,
// TODO: Attempt to coallecse nodes that are the same with previous ones.
Value *d = 0;
vector<ValueList> *LateResolver = &CurMeth.LateResolveValues;
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;
case Type::LabelTyID: d = new BBPlaceHolder(Type, D); break;
case Type::MethodTyID: d = new MethPlaceHolder(Type, D);
LateResolver = &CurModule.LateResolveValues; break;
default: d = new ValuePlaceHolder(Type, D); break;
}
assert(d != 0 && "How did we not make something?");
InsertValue(d, CurMeth.LateResolveValues);
InsertValue(d, *LateResolver);
return d;
}
@ -259,10 +256,12 @@ static void ResolveDefinitions(vector<ValueList> &LateResolvers) {
if (TheRealValue == 0 && DID.Type == 1)
ThrowException("Reference to an invalid definition: '" +DID.getName() +
"' of type '" + V->getType()->getName() + "'");
"' of type '" + V->getType()->getName() + "'",
getLineNumFromPlaceHolder(V));
else if (TheRealValue == 0)
ThrowException("Reference to an invalid definition: #" +itostr(DID.Num)+
" of type '" + V->getType()->getName() + "'");
" of type '" + V->getType()->getName() + "'",
getLineNumFromPlaceHolder(V));
V->replaceAllUsesWith(TheRealValue);
assert(V->use_empty());
@ -305,25 +304,33 @@ static ConstPoolVal *addConstValToConstantPool(ConstPoolVal *C) {
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;
} else if (CPV->hasName() && C->hasName()) {
// Both values have distinct names. We cannot merge them.
// fall through
}
}
assert(0 && "Not reached!");
return 0;
} else { // No duplication of value.
CP.insert(C);
InsertValue(C, ValTab);
return C;
}
// No duplication of value, check to see if our current symbol table already
// has a variable of this type and name...
//
if (C->hasName()) {
SymbolTable *SymTab = CurMeth.CurrentMethod ?
CurMeth.CurrentMethod->getSymbolTable() :
CurModule.CurrentModule->getSymbolTable();
if (SymTab && SymTab->lookup(C->getType(), C->getName()))
ThrowException("<" + C->getType()->getName() + ">:" + C->getName() +
" already defined in translation unit!");
}
// Everything is happy: Insert into constant pool now!
CP.insert(C);
InsertValue(C, ValTab);
return C;
}
@ -450,13 +457,13 @@ Module *RunVMAsmParser(const string &Filename, FILE *F) {
// Built in types...
%type <TypeVal> Types TypesV SIntType UIntType IntType FPType
%token <TypeVal> VOID BOOL SBYTE UBYTE SHORT USHORT INT UINT LONG ULONG
%token <TypeVal> FLOAT DOUBLE STRING TYPE LABEL
%token <TypeVal> FLOAT DOUBLE TYPE LABEL
%token <StrVal> VAR_ID LABELSTR STRINGCONSTANT
%type <StrVal> OptVAR_ID OptAssign
%token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE TO DOTDOTDOT
%token IMPLEMENTATION TRUE FALSE BEGINTOK END DECLARE TO DOTDOTDOT STRING
// Basic Block Terminating Operators
%token <TermOpVal> RET BR SWITCH
@ -504,7 +511,7 @@ EINT64VAL : EUINT64VAL {
// User defined types are added later...
//
Types : BOOL | SBYTE | UBYTE | SHORT | USHORT | INT | UINT
Types : LONG | ULONG | FLOAT | DOUBLE | STRING | TYPE | LABEL
Types : LONG | ULONG | FLOAT | DOUBLE | TYPE | LABEL
// TypesV includes all of 'Types', but it also includes the void type.
TypesV : Types | VOID
@ -554,6 +561,22 @@ ExtendedConstVal: '[' Types ']' '[' ConstVector ']' { // Nonempty unsized array
vector<ConstPoolVal*> Empty;
$$ = new ConstPoolArray(ArrayType::getArrayType($2), Empty);
}
| '[' Types ']' 'c' STRINGCONSTANT {
char *EndStr = UnEscapeLexed($5, true);
vector<ConstPoolVal*> Vals;
if ($2 == Type::SByteTy) {
for (char *C = $5; C != EndStr; ++C)
Vals.push_back(addConstValToConstantPool(new ConstPoolSInt($2, *C)));
} else if ($2 == Type::UByteTy) {
for (char *C = $5; C != EndStr; ++C)
Vals.push_back(addConstValToConstantPool(new ConstPoolUInt($2, *C)));
} else {
ThrowException("Cannot build string arrays of non byte sized elements!");
}
free($5);
$$ = new ConstPoolArray(ArrayType::getArrayType($2), Vals);
}
| '[' EUINT64VAL 'x' Types ']' '[' ConstVector ']' {
// Verify all elements are correct type!
const ArrayType *AT = ArrayType::getArrayType($4, (int)$2);
@ -579,6 +602,26 @@ ExtendedConstVal: '[' Types ']' '[' ConstVector ']' { // Nonempty unsized array
vector<ConstPoolVal*> Empty;
$$ = new ConstPoolArray(ArrayType::getArrayType($4, 0), Empty);
}
| '[' EUINT64VAL 'x' Types ']' 'c' STRINGCONSTANT {
char *EndStr = UnEscapeLexed($7, true);
if ($2 != (unsigned)(EndStr-$7))
ThrowException("Can't build string constant of size " +
itostr((int)(EndStr-$7)) +
" when array has size " + itostr((int)$2) + "!");
vector<ConstPoolVal*> Vals;
if ($4 == Type::SByteTy) {
for (char *C = $7; C != EndStr; ++C)
Vals.push_back(addConstValToConstantPool(new ConstPoolSInt($4, *C)));
} else if ($4 == Type::UByteTy) {
for (char *C = $7; C != EndStr; ++C)
Vals.push_back(addConstValToConstantPool(new ConstPoolUInt($4, *C)));
} else {
ThrowException("Cannot build string arrays of non byte sized elements!");
}
free($7);
$$ = new ConstPoolArray(ArrayType::getArrayType($4, (int)$2), Vals);
}
| '{' TypeList '}' '{' ConstVector '}' {
StructType::ElementTypes Types($2->begin(), $2->end());
delete $2;
@ -600,8 +643,10 @@ ExtendedConstVal: '[' Types ']' '[' ConstVector ']' { // Nonempty unsized array
}
*/
ConstVal : ExtendedConstVal
| TYPE Types { // Type constants
ConstVal : ExtendedConstVal {
$$ = $1;
}
| TYPE TypesV { // Type constants
$$ = new ConstPoolType($2);
}
| SIntType EINT64VAL { // integral constants
@ -623,12 +668,6 @@ ConstVal : ExtendedConstVal
| FPType FPVAL { // Float & Double constants
$$ = new ConstPoolFP($1, $2);
}
| STRING STRINGCONSTANT { // String constants
cerr << "FIXME: TODO: String constants [sbyte] not implemented yet!\n";
abort();
//$$ = new ConstPoolString($2);
free($2);
}
// ConstVector - A list of comma seperated constants.
ConstVector : ConstVector ',' ConstVal {
@ -653,6 +692,8 @@ ConstPool : ConstPool OptAssign ConstVal {
addConstValToConstantPool($3);
}
| ConstPool MethodProto { // Method prototypes can be in const pool
}
/*
| ConstPool OptAssign GlobalDecl { // Global declarations appear in CP
if ($2) {
@ -688,9 +729,6 @@ MethodList : MethodList Method {
}
| MethodList MethodProto {
$$ = $1;
if (!$2->getParent())
$1->getMethodList().push_back($2);
CurMeth.MethodDone();
}
| ConstPool IMPLEMENTATION {
$$ = CurModule.CurrentModule;
@ -732,6 +770,7 @@ ArgList : ArgListH {
}
MethodHeaderH : TypesV STRINGCONSTANT '(' ArgList ')' {
UnEscapeLexed($2);
MethodType::ParamTypes ParamTypeList;
if ($4)
for (list<MethodArgument*>::iterator I = $4->begin(); I != $4->end(); ++I)
@ -782,6 +821,9 @@ Method : BasicBlockList END {
MethodProto : DECLARE { CurMeth.isDeclare = true; } MethodHeaderH {
$$ = CurMeth.CurrentMethod;
if (!$$->getParent())
CurModule.CurrentModule->getMethodList().push_back($$);
CurMeth.MethodDone();
}
//===----------------------------------------------------------------------===//
@ -803,9 +845,11 @@ ConstValueRef : ESINT64VAL { // A reference to a direct constant
| 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...?
@ -867,6 +911,9 @@ Types : ValueRef {
$$ = checkNewType(PointerType::getPointerType($1));
}
// TypeList - Used for struct declarations and as a basis for method type
// declaration type lists
//
TypeList : Types {
$$ = new list<const Type*>();
$$->push_back($1);
@ -875,10 +922,14 @@ TypeList : Types {
($$=$1)->push_back($3);
}
// ArgTypeList - List of types for a method type declaration...
ArgTypeList : TypeList
| TypeList ',' DOTDOTDOT {
($$=$1)->push_back(Type::VoidTy);
}
| DOTDOTDOT {
($$ = new list<const Type*>())->push_back(Type::VoidTy);
}
BasicBlockList : BasicBlockList BasicBlock {
@ -1020,7 +1071,7 @@ InstVal : BinaryOps Types ValueRef ',' ValueRef {
}
delete $2; // Free the list...
}
| CALL Types ValueRef '(' ValueRefListE ')' {
| CALL TypesV ValueRef '(' ValueRefListE ')' {
const MethodType *Ty;
if (!(Ty = $2->isMethodType())) {