2003-10-13 11:32:08 +08:00
|
|
|
//===-- llvmAsmParser.y - Parser for llvm assembly files --------*- C++ -*-===//
|
2005-05-11 06:02:28 +08:00
|
|
|
//
|
2003-10-21 23:17:13 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file was developed by the LLVM research group and is distributed under
|
|
|
|
// the University of Illinois Open Source License. See LICENSE.TXT for details.
|
2005-05-11 06:02:28 +08:00
|
|
|
//
|
2003-10-21 23:17:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
|
|
|
// This file implements the bison parser for LLVM assembly languages files.
|
|
|
|
//
|
2003-10-13 11:32:08 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
%{
|
|
|
|
#include "ParserInternals.h"
|
2005-05-07 04:27:19 +08:00
|
|
|
#include "llvm/CallingConv.h"
|
2006-01-26 06:26:43 +08:00
|
|
|
#include "llvm/InlineAsm.h"
|
2004-07-29 20:17:34 +08:00
|
|
|
#include "llvm/Instructions.h"
|
2001-06-07 04:29:01 +08:00
|
|
|
#include "llvm/Module.h"
|
2004-07-29 20:17:34 +08:00
|
|
|
#include "llvm/SymbolTable.h"
|
2004-04-05 09:30:04 +08:00
|
|
|
#include "llvm/Support/GetElementPtrTypeIterator.h"
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2004-09-02 06:55:40 +08:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2005-11-06 14:46:28 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2006-11-29 06:47:12 +08:00
|
|
|
#include "llvm/Support/Streams.h"
|
2004-07-04 20:19:05 +08:00
|
|
|
#include <algorithm>
|
2001-06-07 04:29:01 +08:00
|
|
|
#include <list>
|
2002-07-31 02:54:25 +08:00
|
|
|
#include <utility>
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
#ifndef NDEBUG
|
|
|
|
#define YYDEBUG 1
|
|
|
|
#endif
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-08-19 01:32:55 +08:00
|
|
|
// The following is a gross hack. In order to rid the libAsmParser library of
|
|
|
|
// exceptions, we have to have a way of getting the yyparse function to go into
|
|
|
|
// an error situation. So, whenever we want an error to occur, the GenerateError
|
|
|
|
// function (see bottom of file) sets TriggerError. Then, at the end of each
|
|
|
|
// production in the grammer we use CHECK_FOR_ERROR which will invoke YYERROR
|
|
|
|
// (a goto) to put YACC in error state. Furthermore, several calls to
|
|
|
|
// GenerateError are made from inside productions and they must simulate the
|
|
|
|
// previous exception behavior by exiting the production immediately. We have
|
|
|
|
// replaced these with the GEN_ERROR macro which calls GeneratError and then
|
|
|
|
// immediately invokes YYERROR. This would be so much cleaner if it was a
|
|
|
|
// recursive descent parser.
|
2006-08-18 16:43:06 +08:00
|
|
|
static bool TriggerError = false;
|
2006-10-10 01:36:59 +08:00
|
|
|
#define CHECK_FOR_ERROR { if (TriggerError) { TriggerError = false; YYABORT; } }
|
2006-08-18 16:43:06 +08:00
|
|
|
#define GEN_ERROR(msg) { GenerateError(msg); YYERROR; }
|
|
|
|
|
2001-10-17 03:54:17 +08:00
|
|
|
int yyerror(const char *ErrorMsg); // Forward declarations to prevent "implicit
|
2001-07-08 12:57:15 +08:00
|
|
|
int yylex(); // declaration" of xxx warnings.
|
2001-06-07 04:29:01 +08:00
|
|
|
int yyparse();
|
|
|
|
|
2003-11-12 06:41:34 +08:00
|
|
|
namespace llvm {
|
2004-07-14 14:39:48 +08:00
|
|
|
std::string CurFilename;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
#if YYDEBUG
|
|
|
|
static cl::opt<bool>
|
|
|
|
Debug("debug-yacc", cl::desc("Print yacc debug state changes"),
|
|
|
|
cl::Hidden, cl::init(false));
|
|
|
|
#endif
|
2004-07-14 14:39:48 +08:00
|
|
|
}
|
|
|
|
using namespace llvm;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
static Module *ParserResult;
|
|
|
|
|
2001-09-08 00:35:17 +08:00
|
|
|
// DEBUG_UPREFS - Define this symbol if you want to enable debugging output
|
|
|
|
// relating to upreferences in the input stream.
|
|
|
|
//
|
|
|
|
//#define DEBUG_UPREFS 1
|
|
|
|
#ifdef DEBUG_UPREFS
|
2006-12-07 09:30:32 +08:00
|
|
|
#define UR_OUT(X) cerr << X
|
2001-09-08 00:35:17 +08:00
|
|
|
#else
|
|
|
|
#define UR_OUT(X)
|
|
|
|
#endif
|
|
|
|
|
2002-07-15 06:59:28 +08:00
|
|
|
#define YYERROR_VERBOSE 1
|
|
|
|
|
2005-11-13 02:21:21 +08:00
|
|
|
static GlobalVariable *CurGV;
|
2005-06-19 02:34:52 +08:00
|
|
|
|
|
|
|
|
2002-06-26 00:13:24 +08:00
|
|
|
// This contains info used when building the body of a function. It is
|
|
|
|
// destroyed when the function is completed.
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
2003-04-23 02:42:41 +08:00
|
|
|
typedef std::vector<Value *> ValueList; // Numbered defs
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
static void
|
|
|
|
ResolveDefinitions(std::map<const Type *,ValueList> &LateResolvers,
|
|
|
|
std::map<const Type *,ValueList> *FutureLateResolvers = 0);
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
static struct PerModuleInfo {
|
|
|
|
Module *CurrentModule;
|
2004-07-09 06:30:50 +08:00
|
|
|
std::map<const Type *, ValueList> Values; // Module level numbered definitions
|
|
|
|
std::map<const Type *,ValueList> LateResolveValues;
|
2006-11-28 15:28:14 +08:00
|
|
|
std::vector<PATypeHolder> Types;
|
|
|
|
std::map<ValID, PATypeHolder> LateResolveTypes;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2004-07-13 16:28:21 +08:00
|
|
|
/// PlaceHolderInfo - When temporary placeholder objects are created, remember
|
2006-05-29 10:34:34 +08:00
|
|
|
/// how they were referenced and on which line of the input they came from so
|
2004-07-13 16:39:15 +08:00
|
|
|
/// that we can resolve them later and print error messages as appropriate.
|
2004-07-13 16:28:21 +08:00
|
|
|
std::map<Value*, std::pair<ValID, int> > PlaceHolderInfo;
|
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
// GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
|
|
|
|
// references to global values. Global values may be referenced before they
|
|
|
|
// are defined, and if so, the temporary object that they represent is held
|
2004-07-18 08:08:11 +08:00
|
|
|
// here. This is used for forward references of GlobalValues.
|
2001-10-13 14:41:08 +08:00
|
|
|
//
|
2003-04-23 02:42:41 +08:00
|
|
|
typedef std::map<std::pair<const PointerType *,
|
2004-03-08 14:09:57 +08:00
|
|
|
ValID>, GlobalValue*> GlobalRefsType;
|
2001-10-13 14:41:08 +08:00
|
|
|
GlobalRefsType GlobalRefs;
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
void ModuleDone() {
|
2002-06-26 00:13:24 +08:00
|
|
|
// If we could not resolve some functions at function compilation time
|
|
|
|
// (calls to functions before they are defined), resolve them now... Types
|
|
|
|
// are resolved when the constant pool has been completely parsed.
|
2001-09-08 00:35:17 +08:00
|
|
|
//
|
2001-06-07 04:29:01 +08:00
|
|
|
ResolveDefinitions(LateResolveValues);
|
2006-09-29 03:28:24 +08:00
|
|
|
if (TriggerError)
|
|
|
|
return;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
// Check to make sure that all global value forward references have been
|
|
|
|
// resolved!
|
|
|
|
//
|
|
|
|
if (!GlobalRefs.empty()) {
|
2003-04-23 02:42:41 +08:00
|
|
|
std::string UndefinedReferences = "Unresolved global references exist:\n";
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2002-03-12 06:12:39 +08:00
|
|
|
for (GlobalRefsType::iterator I = GlobalRefs.begin(), E =GlobalRefs.end();
|
|
|
|
I != E; ++I) {
|
|
|
|
UndefinedReferences += " " + I->first.first->getDescription() + " " +
|
|
|
|
I->first.second.getName() + "\n";
|
|
|
|
}
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError(UndefinedReferences);
|
2006-09-29 03:28:24 +08:00
|
|
|
return;
|
2001-10-13 14:41:08 +08:00
|
|
|
}
|
|
|
|
|
2002-06-26 00:13:24 +08:00
|
|
|
Values.clear(); // Clear out function local definitions
|
2001-09-08 00:35:17 +08:00
|
|
|
Types.clear();
|
2001-06-07 04:29:01 +08:00
|
|
|
CurrentModule = 0;
|
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
|
2004-07-15 05:44:00 +08:00
|
|
|
// GetForwardRefForGlobal - Check to see if there is a forward reference
|
|
|
|
// for this global. If so, remove it from the GlobalRefs map and return it.
|
|
|
|
// If not, just return null.
|
|
|
|
GlobalValue *GetForwardRefForGlobal(const PointerType *PTy, ValID ID) {
|
|
|
|
// Check to see if there is a forward reference to this global variable...
|
|
|
|
// if there is, eliminate it and patch the reference to use the new def'n.
|
|
|
|
GlobalRefsType::iterator I = GlobalRefs.find(std::make_pair(PTy, ID));
|
|
|
|
GlobalValue *Ret = 0;
|
|
|
|
if (I != GlobalRefs.end()) {
|
|
|
|
Ret = I->second;
|
|
|
|
GlobalRefs.erase(I);
|
|
|
|
}
|
|
|
|
return Ret;
|
|
|
|
}
|
2007-01-03 05:53:43 +08:00
|
|
|
|
|
|
|
bool TypeIsUnresolved(PATypeHolder* PATy) {
|
|
|
|
// If it isn't abstract, its resolved
|
|
|
|
const Type* Ty = PATy->get();
|
|
|
|
if (!Ty->isAbstract())
|
|
|
|
return false;
|
|
|
|
// Traverse the type looking for abstract types. If it isn't abstract then
|
|
|
|
// we don't need to traverse that leg of the type.
|
|
|
|
std::vector<const Type*> WorkList, SeenList;
|
|
|
|
WorkList.push_back(Ty);
|
|
|
|
while (!WorkList.empty()) {
|
|
|
|
const Type* Ty = WorkList.back();
|
|
|
|
SeenList.push_back(Ty);
|
|
|
|
WorkList.pop_back();
|
|
|
|
if (const OpaqueType* OpTy = dyn_cast<OpaqueType>(Ty)) {
|
|
|
|
// Check to see if this is an unresolved type
|
|
|
|
std::map<ValID, PATypeHolder>::iterator I = LateResolveTypes.begin();
|
|
|
|
std::map<ValID, PATypeHolder>::iterator E = LateResolveTypes.end();
|
|
|
|
for ( ; I != E; ++I) {
|
|
|
|
if (I->second.get() == OpTy)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
} else if (const SequentialType* SeqTy = dyn_cast<SequentialType>(Ty)) {
|
|
|
|
const Type* TheTy = SeqTy->getElementType();
|
|
|
|
if (TheTy->isAbstract() && TheTy != Ty) {
|
|
|
|
std::vector<const Type*>::iterator I = SeenList.begin(),
|
|
|
|
E = SeenList.end();
|
|
|
|
for ( ; I != E; ++I)
|
|
|
|
if (*I == TheTy)
|
|
|
|
break;
|
|
|
|
if (I == E)
|
|
|
|
WorkList.push_back(TheTy);
|
|
|
|
}
|
|
|
|
} else if (const StructType* StrTy = dyn_cast<StructType>(Ty)) {
|
|
|
|
for (unsigned i = 0; i < StrTy->getNumElements(); ++i) {
|
|
|
|
const Type* TheTy = StrTy->getElementType(i);
|
|
|
|
if (TheTy->isAbstract() && TheTy != Ty) {
|
|
|
|
std::vector<const Type*>::iterator I = SeenList.begin(),
|
|
|
|
E = SeenList.end();
|
|
|
|
for ( ; I != E; ++I)
|
|
|
|
if (*I == TheTy)
|
|
|
|
break;
|
|
|
|
if (I == E)
|
|
|
|
WorkList.push_back(TheTy);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
} CurModule;
|
|
|
|
|
2002-03-27 02:01:55 +08:00
|
|
|
static struct PerFunctionInfo {
|
2002-06-26 00:13:24 +08:00
|
|
|
Function *CurrentFunction; // Pointer to current function being created
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-09-15 02:23:27 +08:00
|
|
|
std::map<const Type*, ValueList> Values; // Keep track of #'d definitions
|
2004-07-09 06:30:50 +08:00
|
|
|
std::map<const Type*, ValueList> LateResolveValues;
|
2006-09-15 02:23:27 +08:00
|
|
|
bool isDeclare; // Is this function a forward declararation?
|
|
|
|
GlobalValue::LinkageTypes Linkage; // Linkage for forward declaration.
|
2007-01-13 03:20:47 +08:00
|
|
|
GlobalValue::VisibilityTypes Visibility;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2004-07-14 14:28:35 +08:00
|
|
|
/// BBForwardRefs - When we see forward references to basic blocks, keep
|
|
|
|
/// track of them here.
|
|
|
|
std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
|
|
|
|
std::vector<BasicBlock*> NumberedBlocks;
|
|
|
|
unsigned NextBBNum;
|
|
|
|
|
2002-03-27 02:01:55 +08:00
|
|
|
inline PerFunctionInfo() {
|
|
|
|
CurrentFunction = 0;
|
2001-07-15 14:35:53 +08:00
|
|
|
isDeclare = false;
|
2007-01-13 03:20:47 +08:00
|
|
|
Linkage = GlobalValue::ExternalLinkage;
|
|
|
|
Visibility = GlobalValue::DefaultVisibility;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2002-03-27 02:01:55 +08:00
|
|
|
inline void FunctionStart(Function *M) {
|
|
|
|
CurrentFunction = M;
|
2004-07-14 14:28:35 +08:00
|
|
|
NextBBNum = 0;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2002-03-27 02:01:55 +08:00
|
|
|
void FunctionDone() {
|
2004-07-14 14:28:35 +08:00
|
|
|
NumberedBlocks.clear();
|
|
|
|
|
|
|
|
// Any forward referenced blocks left?
|
2006-09-29 03:28:24 +08:00
|
|
|
if (!BBForwardRefs.empty()) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Undefined reference to label " +
|
2005-02-24 12:59:49 +08:00
|
|
|
BBForwardRefs.begin()->first->getName());
|
2006-09-29 03:28:24 +08:00
|
|
|
return;
|
|
|
|
}
|
2004-07-14 14:28:35 +08:00
|
|
|
|
|
|
|
// Resolve all forward references now.
|
2001-10-17 03:54:17 +08:00
|
|
|
ResolveDefinitions(LateResolveValues, &CurModule.LateResolveValues);
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-06-26 00:13:24 +08:00
|
|
|
Values.clear(); // Clear out function local definitions
|
2002-03-27 02:01:55 +08:00
|
|
|
CurrentFunction = 0;
|
2001-07-15 14:35:53 +08:00
|
|
|
isDeclare = false;
|
2006-09-15 02:23:27 +08:00
|
|
|
Linkage = GlobalValue::ExternalLinkage;
|
2007-01-13 03:20:47 +08:00
|
|
|
Visibility = GlobalValue::DefaultVisibility;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2003-10-17 04:12:13 +08:00
|
|
|
} CurFun; // Info for the current function...
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2003-10-17 04:12:13 +08:00
|
|
|
static bool inFunctionScope() { return CurFun.CurrentFunction != 0; }
|
2001-10-03 23:39:04 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Code to handle definitions of all the types
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-07-09 06:30:50 +08:00
|
|
|
static int InsertValue(Value *V,
|
|
|
|
std::map<const Type*,ValueList> &ValueTab = CurFun.Values) {
|
|
|
|
if (V->hasName()) return -1; // Is this a numbered definition?
|
2001-10-13 14:41:08 +08:00
|
|
|
|
|
|
|
// Yes, insert the value into the value table...
|
2004-07-09 06:30:50 +08:00
|
|
|
ValueList &List = ValueTab[V->getType()];
|
|
|
|
List.push_back(V);
|
2004-02-10 05:03:38 +08:00
|
|
|
return List.size()-1;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2001-09-08 00:35:17 +08:00
|
|
|
static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
|
|
|
|
switch (D.Type) {
|
2004-07-15 07:03:46 +08:00
|
|
|
case ValID::NumberVal: // Is it a numbered definition?
|
2001-09-08 00:35:17 +08:00
|
|
|
// Module constants occupy the lowest numbered slots...
|
2005-05-11 06:02:28 +08:00
|
|
|
if ((unsigned)D.Num < CurModule.Types.size())
|
2006-11-28 15:28:14 +08:00
|
|
|
return CurModule.Types[(unsigned)D.Num];
|
2001-10-20 17:32:59 +08:00
|
|
|
break;
|
2004-07-15 07:03:46 +08:00
|
|
|
case ValID::NameVal: // Is it a named definition?
|
|
|
|
if (const Type *N = CurModule.CurrentModule->getTypeByName(D.Name)) {
|
|
|
|
D.destroy(); // Free old strdup'd memory...
|
|
|
|
return N;
|
2002-11-21 02:36:02 +08:00
|
|
|
}
|
2004-07-15 07:03:46 +08:00
|
|
|
break;
|
2001-09-08 00:35:17 +08:00
|
|
|
default:
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Internal parser error: Invalid symbol type reference!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// 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?
|
|
|
|
|
2005-03-21 14:27:42 +08:00
|
|
|
|
|
|
|
if (inFunctionScope()) {
|
2006-09-29 03:28:24 +08:00
|
|
|
if (D.Type == ValID::NameVal) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Reference to an undefined type: '" + D.getName() + "'");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
} else {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Reference to an undefined type: #" + itostr(D.Num));
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2001-10-22 13:56:09 +08:00
|
|
|
}
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2006-11-28 15:28:14 +08:00
|
|
|
std::map<ValID, PATypeHolder>::iterator I =CurModule.LateResolveTypes.find(D);
|
2005-03-21 14:27:42 +08:00
|
|
|
if (I != CurModule.LateResolveTypes.end())
|
2006-11-28 15:28:14 +08:00
|
|
|
return I->second;
|
2005-03-21 14:27:42 +08:00
|
|
|
|
2006-11-28 15:28:14 +08:00
|
|
|
Type *Typ = OpaqueType::get();
|
|
|
|
CurModule.LateResolveTypes.insert(std::make_pair(D, Typ));
|
|
|
|
return Typ;
|
2006-12-03 13:45:44 +08:00
|
|
|
}
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2003-04-23 02:42:41 +08:00
|
|
|
static Value *lookupInSymbolTable(const Type *Ty, const std::string &Name) {
|
2005-05-11 06:02:28 +08:00
|
|
|
SymbolTable &SymTab =
|
2007-01-06 15:24:44 +08:00
|
|
|
inFunctionScope() ? CurFun.CurrentFunction->getValueSymbolTable() :
|
|
|
|
CurModule.CurrentModule->getValueSymbolTable();
|
2002-11-21 02:36:02 +08:00
|
|
|
return SymTab.lookup(Ty, Name);
|
2001-10-03 14:12:09 +08:00
|
|
|
}
|
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
// getValNonImprovising - Look up the value specified by the provided type and
|
|
|
|
// the provided ValID. If the value exists and has already been defined, return
|
|
|
|
// it. Otherwise return null.
|
|
|
|
//
|
|
|
|
static Value *getValNonImprovising(const Type *Ty, const ValID &D) {
|
2006-09-29 03:28:24 +08:00
|
|
|
if (isa<FunctionType>(Ty)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Functions are not values and "
|
2002-03-27 02:01:55 +08:00
|
|
|
"must be referenced as pointers");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2001-10-17 03:54:17 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
switch (D.Type) {
|
2001-10-01 06:46:54 +08:00
|
|
|
case ValID::NumberVal: { // Is it a numbered definition?
|
2001-06-07 04:29:01 +08:00
|
|
|
unsigned Num = (unsigned)D.Num;
|
|
|
|
|
|
|
|
// Module constants occupy the lowest numbered slots...
|
2004-07-09 06:30:50 +08:00
|
|
|
std::map<const Type*,ValueList>::iterator VI = CurModule.Values.find(Ty);
|
2004-02-10 05:03:38 +08:00
|
|
|
if (VI != CurModule.Values.end()) {
|
2005-05-11 06:02:28 +08:00
|
|
|
if (Num < VI->second.size())
|
2004-02-10 05:03:38 +08:00
|
|
|
return VI->second[Num];
|
|
|
|
Num -= VI->second.size();
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure that our type is within bounds
|
2004-07-09 06:30:50 +08:00
|
|
|
VI = CurFun.Values.find(Ty);
|
2004-02-10 05:03:38 +08:00
|
|
|
if (VI == CurFun.Values.end()) return 0;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
// Check that the number is within bounds...
|
2004-02-10 05:03:38 +08:00
|
|
|
if (VI->second.size() <= Num) return 0;
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2004-02-10 05:03:38 +08:00
|
|
|
return VI->second[Num];
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
|
2001-10-01 06:46:54 +08:00
|
|
|
case ValID::NameVal: { // Is it a named definition?
|
2003-04-23 02:42:41 +08:00
|
|
|
Value *N = lookupInSymbolTable(Ty, std::string(D.Name));
|
2001-10-13 14:41:08 +08:00
|
|
|
if (N == 0) return 0;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
D.destroy(); // Free old strdup'd memory...
|
|
|
|
return N;
|
|
|
|
}
|
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
// Check to make sure that "Ty" is an integral type, and that our
|
2001-10-13 14:41:08 +08:00
|
|
|
// value will fit into the specified type...
|
|
|
|
case ValID::ConstSIntVal: // Is it a constant pool reference??
|
2006-10-20 15:07:24 +08:00
|
|
|
if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Signed integral constant '" +
|
2005-05-11 06:02:28 +08:00
|
|
|
itostr(D.ConstPool64) + "' is invalid for type '" +
|
2002-08-17 05:14:40 +08:00
|
|
|
Ty->getDescription() + "'!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2006-10-20 15:07:24 +08:00
|
|
|
return ConstantInt::get(Ty, D.ConstPool64);
|
2001-10-13 14:41:08 +08:00
|
|
|
|
2001-10-01 06:46:54 +08:00
|
|
|
case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
|
2006-10-20 15:07:24 +08:00
|
|
|
if (!ConstantInt::isValueValidForType(Ty, D.UConstPool64)) {
|
|
|
|
if (!ConstantInt::isValueValidForType(Ty, D.ConstPool64)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Integral constant '" + utostr(D.UConstPool64) +
|
2002-07-18 13:18:37 +08:00
|
|
|
"' is invalid or out of range!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
2001-10-13 14:41:08 +08:00
|
|
|
} else { // This is really a signed reference. Transmogrify.
|
2006-10-20 15:07:24 +08:00
|
|
|
return ConstantInt::get(Ty, D.ConstPool64);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
} else {
|
2006-10-20 15:07:24 +08:00
|
|
|
return ConstantInt::get(Ty, D.UConstPool64);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
|
|
|
|
case ValID::ConstFPVal: // Is it a floating point const pool reference?
|
2006-09-29 03:28:24 +08:00
|
|
|
if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("FP constant invalid for type!!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2001-12-04 06:26:30 +08:00
|
|
|
return ConstantFP::get(Ty, D.ConstPoolFP);
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
case ValID::ConstNullVal: // Is it a null value?
|
2006-09-29 03:28:24 +08:00
|
|
|
if (!isa<PointerType>(Ty)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Cannot create a a non pointer null!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2001-12-04 06:26:30 +08:00
|
|
|
return ConstantPointerNull::get(cast<PointerType>(Ty));
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2004-10-17 02:17:13 +08:00
|
|
|
case ValID::ConstUndefVal: // Is it an undef value?
|
|
|
|
return UndefValue::get(Ty);
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2005-12-22 01:53:02 +08:00
|
|
|
case ValID::ConstZeroVal: // Is it a zero value?
|
|
|
|
return Constant::getNullValue(Ty);
|
|
|
|
|
2002-08-17 05:14:40 +08:00
|
|
|
case ValID::ConstantVal: // Fully resolved constant?
|
2006-09-29 03:28:24 +08:00
|
|
|
if (D.ConstantValue->getType() != Ty) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Constant expression type different from required type!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2002-08-17 05:14:40 +08:00
|
|
|
return D.ConstantValue;
|
|
|
|
|
2006-01-26 06:26:43 +08:00
|
|
|
case ValID::InlineAsmVal: { // Inline asm expression
|
|
|
|
const PointerType *PTy = dyn_cast<PointerType>(Ty);
|
|
|
|
const FunctionType *FTy =
|
|
|
|
PTy ? dyn_cast<FunctionType>(PTy->getElementType()) : 0;
|
2006-09-29 03:28:24 +08:00
|
|
|
if (!FTy || !InlineAsm::Verify(FTy, D.IAD->Constraints)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Invalid type for asm constraint string!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2006-01-26 06:26:43 +08:00
|
|
|
InlineAsm *IA = InlineAsm::get(FTy, D.IAD->AsmString, D.IAD->Constraints,
|
|
|
|
D.IAD->HasSideEffects);
|
|
|
|
D.destroy(); // Free InlineAsmDescriptor.
|
|
|
|
return IA;
|
|
|
|
}
|
2001-09-08 00:35:17 +08:00
|
|
|
default:
|
|
|
|
assert(0 && "Unhandled case!");
|
2001-10-13 14:41:08 +08:00
|
|
|
return 0;
|
2001-06-07 04:29:01 +08:00
|
|
|
} // End of switch
|
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
assert(0 && "Unhandled case!");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// getVal - This function is identical to getValNonImprovising, except that if a
|
|
|
|
// value is not already defined, it "improvises" by creating a placeholder var
|
|
|
|
// that looks and acts just like the requested variable. When the value is
|
|
|
|
// defined later, all uses of the placeholder variable are replaced with the
|
|
|
|
// real thing.
|
|
|
|
//
|
2004-07-14 09:33:11 +08:00
|
|
|
static Value *getVal(const Type *Ty, const ValID &ID) {
|
2006-09-29 03:28:24 +08:00
|
|
|
if (Ty == Type::LabelTy) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Cannot use a basic block here");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
|
2004-07-14 09:33:11 +08:00
|
|
|
// See if the value has already been defined.
|
|
|
|
Value *V = getValNonImprovising(Ty, ID);
|
2001-10-13 14:41:08 +08:00
|
|
|
if (V) return V;
|
2006-09-29 03:28:24 +08:00
|
|
|
if (TriggerError) return 0;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-09-29 03:28:24 +08:00
|
|
|
if (!Ty->isFirstClassType() && !isa<OpaqueType>(Ty)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Invalid use of a composite type!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2005-03-23 09:29:26 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
// 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...
|
|
|
|
//
|
2004-07-14 09:33:11 +08:00
|
|
|
V = new Argument(Ty);
|
2004-07-13 16:28:21 +08:00
|
|
|
|
|
|
|
// Remember where this forward reference came from. FIXME, shouldn't we try
|
|
|
|
// to recycle these things??
|
2004-07-14 09:33:11 +08:00
|
|
|
CurModule.PlaceHolderInfo.insert(std::make_pair(V, std::make_pair(ID,
|
2004-07-13 16:28:21 +08:00
|
|
|
llvmAsmlineno)));
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-03-27 02:01:55 +08:00
|
|
|
if (inFunctionScope())
|
2004-07-13 16:28:21 +08:00
|
|
|
InsertValue(V, CurFun.LateResolveValues);
|
2005-05-11 06:02:28 +08:00
|
|
|
else
|
2004-07-13 16:28:21 +08:00
|
|
|
InsertValue(V, CurModule.LateResolveValues);
|
|
|
|
return V;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2004-07-14 14:28:35 +08:00
|
|
|
/// getBBVal - This is used for two purposes:
|
|
|
|
/// * If isDefinition is true, a new basic block with the specified ID is being
|
|
|
|
/// defined.
|
|
|
|
/// * If isDefinition is true, this is a reference to a basic block, which may
|
|
|
|
/// or may not be a forward reference.
|
|
|
|
///
|
|
|
|
static BasicBlock *getBBVal(const ValID &ID, bool isDefinition = false) {
|
2004-07-14 09:33:11 +08:00
|
|
|
assert(inFunctionScope() && "Can't get basic block at global scope!");
|
|
|
|
|
2004-07-14 14:28:35 +08:00
|
|
|
std::string Name;
|
|
|
|
BasicBlock *BB = 0;
|
|
|
|
switch (ID.Type) {
|
2006-09-29 03:28:24 +08:00
|
|
|
default:
|
|
|
|
GenerateError("Illegal label reference " + ID.getName());
|
|
|
|
return 0;
|
2004-07-14 14:28:35 +08:00
|
|
|
case ValID::NumberVal: // Is it a numbered definition?
|
|
|
|
if (unsigned(ID.Num) >= CurFun.NumberedBlocks.size())
|
|
|
|
CurFun.NumberedBlocks.resize(ID.Num+1);
|
|
|
|
BB = CurFun.NumberedBlocks[ID.Num];
|
|
|
|
break;
|
|
|
|
case ValID::NameVal: // Is it a named definition?
|
|
|
|
Name = ID.Name;
|
2004-07-15 07:03:46 +08:00
|
|
|
if (Value *N = CurFun.CurrentFunction->
|
2007-01-06 15:24:44 +08:00
|
|
|
getValueSymbolTable().lookup(Type::LabelTy, Name))
|
2004-07-14 14:28:35 +08:00
|
|
|
BB = cast<BasicBlock>(N);
|
|
|
|
break;
|
|
|
|
}
|
2004-07-14 09:33:11 +08:00
|
|
|
|
2004-07-14 14:28:35 +08:00
|
|
|
// See if the block has already been defined.
|
|
|
|
if (BB) {
|
|
|
|
// If this is the definition of the block, make sure the existing value was
|
|
|
|
// just a forward reference. If it was a forward reference, there will be
|
|
|
|
// an entry for it in the PlaceHolderInfo map.
|
2006-09-29 03:28:24 +08:00
|
|
|
if (isDefinition && !CurFun.BBForwardRefs.erase(BB)) {
|
2004-07-14 14:28:35 +08:00
|
|
|
// The existing value was a definition, not a forward reference.
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Redefinition of label " + ID.getName());
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2004-07-14 14:28:35 +08:00
|
|
|
|
|
|
|
ID.destroy(); // Free strdup'd memory.
|
|
|
|
return BB;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise this block has not been seen before.
|
|
|
|
BB = new BasicBlock("", CurFun.CurrentFunction);
|
|
|
|
if (ID.Type == ValID::NameVal) {
|
|
|
|
BB->setName(ID.Name);
|
|
|
|
} else {
|
|
|
|
CurFun.NumberedBlocks[ID.Num] = BB;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If this is not a definition, keep track of it so we can use it as a forward
|
|
|
|
// reference.
|
|
|
|
if (!isDefinition) {
|
|
|
|
// Remember where this forward reference came from.
|
|
|
|
CurFun.BBForwardRefs[BB] = std::make_pair(ID, llvmAsmlineno);
|
|
|
|
} else {
|
|
|
|
// The forward declaration could have been inserted anywhere in the
|
|
|
|
// function: insert it into the correct place now.
|
|
|
|
CurFun.CurrentFunction->getBasicBlockList().remove(BB);
|
|
|
|
CurFun.CurrentFunction->getBasicBlockList().push_back(BB);
|
|
|
|
}
|
2004-10-27 02:26:14 +08:00
|
|
|
ID.destroy();
|
2004-07-14 09:33:11 +08:00
|
|
|
return BB;
|
|
|
|
}
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// 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.
|
|
|
|
//
|
2003-10-17 04:12:13 +08:00
|
|
|
// This keeps a table (CurFun.LateResolveValues) of all such forward references
|
2001-06-07 04:29:01 +08:00
|
|
|
// and back patchs after we are done.
|
|
|
|
//
|
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
// ResolveDefinitions - If we could not resolve some defs at parsing
|
|
|
|
// time (forward branches, phi functions for loops, etc...) resolve the
|
2001-06-07 04:29:01 +08:00
|
|
|
// defs now...
|
|
|
|
//
|
2005-05-11 06:02:28 +08:00
|
|
|
static void
|
|
|
|
ResolveDefinitions(std::map<const Type*,ValueList> &LateResolvers,
|
|
|
|
std::map<const Type*,ValueList> *FutureLateResolvers) {
|
2001-06-07 04:29:01 +08:00
|
|
|
// Loop over LateResolveDefs fixing up stuff that couldn't be resolved
|
2004-07-09 06:30:50 +08:00
|
|
|
for (std::map<const Type*,ValueList>::iterator LRI = LateResolvers.begin(),
|
2004-02-10 05:03:38 +08:00
|
|
|
E = LateResolvers.end(); LRI != E; ++LRI) {
|
|
|
|
ValueList &List = LRI->second;
|
|
|
|
while (!List.empty()) {
|
|
|
|
Value *V = List.back();
|
|
|
|
List.pop_back();
|
2004-07-13 16:28:21 +08:00
|
|
|
|
|
|
|
std::map<Value*, std::pair<ValID, int> >::iterator PHI =
|
|
|
|
CurModule.PlaceHolderInfo.find(V);
|
|
|
|
assert(PHI != CurModule.PlaceHolderInfo.end() && "Placeholder error!");
|
|
|
|
|
|
|
|
ValID &DID = PHI->second.first;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2004-07-09 06:30:50 +08:00
|
|
|
Value *TheRealValue = getValNonImprovising(LRI->first, DID);
|
2006-09-29 03:28:24 +08:00
|
|
|
if (TriggerError)
|
|
|
|
return;
|
2001-10-17 03:54:17 +08:00
|
|
|
if (TheRealValue) {
|
|
|
|
V->replaceAllUsesWith(TheRealValue);
|
|
|
|
delete V;
|
2004-07-13 16:28:21 +08:00
|
|
|
CurModule.PlaceHolderInfo.erase(PHI);
|
2001-10-17 03:54:17 +08:00
|
|
|
} else if (FutureLateResolvers) {
|
2002-03-27 02:01:55 +08:00
|
|
|
// Functions have their unresolved items forwarded to the module late
|
2001-10-17 03:54:17 +08:00
|
|
|
// resolver table
|
|
|
|
InsertValue(V, *FutureLateResolvers);
|
|
|
|
} else {
|
2006-09-29 03:28:24 +08:00
|
|
|
if (DID.Type == ValID::NameVal) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Reference to an invalid definition: '" +DID.getName()+
|
2004-07-18 08:08:11 +08:00
|
|
|
"' of type '" + V->getType()->getDescription() + "'",
|
|
|
|
PHI->second.second);
|
2006-09-29 03:28:24 +08:00
|
|
|
return;
|
|
|
|
} else {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Reference to an invalid definition: #" +
|
2005-05-11 06:02:28 +08:00
|
|
|
itostr(DID.Num) + " of type '" +
|
2004-07-18 08:08:11 +08:00
|
|
|
V->getType()->getDescription() + "'",
|
|
|
|
PHI->second.second);
|
2006-09-29 03:28:24 +08:00
|
|
|
return;
|
|
|
|
}
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
LateResolvers.clear();
|
|
|
|
}
|
|
|
|
|
2001-10-22 13:56:09 +08:00
|
|
|
// ResolveTypeTo - A brand new type was just declared. This means that (if
|
|
|
|
// name is not null) things referencing Name can be resolved. Otherwise, things
|
|
|
|
// refering to the number can be resolved. Do this now.
|
2001-06-07 04:29:01 +08:00
|
|
|
//
|
2001-10-22 13:56:09 +08:00
|
|
|
static void ResolveTypeTo(char *Name, const Type *ToTy) {
|
2005-03-21 14:27:42 +08:00
|
|
|
ValID D;
|
|
|
|
if (Name) D = ValID::create(Name);
|
|
|
|
else D = ValID::create((int)CurModule.Types.size());
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-11-28 15:28:14 +08:00
|
|
|
std::map<ValID, PATypeHolder>::iterator I =
|
2005-03-21 14:27:42 +08:00
|
|
|
CurModule.LateResolveTypes.find(D);
|
|
|
|
if (I != CurModule.LateResolveTypes.end()) {
|
2006-11-28 15:28:14 +08:00
|
|
|
((DerivedType*)I->second.get())->refineAbstractTypeTo(ToTy);
|
2005-03-21 14:27:42 +08:00
|
|
|
CurModule.LateResolveTypes.erase(I);
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2001-09-18 12:00:54 +08:00
|
|
|
// setValueName - Set the specified value to the name given. The name may be
|
|
|
|
// null potentially, in which case this is a noop. The string passed in is
|
2004-07-13 15:59:27 +08:00
|
|
|
// assumed to be a malloc'd string buffer, and is free'd by this function.
|
|
|
|
//
|
|
|
|
static void setValueName(Value *V, char *NameStr) {
|
|
|
|
if (NameStr) {
|
|
|
|
std::string Name(NameStr); // Copy string
|
|
|
|
free(NameStr); // Free old string
|
2004-07-13 16:12:39 +08:00
|
|
|
|
2006-09-29 03:28:24 +08:00
|
|
|
if (V->getType() == Type::VoidTy) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Can't assign name '" + Name+"' to value with void type!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return;
|
|
|
|
}
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2004-07-13 15:59:27 +08:00
|
|
|
assert(inFunctionScope() && "Must be in function scope!");
|
2007-01-06 15:24:44 +08:00
|
|
|
SymbolTable &ST = CurFun.CurrentFunction->getValueSymbolTable();
|
2006-09-29 03:28:24 +08:00
|
|
|
if (ST.lookup(V->getType(), Name)) {
|
2007-01-06 05:50:38 +08:00
|
|
|
GenerateError("Redefinition of value '" + Name + "' of type '" +
|
|
|
|
V->getType()->getDescription() + "'!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return;
|
|
|
|
}
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2004-07-13 16:12:39 +08:00
|
|
|
// Set the name.
|
2005-03-06 03:04:07 +08:00
|
|
|
V->setName(Name);
|
2004-07-13 15:59:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-07-15 04:42:57 +08:00
|
|
|
/// ParseGlobalVariable - Handle parsing of a global. If Initializer is null,
|
|
|
|
/// this is a declaration, otherwise it is a definition.
|
2005-11-13 02:21:21 +08:00
|
|
|
static GlobalVariable *
|
2007-01-13 03:20:47 +08:00
|
|
|
ParseGlobalVariable(char *NameStr,
|
|
|
|
GlobalValue::LinkageTypes Linkage,
|
|
|
|
GlobalValue::VisibilityTypes Visibility,
|
2005-11-13 02:21:21 +08:00
|
|
|
bool isConstantGlobal, const Type *Ty,
|
|
|
|
Constant *Initializer) {
|
2006-09-29 03:28:24 +08:00
|
|
|
if (isa<FunctionType>(Ty)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Cannot declare global vars of function type!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2001-09-18 12:00:54 +08:00
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
const PointerType *PTy = PointerType::get(Ty);
|
2004-07-15 07:03:46 +08:00
|
|
|
|
2004-07-15 04:42:57 +08:00
|
|
|
std::string Name;
|
|
|
|
if (NameStr) {
|
|
|
|
Name = NameStr; // Copy string
|
|
|
|
free(NameStr); // Free old string
|
2004-07-15 07:03:46 +08:00
|
|
|
}
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2004-07-15 07:03:46 +08:00
|
|
|
// See if this global value was forward referenced. If so, recycle the
|
|
|
|
// object.
|
2005-05-11 06:02:28 +08:00
|
|
|
ValID ID;
|
2004-07-15 07:03:46 +08:00
|
|
|
if (!Name.empty()) {
|
|
|
|
ID = ValID::create((char*)Name.c_str());
|
|
|
|
} else {
|
|
|
|
ID = ValID::create((int)CurModule.Values[PTy].size());
|
|
|
|
}
|
2004-07-14 15:12:48 +08:00
|
|
|
|
2004-07-15 07:03:46 +08:00
|
|
|
if (GlobalValue *FWGV = CurModule.GetForwardRefForGlobal(PTy, ID)) {
|
2005-05-11 06:02:28 +08:00
|
|
|
// Move the global to the end of the list, from whereever it was
|
2004-07-15 07:03:46 +08:00
|
|
|
// previously inserted.
|
|
|
|
GlobalVariable *GV = cast<GlobalVariable>(FWGV);
|
|
|
|
CurModule.CurrentModule->getGlobalList().remove(GV);
|
|
|
|
CurModule.CurrentModule->getGlobalList().push_back(GV);
|
|
|
|
GV->setInitializer(Initializer);
|
|
|
|
GV->setLinkage(Linkage);
|
2007-01-13 03:20:47 +08:00
|
|
|
GV->setVisibility(Visibility);
|
2004-07-15 07:03:46 +08:00
|
|
|
GV->setConstant(isConstantGlobal);
|
2004-07-16 09:18:09 +08:00
|
|
|
InsertValue(GV, CurModule.Values);
|
2005-11-13 02:21:21 +08:00
|
|
|
return GV;
|
2004-07-15 07:03:46 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If this global has a name, check to see if there is already a definition
|
2007-01-06 05:50:38 +08:00
|
|
|
// of this global in the module. If so, it is an error.
|
2004-07-15 07:03:46 +08:00
|
|
|
if (!Name.empty()) {
|
|
|
|
// We are a simple redefinition of a value, check to see if it is defined
|
|
|
|
// the same as the old one.
|
2007-01-06 05:50:38 +08:00
|
|
|
if (CurModule.CurrentModule->getGlobalVariable(Name, Ty)) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Redefinition of global variable named '" + Name +
|
2007-01-06 05:50:38 +08:00
|
|
|
"' of type '" + Ty->getDescription() + "'!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return 0;
|
2004-07-15 04:42:57 +08:00
|
|
|
}
|
2001-07-10 03:38:36 +08:00
|
|
|
}
|
2004-07-13 16:12:39 +08:00
|
|
|
|
2004-07-15 07:03:46 +08:00
|
|
|
// Otherwise there is no existing GV to use, create one now.
|
2004-07-16 09:18:09 +08:00
|
|
|
GlobalVariable *GV =
|
2005-05-11 06:02:28 +08:00
|
|
|
new GlobalVariable(Ty, isConstantGlobal, Linkage, Initializer, Name,
|
2004-07-16 09:18:09 +08:00
|
|
|
CurModule.CurrentModule);
|
2007-01-13 03:20:47 +08:00
|
|
|
GV->setVisibility(Visibility);
|
2004-07-16 09:18:09 +08:00
|
|
|
InsertValue(GV, CurModule.Values);
|
2005-11-13 02:21:21 +08:00
|
|
|
return GV;
|
2004-07-14 16:23:52 +08:00
|
|
|
}
|
2004-07-13 15:59:27 +08:00
|
|
|
|
2004-05-27 05:48:31 +08:00
|
|
|
// setTypeName - Set the specified type to the name given. The name may be
|
|
|
|
// null potentially, in which case this is a noop. The string passed in is
|
|
|
|
// assumed to be a malloc'd string buffer, and is freed by this function.
|
|
|
|
//
|
|
|
|
// This function returns true if the type has already been defined, but is
|
|
|
|
// allowed to be redefined in the specified context. If the name is a new name
|
|
|
|
// for the type plane, it is inserted and false is returned.
|
2004-07-13 16:10:10 +08:00
|
|
|
static bool setTypeName(const Type *T, char *NameStr) {
|
2004-07-15 07:03:46 +08:00
|
|
|
assert(!inFunctionScope() && "Can't give types function-local names!");
|
2004-05-27 05:48:31 +08:00
|
|
|
if (NameStr == 0) return false;
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2004-05-27 05:48:31 +08:00
|
|
|
std::string Name(NameStr); // Copy string
|
|
|
|
free(NameStr); // Free old string
|
|
|
|
|
|
|
|
// We don't allow assigning names to void type
|
2006-09-29 03:28:24 +08:00
|
|
|
if (T == Type::VoidTy) {
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError("Can't assign name '" + Name + "' to the void type!");
|
2006-09-29 03:28:24 +08:00
|
|
|
return false;
|
|
|
|
}
|
2004-05-27 05:48:31 +08:00
|
|
|
|
2004-07-15 07:03:46 +08:00
|
|
|
// Set the type name, checking for conflicts as we do so.
|
|
|
|
bool AlreadyExists = CurModule.CurrentModule->addTypeName(Name, T);
|
|
|
|
|
|
|
|
if (AlreadyExists) { // Inserting a name that is already defined???
|
|
|
|
const Type *Existing = CurModule.CurrentModule->getTypeByName(Name);
|
|
|
|
assert(Existing && "Conflict but no matching type?");
|
2004-05-27 05:48:31 +08:00
|
|
|
|
|
|
|
// There is only one case where this is allowed: when we are refining an
|
|
|
|
// opaque type. In this case, Existing will be an opaque type.
|
|
|
|
if (const OpaqueType *OpTy = dyn_cast<OpaqueType>(Existing)) {
|
|
|
|
// We ARE replacing an opaque type!
|
2004-07-13 16:10:10 +08:00
|
|
|
const_cast<OpaqueType*>(OpTy)->refineAbstractTypeTo(T);
|
2004-05-27 05:48:31 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, this is an attempt to redefine a type. That's okay if
|
|
|
|
// the redefinition is identical to the original. This will be so if
|
|
|
|
// Existing and T point to the same Type object. In this one case we
|
|
|
|
// allow the equivalent redefinition.
|
|
|
|
if (Existing == T) return true; // Yes, it's equal.
|
|
|
|
|
|
|
|
// Any other kind of (non-equivalent) redefinition is an error.
|
2007-01-06 05:50:38 +08:00
|
|
|
GenerateError("Redefinition of type named '" + Name + "' of type '" +
|
|
|
|
T->getDescription() + "'!");
|
2004-05-27 05:48:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2001-07-10 03:38:36 +08:00
|
|
|
|
2001-09-08 00:35:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Code for handling upreferences in type names...
|
2001-07-10 03:38:36 +08:00
|
|
|
//
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2004-02-09 11:19:29 +08:00
|
|
|
// TypeContains - Returns true if Ty directly contains E in it.
|
2001-09-08 00:35:17 +08:00
|
|
|
//
|
|
|
|
static bool TypeContains(const Type *Ty, const Type *E) {
|
2005-05-11 06:02:28 +08:00
|
|
|
return std::find(Ty->subtype_begin(), Ty->subtype_end(),
|
2004-12-09 00:13:53 +08:00
|
|
|
E) != Ty->subtype_end();
|
2004-02-09 11:19:29 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct UpRefRecord {
|
|
|
|
// NestingLevel - The number of nesting levels that need to be popped before
|
|
|
|
// this type is resolved.
|
|
|
|
unsigned NestingLevel;
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2004-02-09 11:19:29 +08:00
|
|
|
// LastContainedTy - This is the type at the current binding level for the
|
|
|
|
// type. Every time we reduce the nesting level, this gets updated.
|
|
|
|
const Type *LastContainedTy;
|
|
|
|
|
|
|
|
// UpRefTy - This is the actual opaque type that the upreference is
|
|
|
|
// represented with.
|
|
|
|
OpaqueType *UpRefTy;
|
|
|
|
|
|
|
|
UpRefRecord(unsigned NL, OpaqueType *URTy)
|
|
|
|
: NestingLevel(NL), LastContainedTy(URTy), UpRefTy(URTy) {}
|
|
|
|
};
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
|
|
|
|
2003-12-31 10:18:11 +08:00
|
|
|
// UpRefs - A list of the outstanding upreferences that need to be resolved.
|
2004-02-09 11:19:29 +08:00
|
|
|
static std::vector<UpRefRecord> UpRefs;
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2003-12-31 10:18:11 +08:00
|
|
|
/// HandleUpRefs - Every time we finish a new layer of types, this function is
|
|
|
|
/// called. It loops through the UpRefs vector, which is a list of the
|
|
|
|
/// currently active types. For each type, if the up reference is contained in
|
|
|
|
/// the newly completed type, we decrement the level count. When the level
|
|
|
|
/// count reaches zero, the upreferenced type is the type that is passed in:
|
|
|
|
/// thus we can complete the cycle.
|
|
|
|
///
|
2002-04-05 03:23:55 +08:00
|
|
|
static PATypeHolder HandleUpRefs(const Type *ty) {
|
2006-08-19 01:34:24 +08:00
|
|
|
// If Ty isn't abstract, or if there are no up-references in it, then there is
|
|
|
|
// nothing to resolve here.
|
|
|
|
if (!ty->isAbstract() || UpRefs.empty()) return ty;
|
|
|
|
|
2002-04-05 03:23:55 +08:00
|
|
|
PATypeHolder Ty(ty);
|
2005-05-11 06:02:28 +08:00
|
|
|
UR_OUT("Type '" << Ty->getDescription() <<
|
2001-11-02 15:46:26 +08:00
|
|
|
"' newly formed. Resolving upreferences.\n" <<
|
|
|
|
UpRefs.size() << " upreferences active!\n");
|
2004-02-10 02:53:54 +08:00
|
|
|
|
|
|
|
// If we find any resolvable upreferences (i.e., those whose NestingLevel goes
|
|
|
|
// to zero), we resolve them all together before we resolve them to Ty. At
|
|
|
|
// the end of the loop, if there is anything to resolve to Ty, it will be in
|
|
|
|
// this variable.
|
|
|
|
OpaqueType *TypeToResolve = 0;
|
|
|
|
|
2003-12-31 10:18:11 +08:00
|
|
|
for (unsigned i = 0; i != UpRefs.size(); ++i) {
|
2005-05-11 06:02:28 +08:00
|
|
|
UR_OUT(" UR#" << i << " - TypeContains(" << Ty->getDescription() << ", "
|
|
|
|
<< UpRefs[i].second->getDescription() << ") = "
|
2004-07-18 08:08:11 +08:00
|
|
|
<< (TypeContains(Ty, UpRefs[i].second) ? "true" : "false") << "\n");
|
2004-02-09 11:19:29 +08:00
|
|
|
if (TypeContains(Ty, UpRefs[i].LastContainedTy)) {
|
|
|
|
// Decrement level of upreference
|
|
|
|
unsigned Level = --UpRefs[i].NestingLevel;
|
|
|
|
UpRefs[i].LastContainedTy = Ty;
|
2003-12-31 10:18:11 +08:00
|
|
|
UR_OUT(" Uplevel Ref Level = " << Level << "\n");
|
2005-05-11 06:02:28 +08:00
|
|
|
if (Level == 0) { // Upreference should be resolved!
|
2004-02-10 02:53:54 +08:00
|
|
|
if (!TypeToResolve) {
|
|
|
|
TypeToResolve = UpRefs[i].UpRefTy;
|
|
|
|
} else {
|
|
|
|
UR_OUT(" * Resolving upreference for "
|
|
|
|
<< UpRefs[i].second->getDescription() << "\n";
|
|
|
|
std::string OldName = UpRefs[i].UpRefTy->getDescription());
|
|
|
|
UpRefs[i].UpRefTy->refineAbstractTypeTo(TypeToResolve);
|
|
|
|
UR_OUT(" * Type '" << OldName << "' refined upreference to: "
|
|
|
|
<< (const void*)Ty << ", " << Ty->getDescription() << "\n");
|
|
|
|
}
|
2004-07-18 08:08:11 +08:00
|
|
|
UpRefs.erase(UpRefs.begin()+i); // Remove from upreference list...
|
2003-12-31 10:18:11 +08:00
|
|
|
--i; // Do not skip the next element...
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
|
|
|
}
|
2001-07-10 03:38:36 +08:00
|
|
|
}
|
2003-12-31 10:18:11 +08:00
|
|
|
|
2004-02-10 02:53:54 +08:00
|
|
|
if (TypeToResolve) {
|
|
|
|
UR_OUT(" * Resolving upreference for "
|
|
|
|
<< UpRefs[i].second->getDescription() << "\n";
|
2004-02-10 05:03:38 +08:00
|
|
|
std::string OldName = TypeToResolve->getDescription());
|
2004-02-10 02:53:54 +08:00
|
|
|
TypeToResolve->refineAbstractTypeTo(Ty);
|
|
|
|
}
|
|
|
|
|
2001-07-10 03:38:36 +08:00
|
|
|
return Ty;
|
|
|
|
}
|
|
|
|
|
2005-05-20 11:25:47 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// RunVMAsmParser - Define an interface to this parser
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
static Module* RunParser(Module * M);
|
|
|
|
|
2005-05-20 11:25:47 +08:00
|
|
|
Module *llvm::RunVMAsmParser(const std::string &Filename, FILE *F) {
|
|
|
|
set_scan_file(F);
|
|
|
|
|
|
|
|
CurFilename = Filename;
|
|
|
|
return RunParser(new Module(CurFilename));
|
|
|
|
}
|
|
|
|
|
|
|
|
Module *llvm::RunVMAsmParser(const char * AsmString, Module * M) {
|
|
|
|
set_scan_string(AsmString);
|
|
|
|
|
|
|
|
CurFilename = "from_memory";
|
|
|
|
if (M == NULL) {
|
|
|
|
return RunParser(new Module (CurFilename));
|
|
|
|
} else {
|
|
|
|
return RunParser(M);
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
%}
|
|
|
|
|
|
|
|
%union {
|
2003-11-12 06:41:34 +08:00
|
|
|
llvm::Module *ModuleVal;
|
|
|
|
llvm::Function *FunctionVal;
|
|
|
|
llvm::BasicBlock *BasicBlockVal;
|
|
|
|
llvm::TerminatorInst *TermInstVal;
|
|
|
|
llvm::Instruction *InstVal;
|
2006-12-03 13:45:44 +08:00
|
|
|
llvm::Constant *ConstVal;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
const llvm::Type *PrimType;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
std::list<llvm::PATypeHolder> *TypeList;
|
2006-12-03 13:45:44 +08:00
|
|
|
llvm::PATypeHolder *TypeVal;
|
|
|
|
llvm::Value *ValueVal;
|
|
|
|
std::vector<llvm::Value*> *ValueList;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
llvm::ArgListType *ArgList;
|
|
|
|
llvm::TypeWithAttrs TypeWithAttrs;
|
|
|
|
llvm::TypeWithAttrsList *TypeWithAttrsList;
|
|
|
|
llvm::ValueRefList *ValueRefList;
|
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
// Represent the RHS of PHI node
|
2006-12-03 13:45:44 +08:00
|
|
|
std::list<std::pair<llvm::Value*,
|
|
|
|
llvm::BasicBlock*> > *PHIList;
|
2003-11-12 06:41:34 +08:00
|
|
|
std::vector<std::pair<llvm::Constant*, llvm::BasicBlock*> > *JumpTable;
|
2006-12-03 13:45:44 +08:00
|
|
|
std::vector<llvm::Constant*> *ConstVector;
|
2003-11-12 06:41:34 +08:00
|
|
|
|
|
|
|
llvm::GlobalValue::LinkageTypes Linkage;
|
2007-01-13 03:20:47 +08:00
|
|
|
llvm::GlobalValue::VisibilityTypes Visibility;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
llvm::FunctionType::ParameterAttributes ParamAttrs;
|
2001-09-08 00:35:17 +08:00
|
|
|
int64_t SInt64Val;
|
|
|
|
uint64_t UInt64Val;
|
|
|
|
int SIntVal;
|
|
|
|
unsigned UIntVal;
|
|
|
|
double FPVal;
|
2001-09-18 12:00:54 +08:00
|
|
|
bool BoolVal;
|
2001-09-08 00:35:17 +08:00
|
|
|
|
|
|
|
char *StrVal; // This memory is strdup'd!
|
2006-10-26 14:15:43 +08:00
|
|
|
llvm::ValID ValIDVal; // strdup'd memory maybe!
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
llvm::Instruction::BinaryOps BinaryOpVal;
|
|
|
|
llvm::Instruction::TermOps TermOpVal;
|
|
|
|
llvm::Instruction::MemoryOps MemOpVal;
|
|
|
|
llvm::Instruction::CastOps CastOpVal;
|
|
|
|
llvm::Instruction::OtherOps OtherOpVal;
|
2006-10-26 14:15:43 +08:00
|
|
|
llvm::Module::Endianness Endianness;
|
2006-12-03 13:45:44 +08:00
|
|
|
llvm::ICmpInst::Predicate IPredicate;
|
|
|
|
llvm::FCmpInst::Predicate FPredicate;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
%type <ModuleVal> Module
|
2002-03-27 02:01:55 +08:00
|
|
|
%type <FunctionVal> Function FunctionProto FunctionHeader BasicBlockList
|
2001-06-07 04:29:01 +08:00
|
|
|
%type <BasicBlockVal> BasicBlock InstructionList
|
|
|
|
%type <TermInstVal> BBTerminatorInst
|
|
|
|
%type <InstVal> Inst InstVal MemoryInst
|
2002-07-15 06:59:28 +08:00
|
|
|
%type <ConstVal> ConstVal ConstExpr
|
2001-11-27 00:54:11 +08:00
|
|
|
%type <ConstVector> ConstVector
|
2002-04-10 03:41:42 +08:00
|
|
|
%type <ArgList> ArgList ArgListH
|
2001-06-11 23:04:20 +08:00
|
|
|
%type <PHIList> PHIList
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
%type <ValueRefList> ValueRefList // For call param lists & GEP indices
|
|
|
|
%type <ValueList> IndexList // For GEP indices
|
|
|
|
%type <TypeList> TypeListI
|
|
|
|
%type <TypeWithAttrsList> ArgTypeList ArgTypeListI
|
2007-01-06 01:06:19 +08:00
|
|
|
%type <TypeWithAttrs> ArgType
|
2001-06-07 04:29:01 +08:00
|
|
|
%type <JumpTable> JumpTable
|
2003-04-17 04:28:45 +08:00
|
|
|
%type <BoolVal> GlobalType // GLOBAL or CONSTANT?
|
2003-09-09 02:20:29 +08:00
|
|
|
%type <BoolVal> OptVolatile // 'volatile' or not
|
2005-05-06 13:51:46 +08:00
|
|
|
%type <BoolVal> OptTailCall // TAIL CALL or plain CALL.
|
2006-01-26 06:26:43 +08:00
|
|
|
%type <BoolVal> OptSideEffect // 'sideeffect' or not.
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
%type <Linkage> GVInternalLinkage GVExternalLinkage
|
|
|
|
%type <Linkage> FunctionDefineLinkage FunctionDeclareLinkage
|
2007-01-13 03:20:47 +08:00
|
|
|
%type <Visibility> GVVisibilityStyle
|
2003-04-23 03:07:06 +08:00
|
|
|
%type <Endianness> BigOrLittle
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
// ValueRef - Unresolved reference to a definition or BB
|
|
|
|
%type <ValIDVal> ValueRef ConstValueRef SymbolicValueRef
|
2001-07-27 00:29:15 +08:00
|
|
|
%type <ValueVal> ResolvedVal // <type> <valref> pair
|
2001-06-07 04:29:01 +08:00
|
|
|
// 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
|
|
|
|
|
|
|
|
%token <SIntVal> SINTVAL // Signed 32 bit ints...
|
|
|
|
%token <UIntVal> UINTVAL // Unsigned 32 bit ints...
|
|
|
|
%type <SIntVal> INTVAL
|
2001-07-15 08:17:01 +08:00
|
|
|
%token <FPVal> FPVAL // Float or Double constant
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
// Built in types...
|
2007-01-06 01:06:19 +08:00
|
|
|
%type <TypeVal> Types ResultTypes
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
%type <PrimType> IntType FPType PrimType // Classifications
|
2007-01-13 13:00:20 +08:00
|
|
|
%token <PrimType> VOID INTTYPE
|
2006-12-30 04:29:48 +08:00
|
|
|
%token <PrimType> FLOAT DOUBLE LABEL
|
|
|
|
%token TYPE
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2003-08-22 13:42:10 +08:00
|
|
|
%token <StrVal> VAR_ID LABELSTR STRINGCONSTANT
|
|
|
|
%type <StrVal> Name OptName OptAssign
|
2005-11-06 14:46:28 +08:00
|
|
|
%type <UIntVal> OptAlign OptCAlign
|
2005-11-13 02:21:21 +08:00
|
|
|
%type <StrVal> OptSection SectionString
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2004-03-31 11:49:47 +08:00
|
|
|
%token IMPLEMENTATION ZEROINITIALIZER TRUETOK FALSETOK BEGINTOK ENDTOK
|
2006-12-30 04:29:48 +08:00
|
|
|
%token DECLARE DEFINE GLOBAL CONSTANT SECTION VOLATILE
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
%token TO DOTDOTDOT NULL_TOK UNDEF INTERNAL LINKONCE WEAK APPENDING
|
2006-09-15 02:23:27 +08:00
|
|
|
%token DLLIMPORT DLLEXPORT EXTERN_WEAK
|
2007-01-13 02:32:39 +08:00
|
|
|
%token OPAQUE EXTERNAL TARGET TRIPLE ENDIAN POINTERSIZE LITTLE BIG ALIGN
|
2006-01-26 06:26:43 +08:00
|
|
|
%token DEPLIBS CALL TAIL ASM_TOK MODULE SIDEEFFECT
|
2006-05-20 05:28:34 +08:00
|
|
|
%token CC_TOK CCC_TOK CSRETCC_TOK FASTCC_TOK COLDCC_TOK
|
2006-09-18 04:25:45 +08:00
|
|
|
%token X86_STDCALLCC_TOK X86_FASTCALLCC_TOK
|
2006-10-22 14:07:41 +08:00
|
|
|
%token DATALAYOUT
|
2005-05-07 04:27:19 +08:00
|
|
|
%type <UIntVal> OptCallingConv
|
2007-01-06 01:06:19 +08:00
|
|
|
%type <ParamAttrs> OptParamAttrs ParamAttr
|
|
|
|
%type <ParamAttrs> OptFuncAttrs FuncAttr
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
// Basic Block Terminating Operators
|
2004-10-17 02:17:13 +08:00
|
|
|
%token <TermOpVal> RET BR SWITCH INVOKE UNWIND UNREACHABLE
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
// Binary Operators
|
2006-12-23 14:05:41 +08:00
|
|
|
%type <BinaryOpVal> ArithmeticOps LogicalOps // Binops Subcatagories
|
2006-11-02 09:53:59 +08:00
|
|
|
%token <BinaryOpVal> ADD SUB MUL UDIV SDIV FDIV UREM SREM FREM AND OR XOR
|
2006-12-03 13:45:44 +08:00
|
|
|
%token <OtherOpVal> ICMP FCMP
|
|
|
|
%type <IPredicate> IPredicates
|
|
|
|
%type <FPredicate> FPredicates
|
2006-12-03 14:58:07 +08:00
|
|
|
%token EQ NE SLT SGT SLE SGE ULT UGT ULE UGE
|
|
|
|
%token OEQ ONE OLT OGT OLE OGE ORD UNO UEQ UNE
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
// Memory Instructions
|
2002-07-15 06:59:28 +08:00
|
|
|
%token <MemOpVal> MALLOC ALLOCA FREE LOAD STORE GETELEMENTPTR
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-11-27 09:05:10 +08:00
|
|
|
// Cast Operators
|
|
|
|
%type <CastOpVal> CastOps
|
|
|
|
%token <CastOpVal> TRUNC ZEXT SEXT FPTRUNC FPEXT BITCAST
|
|
|
|
%token <CastOpVal> UITOFP SITOFP FPTOUI FPTOSI INTTOPTR PTRTOINT
|
|
|
|
|
2001-07-09 05:10:27 +08:00
|
|
|
// Other Operators
|
|
|
|
%type <OtherOpVal> ShiftOps
|
2006-11-27 09:05:10 +08:00
|
|
|
%token <OtherOpVal> PHI_TOK SELECT SHL LSHR ASHR VAARG
|
2006-04-08 09:18:35 +08:00
|
|
|
%token <OtherOpVal> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
|
2005-05-06 13:51:46 +08:00
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
// Function Attributes
|
|
|
|
%token NORETURN
|
2001-07-09 05:10:27 +08:00
|
|
|
|
2007-01-13 03:20:47 +08:00
|
|
|
// Visibility Styles
|
|
|
|
%token DEFAULT HIDDEN
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
%start Module
|
|
|
|
%%
|
|
|
|
|
|
|
|
// Handle constant integer size restriction and conversion...
|
|
|
|
//
|
2002-06-05 05:58:56 +08:00
|
|
|
INTVAL : SINTVAL;
|
2001-06-07 04:29:01 +08:00
|
|
|
INTVAL : UINTVAL {
|
|
|
|
if ($1 > (uint32_t)INT32_MAX) // Outside of my range!
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Value too large for type!");
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = (int32_t)$1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2005-05-11 06:02:28 +08:00
|
|
|
// Operations that are notably excluded from this list include:
|
2001-06-07 04:29:01 +08:00
|
|
|
// RET, BR, & SWITCH because they end basic blocks and are treated specially.
|
|
|
|
//
|
2006-11-02 09:53:59 +08:00
|
|
|
ArithmeticOps: ADD | SUB | MUL | UDIV | SDIV | FDIV | UREM | SREM | FREM;
|
2002-09-11 03:57:26 +08:00
|
|
|
LogicalOps : AND | OR | XOR;
|
2006-11-27 09:05:10 +08:00
|
|
|
CastOps : TRUNC | ZEXT | SEXT | FPTRUNC | FPEXT | BITCAST |
|
|
|
|
UITOFP | SITOFP | FPTOUI | FPTOSI | INTTOPTR | PTRTOINT;
|
|
|
|
ShiftOps : SHL | LSHR | ASHR;
|
2006-12-03 14:58:07 +08:00
|
|
|
IPredicates
|
2006-12-04 13:20:06 +08:00
|
|
|
: EQ { $$ = ICmpInst::ICMP_EQ; } | NE { $$ = ICmpInst::ICMP_NE; }
|
2006-12-03 14:58:07 +08:00
|
|
|
| SLT { $$ = ICmpInst::ICMP_SLT; } | SGT { $$ = ICmpInst::ICMP_SGT; }
|
|
|
|
| SLE { $$ = ICmpInst::ICMP_SLE; } | SGE { $$ = ICmpInst::ICMP_SGE; }
|
|
|
|
| ULT { $$ = ICmpInst::ICMP_ULT; } | UGT { $$ = ICmpInst::ICMP_UGT; }
|
|
|
|
| ULE { $$ = ICmpInst::ICMP_ULE; } | UGE { $$ = ICmpInst::ICMP_UGE; }
|
|
|
|
;
|
|
|
|
|
|
|
|
FPredicates
|
|
|
|
: OEQ { $$ = FCmpInst::FCMP_OEQ; } | ONE { $$ = FCmpInst::FCMP_ONE; }
|
|
|
|
| OLT { $$ = FCmpInst::FCMP_OLT; } | OGT { $$ = FCmpInst::FCMP_OGT; }
|
|
|
|
| OLE { $$ = FCmpInst::FCMP_OLE; } | OGE { $$ = FCmpInst::FCMP_OGE; }
|
|
|
|
| ORD { $$ = FCmpInst::FCMP_ORD; } | UNO { $$ = FCmpInst::FCMP_UNO; }
|
|
|
|
| UEQ { $$ = FCmpInst::FCMP_UEQ; } | UNE { $$ = FCmpInst::FCMP_UNE; }
|
|
|
|
| ULT { $$ = FCmpInst::FCMP_ULT; } | UGT { $$ = FCmpInst::FCMP_UGT; }
|
|
|
|
| ULE { $$ = FCmpInst::FCMP_ULE; } | UGE { $$ = FCmpInst::FCMP_UGE; }
|
|
|
|
| TRUETOK { $$ = FCmpInst::FCMP_TRUE; }
|
|
|
|
| FALSETOK { $$ = FCmpInst::FCMP_FALSE; }
|
|
|
|
;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-07-14 14:10:16 +08:00
|
|
|
// These are some types that allow classification if we only want a particular
|
|
|
|
// thing... for example, only a signed, unsigned, or integral type.
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
IntType : INTTYPE;
|
2002-06-05 05:58:56 +08:00
|
|
|
FPType : FLOAT | DOUBLE;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-07-14 14:10:16 +08:00
|
|
|
// OptAssign - Value producing statements have an optional assignment component
|
2003-08-22 13:42:10 +08:00
|
|
|
OptAssign : Name '=' {
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2005-05-11 06:02:28 +08:00
|
|
|
| /*empty*/ {
|
|
|
|
$$ = 0;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-12-30 04:29:48 +08:00
|
|
|
GVInternalLinkage
|
|
|
|
: INTERNAL { $$ = GlobalValue::InternalLinkage; }
|
|
|
|
| WEAK { $$ = GlobalValue::WeakLinkage; }
|
|
|
|
| LINKONCE { $$ = GlobalValue::LinkOnceLinkage; }
|
|
|
|
| APPENDING { $$ = GlobalValue::AppendingLinkage; }
|
|
|
|
| DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; }
|
|
|
|
;
|
|
|
|
|
|
|
|
GVExternalLinkage
|
|
|
|
: DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; }
|
|
|
|
| EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; }
|
|
|
|
| EXTERNAL { $$ = GlobalValue::ExternalLinkage; }
|
|
|
|
;
|
|
|
|
|
2007-01-13 03:20:47 +08:00
|
|
|
GVVisibilityStyle
|
|
|
|
: /*empty*/ { $$ = GlobalValue::DefaultVisibility; }
|
|
|
|
| HIDDEN { $$ = GlobalValue::HiddenVisibility; }
|
|
|
|
;
|
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
FunctionDeclareLinkage
|
|
|
|
: /*empty*/ { $$ = GlobalValue::ExternalLinkage; }
|
|
|
|
| DLLIMPORT { $$ = GlobalValue::DLLImportLinkage; }
|
|
|
|
| EXTERN_WEAK { $$ = GlobalValue::ExternalWeakLinkage; }
|
2006-12-30 04:29:48 +08:00
|
|
|
;
|
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
FunctionDefineLinkage
|
|
|
|
: /*empty*/ { $$ = GlobalValue::ExternalLinkage; }
|
|
|
|
| INTERNAL { $$ = GlobalValue::InternalLinkage; }
|
2006-12-30 04:29:48 +08:00
|
|
|
| LINKONCE { $$ = GlobalValue::LinkOnceLinkage; }
|
|
|
|
| WEAK { $$ = GlobalValue::WeakLinkage; }
|
|
|
|
| DLLEXPORT { $$ = GlobalValue::DLLExportLinkage; }
|
|
|
|
;
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2006-09-18 04:25:45 +08:00
|
|
|
OptCallingConv : /*empty*/ { $$ = CallingConv::C; } |
|
|
|
|
CCC_TOK { $$ = CallingConv::C; } |
|
|
|
|
CSRETCC_TOK { $$ = CallingConv::CSRet; } |
|
|
|
|
FASTCC_TOK { $$ = CallingConv::Fast; } |
|
|
|
|
COLDCC_TOK { $$ = CallingConv::Cold; } |
|
|
|
|
X86_STDCALLCC_TOK { $$ = CallingConv::X86_StdCall; } |
|
|
|
|
X86_FASTCALLCC_TOK { $$ = CallingConv::X86_FastCall; } |
|
|
|
|
CC_TOK EUINT64VAL {
|
2005-05-07 04:27:19 +08:00
|
|
|
if ((unsigned)$2 != $2)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Calling conv too large!");
|
2005-05-07 04:27:19 +08:00
|
|
|
$$ = $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-05-07 04:27:19 +08:00
|
|
|
};
|
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ParamAttr : ZEXT { $$ = FunctionType::ZExtAttribute; }
|
|
|
|
| SEXT { $$ = FunctionType::SExtAttribute; }
|
|
|
|
;
|
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
OptParamAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; }
|
|
|
|
| OptParamAttrs ParamAttr {
|
|
|
|
$$ = FunctionType::ParameterAttributes($1 | $2);
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
FuncAttr : NORETURN { $$ = FunctionType::NoReturnAttribute; }
|
|
|
|
| ParamAttr
|
|
|
|
;
|
|
|
|
|
|
|
|
OptFuncAttrs : /* empty */ { $$ = FunctionType::NoAttributeSet; }
|
|
|
|
| OptFuncAttrs FuncAttr {
|
|
|
|
$$ = FunctionType::ParameterAttributes($1 | $2);
|
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
;
|
|
|
|
|
2005-11-06 14:34:12 +08:00
|
|
|
// OptAlign/OptCAlign - An optional alignment, and an optional alignment with
|
|
|
|
// a comma before it.
|
2005-11-06 14:46:28 +08:00
|
|
|
OptAlign : /*empty*/ { $$ = 0; } |
|
2005-11-13 02:21:21 +08:00
|
|
|
ALIGN EUINT64VAL {
|
|
|
|
$$ = $2;
|
|
|
|
if ($$ != 0 && !isPowerOf2_32($$))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Alignment must be a power of two!");
|
|
|
|
CHECK_FOR_ERROR
|
2005-11-13 02:21:21 +08:00
|
|
|
};
|
2005-11-06 14:34:12 +08:00
|
|
|
OptCAlign : /*empty*/ { $$ = 0; } |
|
2005-11-13 02:21:21 +08:00
|
|
|
',' ALIGN EUINT64VAL {
|
|
|
|
$$ = $3;
|
|
|
|
if ($$ != 0 && !isPowerOf2_32($$))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Alignment must be a power of two!");
|
|
|
|
CHECK_FOR_ERROR
|
2005-11-13 02:21:21 +08:00
|
|
|
};
|
|
|
|
|
2005-11-06 14:34:12 +08:00
|
|
|
|
2005-11-12 08:11:10 +08:00
|
|
|
SectionString : SECTION STRINGCONSTANT {
|
|
|
|
for (unsigned i = 0, e = strlen($2); i != e; ++i)
|
|
|
|
if ($2[i] == '"' || $2[i] == '\\')
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid character in section name!");
|
2005-11-12 08:11:10 +08:00
|
|
|
$$ = $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-11-12 08:11:10 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
OptSection : /*empty*/ { $$ = 0; } |
|
|
|
|
SectionString { $$ = $1; };
|
|
|
|
|
2005-11-13 02:21:21 +08:00
|
|
|
// GlobalVarAttributes - Used to pass the attributes string on a global. CurGV
|
|
|
|
// is set to be the global we are processing.
|
|
|
|
//
|
|
|
|
GlobalVarAttributes : /* empty */ {} |
|
|
|
|
',' GlobalVarAttribute GlobalVarAttributes {};
|
|
|
|
GlobalVarAttribute : SectionString {
|
|
|
|
CurGV->setSection($1);
|
|
|
|
free($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-11-13 02:21:21 +08:00
|
|
|
}
|
|
|
|
| ALIGN EUINT64VAL {
|
|
|
|
if ($2 != 0 && !isPowerOf2_32($2))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Alignment must be a power of two!");
|
2005-11-13 02:21:21 +08:00
|
|
|
CurGV->setAlignment($2);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-11-13 02:21:21 +08:00
|
|
|
};
|
2005-11-12 08:11:10 +08:00
|
|
|
|
2001-09-08 00:35:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Types includes all predefined types... except void, because it can only be
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
// used in specific contexts (function returning void for example).
|
2001-09-08 00:35:17 +08:00
|
|
|
|
|
|
|
// Derived types are added later...
|
2001-07-27 00:29:15 +08:00
|
|
|
//
|
2007-01-13 13:00:20 +08:00
|
|
|
PrimType : INTTYPE | FLOAT | DOUBLE | LABEL ;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
|
|
|
|
Types
|
|
|
|
: OPAQUE {
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new PATypeHolder(OpaqueType::get());
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-04-05 03:23:55 +08:00
|
|
|
}
|
|
|
|
| PrimType {
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new PATypeHolder($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
|
|
|
| Types '*' { // Pointer type?
|
|
|
|
if (*$1 == Type::LabelTy)
|
|
|
|
GEN_ERROR("Cannot form a pointer to a basic block");
|
|
|
|
$$ = new PATypeHolder(HandleUpRefs(PointerType::get(*$1)));
|
|
|
|
delete $1;
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
|
|
|
| SymbolicValueRef { // Named types are also simple types...
|
|
|
|
const Type* tmp = getTypeVal($1);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
$$ = new PATypeHolder(tmp);
|
|
|
|
}
|
|
|
|
| '\\' EUINT64VAL { // Type UpReference
|
2006-08-18 16:43:06 +08:00
|
|
|
if ($2 > (uint64_t)~0U) GEN_ERROR("Value out of range!");
|
2001-09-08 00:35:17 +08:00
|
|
|
OpaqueType *OT = OpaqueType::get(); // Use temporary placeholder
|
2004-02-09 11:19:29 +08:00
|
|
|
UpRefs.push_back(UpRefRecord((unsigned)$2, OT)); // Add to vector...
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new PATypeHolder(OT);
|
2001-09-08 00:35:17 +08:00
|
|
|
UR_OUT("New Upreference!\n");
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
2007-01-06 01:06:19 +08:00
|
|
|
| Types '(' ArgTypeListI ')' OptFuncAttrs {
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<const Type*> Params;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
std::vector<FunctionType::ParameterAttributes> Attrs;
|
2007-01-06 01:06:19 +08:00
|
|
|
Attrs.push_back($5);
|
|
|
|
for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
Params.push_back(I->Ty->get());
|
|
|
|
if (I->Ty->get() != Type::VoidTy)
|
|
|
|
Attrs.push_back(I->Attrs);
|
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
|
|
|
|
if (isVarArg) Params.pop_back();
|
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
FunctionType *FT = FunctionType::get(*$1, Params, isVarArg, Attrs);
|
2007-01-13 03:20:47 +08:00
|
|
|
delete $3; // Delete the argument list
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
delete $1; // Delete the return type handle
|
|
|
|
$$ = new PATypeHolder(HandleUpRefs(FT));
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
2007-01-06 01:06:19 +08:00
|
|
|
| VOID '(' ArgTypeListI ')' OptFuncAttrs {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
std::vector<const Type*> Params;
|
|
|
|
std::vector<FunctionType::ParameterAttributes> Attrs;
|
2007-01-06 01:06:19 +08:00
|
|
|
Attrs.push_back($5);
|
|
|
|
for (TypeWithAttrsList::iterator I=$3->begin(), E=$3->end(); I != E; ++I) {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
Params.push_back(I->Ty->get());
|
|
|
|
if (I->Ty->get() != Type::VoidTy)
|
|
|
|
Attrs.push_back(I->Attrs);
|
|
|
|
}
|
|
|
|
bool isVarArg = Params.size() && Params.back() == Type::VoidTy;
|
|
|
|
if (isVarArg) Params.pop_back();
|
|
|
|
|
|
|
|
FunctionType *FT = FunctionType::get($1, Params, isVarArg, Attrs);
|
2007-01-06 01:06:19 +08:00
|
|
|
delete $3; // Delete the argument list
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
$$ = new PATypeHolder(HandleUpRefs(FT));
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
|
|
|
|
|
|
|
| '[' EUINT64VAL 'x' Types ']' { // Sized array type?
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new PATypeHolder(HandleUpRefs(ArrayType::get(*$4, (unsigned)$2)));
|
|
|
|
delete $4;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| '<' EUINT64VAL 'x' Types '>' { // Packed array type?
|
2006-12-03 13:45:44 +08:00
|
|
|
const llvm::Type* ElemTy = $4->get();
|
|
|
|
if ((unsigned)$2 != $2)
|
|
|
|
GEN_ERROR("Unsigned result not equal to signed result");
|
2007-01-15 10:27:26 +08:00
|
|
|
if (!ElemTy->isFloatingPoint() && !ElemTy->isInteger())
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
GEN_ERROR("Element type of a PackedType must be primitive");
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isPowerOf2_32($2))
|
|
|
|
GEN_ERROR("Vector length should be a power of 2!");
|
|
|
|
$$ = new PATypeHolder(HandleUpRefs(PackedType::get(*$4, (unsigned)$2)));
|
|
|
|
delete $4;
|
|
|
|
CHECK_FOR_ERROR
|
2004-08-20 14:00:58 +08:00
|
|
|
}
|
2001-10-03 11:19:33 +08:00
|
|
|
| '{' TypeListI '}' { // Structure type?
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<const Type*> Elements;
|
2006-12-03 13:45:44 +08:00
|
|
|
for (std::list<llvm::PATypeHolder>::iterator I = $2->begin(),
|
2005-02-23 07:13:58 +08:00
|
|
|
E = $2->end(); I != E; ++I)
|
2006-12-03 13:45:44 +08:00
|
|
|
Elements.push_back(*I);
|
2005-05-11 06:02:28 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements)));
|
2001-10-03 11:19:33 +08:00
|
|
|
delete $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-10-03 11:19:33 +08:00
|
|
|
}
|
|
|
|
| '{' '}' { // Empty structure type?
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new PATypeHolder(StructType::get(std::vector<const Type*>()));
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-10-03 11:19:33 +08:00
|
|
|
}
|
2006-12-09 02:06:16 +08:00
|
|
|
| '<' '{' TypeListI '}' '>' {
|
|
|
|
std::vector<const Type*> Elements;
|
|
|
|
for (std::list<llvm::PATypeHolder>::iterator I = $3->begin(),
|
|
|
|
E = $3->end(); I != E; ++I)
|
|
|
|
Elements.push_back(*I);
|
|
|
|
|
|
|
|
$$ = new PATypeHolder(HandleUpRefs(StructType::get(Elements, true)));
|
|
|
|
delete $3;
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
|
|
|
| '<' '{' '}' '>' { // Empty structure type?
|
|
|
|
$$ = new PATypeHolder(StructType::get(std::vector<const Type*>(), true));
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
;
|
2001-09-08 00:35:17 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ArgType
|
|
|
|
: Types OptParamAttrs {
|
|
|
|
$$.Ty = $1;
|
|
|
|
$$.Attrs = $2;
|
|
|
|
}
|
|
|
|
;
|
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
ResultTypes
|
|
|
|
: Types {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
|
|
|
if (!(*$1)->isFirstClassType())
|
|
|
|
GEN_ERROR("LLVM functions cannot return aggregate types!");
|
2007-01-06 01:06:19 +08:00
|
|
|
$$ = $1;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
2007-01-06 01:06:19 +08:00
|
|
|
| VOID {
|
|
|
|
$$ = new PATypeHolder(Type::VoidTy);
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
|
|
|
;
|
|
|
|
|
|
|
|
ArgTypeList : ArgType {
|
|
|
|
$$ = new TypeWithAttrsList();
|
|
|
|
$$->push_back($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| ArgTypeList ',' ArgType {
|
|
|
|
($$=$1)->push_back($3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
|
|
|
;
|
2001-09-08 00:35:17 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ArgTypeListI
|
|
|
|
: ArgTypeList
|
|
|
|
| ArgTypeList ',' DOTDOTDOT {
|
|
|
|
$$=$1;
|
|
|
|
TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
|
|
|
|
TWA.Ty = new PATypeHolder(Type::VoidTy);
|
|
|
|
$$->push_back(TWA);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
|
|
|
| DOTDOTDOT {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
$$ = new TypeWithAttrsList;
|
|
|
|
TypeWithAttrs TWA; TWA.Attrs = FunctionType::NoAttributeSet;
|
|
|
|
TWA.Ty = new PATypeHolder(Type::VoidTy);
|
|
|
|
$$->push_back(TWA);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
|
|
|
| /*empty*/ {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
$$ = new TypeWithAttrsList();
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
};
|
|
|
|
|
|
|
|
// TypeList - Used for struct declarations and as a basis for function type
|
|
|
|
// declaration type lists
|
|
|
|
//
|
|
|
|
TypeListI : Types {
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new std::list<PATypeHolder>();
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
$$->push_back(*$1); delete $1;
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
|
|
|
| TypeListI ',' Types {
|
|
|
|
($$=$1)->push_back(*$3); delete $3;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-09-08 00:35:17 +08:00
|
|
|
|
|
|
|
// ConstVal - The various declarations that go into the constant pool. This
|
2002-08-17 05:14:40 +08:00
|
|
|
// production is used ONLY to represent constants that show up AFTER a 'const',
|
|
|
|
// 'constant' or 'global' token at global scope. Constants that can be inlined
|
|
|
|
// into other expressions (such as integers and constexprs) are handled by the
|
|
|
|
// ResolvedVal, ValueRef and ConstValueRef productions.
|
2001-09-08 00:35:17 +08:00
|
|
|
//
|
2001-10-03 11:19:33 +08:00
|
|
|
ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const ArrayType *ATy = dyn_cast<ArrayType>($1->get());
|
2001-10-03 11:19:33 +08:00
|
|
|
if (ATy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make array constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2001-09-08 00:35:17 +08:00
|
|
|
const Type *ETy = ATy->getElementType();
|
|
|
|
int NumElements = ATy->getNumElements();
|
|
|
|
|
|
|
|
// Verify that we have the correct size...
|
|
|
|
if (NumElements != -1 && NumElements != (int)$3->size())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Type mismatch: constant sized array initialized with " +
|
2004-07-18 08:08:11 +08:00
|
|
|
utostr($3->size()) + " arguments, but has size of " +
|
|
|
|
itostr(NumElements) + "!");
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-09-08 00:35:17 +08:00
|
|
|
// Verify all elements are correct type!
|
|
|
|
for (unsigned i = 0; i < $3->size(); i++) {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (ETy != (*$3)[i]->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
|
2004-07-18 08:08:11 +08:00
|
|
|
ETy->getDescription() +"' as required!\nIt is of type '"+
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$3)[i]->getType()->getDescription() + "'.");
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantArray::get(ATy, *$3);
|
|
|
|
delete $1; delete $3;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-10-03 11:19:33 +08:00
|
|
|
| Types '[' ']' {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const ArrayType *ATy = dyn_cast<ArrayType>($1->get());
|
2001-10-03 11:19:33 +08:00
|
|
|
if (ATy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make array constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2001-10-03 11:19:33 +08:00
|
|
|
|
|
|
|
int NumElements = ATy->getNumElements();
|
2001-09-08 00:35:17 +08:00
|
|
|
if (NumElements != -1 && NumElements != 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Type mismatch: constant sized array initialized with 0"
|
2004-07-18 08:08:11 +08:00
|
|
|
" arguments, but has size of " + itostr(NumElements) +"!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantArray::get(ATy, std::vector<Constant*>());
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
2001-10-03 11:19:33 +08:00
|
|
|
| Types 'c' STRINGCONSTANT {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const ArrayType *ATy = dyn_cast<ArrayType>($1->get());
|
2001-10-03 11:19:33 +08:00
|
|
|
if (ATy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make array constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2001-10-03 11:19:33 +08:00
|
|
|
|
2001-09-08 00:35:17 +08:00
|
|
|
int NumElements = ATy->getNumElements();
|
|
|
|
const Type *ETy = ATy->getElementType();
|
|
|
|
char *EndStr = UnEscapeLexed($3, true);
|
|
|
|
if (NumElements != -1 && NumElements != (EndStr-$3))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Can't build string constant of size " +
|
2004-07-18 08:08:11 +08:00
|
|
|
itostr((int)(EndStr-$3)) +
|
|
|
|
" when array has size " + itostr(NumElements) + "!");
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<Constant*> Vals;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (ETy == Type::Int8Ty) {
|
2006-01-24 07:05:15 +08:00
|
|
|
for (unsigned char *C = (unsigned char *)$3;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
C != (unsigned char*)EndStr; ++C)
|
|
|
|
Vals.push_back(ConstantInt::get(ETy, *C));
|
2001-07-29 01:48:55 +08:00
|
|
|
} else {
|
2001-09-08 00:35:17 +08:00
|
|
|
free($3);
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot build string arrays of non byte sized elements!");
|
2001-07-29 01:48:55 +08:00
|
|
|
}
|
2001-09-08 00:35:17 +08:00
|
|
|
free($3);
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantArray::get(ATy, Vals);
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2004-08-20 14:00:58 +08:00
|
|
|
| Types '<' ConstVector '>' { // Nonempty unsized arr
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const PackedType *PTy = dyn_cast<PackedType>($1->get());
|
2004-08-20 14:00:58 +08:00
|
|
|
if (PTy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make packed constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2004-08-20 14:00:58 +08:00
|
|
|
const Type *ETy = PTy->getElementType();
|
|
|
|
int NumElements = PTy->getNumElements();
|
|
|
|
|
|
|
|
// Verify that we have the correct size...
|
|
|
|
if (NumElements != -1 && NumElements != (int)$3->size())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Type mismatch: constant sized packed initialized with " +
|
2004-08-20 14:00:58 +08:00
|
|
|
utostr($3->size()) + " arguments, but has size of " +
|
|
|
|
itostr(NumElements) + "!");
|
|
|
|
|
|
|
|
// Verify all elements are correct type!
|
|
|
|
for (unsigned i = 0; i < $3->size(); i++) {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (ETy != (*$3)[i]->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
|
2004-08-20 14:00:58 +08:00
|
|
|
ETy->getDescription() +"' as required!\nIt is of type '"+
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$3)[i]->getType()->getDescription() + "'.");
|
2004-08-20 14:00:58 +08:00
|
|
|
}
|
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantPacked::get(PTy, *$3);
|
|
|
|
delete $1; delete $3;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-08-20 14:00:58 +08:00
|
|
|
}
|
2001-10-03 11:19:33 +08:00
|
|
|
| Types '{' ConstVector '}' {
|
2006-12-03 13:45:44 +08:00
|
|
|
const StructType *STy = dyn_cast<StructType>($1->get());
|
2001-10-03 11:19:33 +08:00
|
|
|
if (STy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make struct constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2003-04-16 00:09:31 +08:00
|
|
|
|
2003-05-22 00:06:56 +08:00
|
|
|
if ($3->size() != STy->getNumContainedTypes())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Illegal number of initializers for structure type!");
|
2003-05-22 00:06:56 +08:00
|
|
|
|
2003-04-16 00:09:31 +08:00
|
|
|
// Check to ensure that constants are compatible with the type initializer!
|
|
|
|
for (unsigned i = 0, e = $3->size(); i != e; ++i)
|
2006-12-03 13:45:44 +08:00
|
|
|
if ((*$3)[i]->getType() != STy->getElementType(i))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Expected type '" +
|
2004-02-09 12:37:31 +08:00
|
|
|
STy->getElementType(i)->getDescription() +
|
2003-04-16 00:09:31 +08:00
|
|
|
"' for element #" + utostr(i) +
|
|
|
|
" of structure initializer!");
|
|
|
|
|
2007-01-09 02:16:47 +08:00
|
|
|
// Check to ensure that Type is not packed
|
|
|
|
if (STy->isPacked())
|
|
|
|
GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'");
|
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantStruct::get(STy, *$3);
|
|
|
|
delete $1; delete $3;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2003-05-22 00:06:56 +08:00
|
|
|
| Types '{' '}' {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const StructType *STy = dyn_cast<StructType>($1->get());
|
2003-05-22 00:06:56 +08:00
|
|
|
if (STy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make struct constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2003-05-22 00:06:56 +08:00
|
|
|
|
|
|
|
if (STy->getNumContainedTypes() != 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Illegal number of initializers for structure type!");
|
2003-05-22 00:06:56 +08:00
|
|
|
|
2007-01-09 02:16:47 +08:00
|
|
|
// Check to ensure that Type is not packed
|
|
|
|
if (STy->isPacked())
|
|
|
|
GEN_ERROR("Unpacked Initializer to packed type '" + STy->getDescription() + "'");
|
|
|
|
|
|
|
|
$$ = ConstantStruct::get(STy, std::vector<Constant*>());
|
|
|
|
delete $1;
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
|
|
|
| Types '<' '{' ConstVector '}' '>' {
|
|
|
|
const StructType *STy = dyn_cast<StructType>($1->get());
|
|
|
|
if (STy == 0)
|
|
|
|
GEN_ERROR("Cannot make struct constant with type: '" +
|
|
|
|
(*$1)->getDescription() + "'!");
|
|
|
|
|
|
|
|
if ($4->size() != STy->getNumContainedTypes())
|
|
|
|
GEN_ERROR("Illegal number of initializers for structure type!");
|
|
|
|
|
|
|
|
// Check to ensure that constants are compatible with the type initializer!
|
|
|
|
for (unsigned i = 0, e = $4->size(); i != e; ++i)
|
|
|
|
if ((*$4)[i]->getType() != STy->getElementType(i))
|
|
|
|
GEN_ERROR("Expected type '" +
|
|
|
|
STy->getElementType(i)->getDescription() +
|
|
|
|
"' for element #" + utostr(i) +
|
|
|
|
" of structure initializer!");
|
|
|
|
|
|
|
|
// Check to ensure that Type is packed
|
|
|
|
if (!STy->isPacked())
|
|
|
|
GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
|
|
|
|
|
|
|
|
$$ = ConstantStruct::get(STy, *$4);
|
|
|
|
delete $1; delete $4;
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
|
|
|
| Types '<' '{' '}' '>' {
|
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
|
|
|
const StructType *STy = dyn_cast<StructType>($1->get());
|
|
|
|
if (STy == 0)
|
|
|
|
GEN_ERROR("Cannot make struct constant with type: '" +
|
|
|
|
(*$1)->getDescription() + "'!");
|
|
|
|
|
|
|
|
if (STy->getNumContainedTypes() != 0)
|
|
|
|
GEN_ERROR("Illegal number of initializers for structure type!");
|
|
|
|
|
|
|
|
// Check to ensure that Type is packed
|
|
|
|
if (!STy->isPacked())
|
|
|
|
GEN_ERROR("Packed Initializer to unpacked type '" + STy->getDescription() + "'");
|
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantStruct::get(STy, std::vector<Constant*>());
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-05-22 00:06:56 +08:00
|
|
|
}
|
2001-10-03 11:19:33 +08:00
|
|
|
| Types NULL_TOK {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const PointerType *PTy = dyn_cast<PointerType>($1->get());
|
2001-10-03 11:19:33 +08:00
|
|
|
if (PTy == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot make null pointer constant with type: '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$1)->getDescription() + "'!");
|
2001-10-03 11:19:33 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantPointerNull::get(PTy);
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-10-03 09:49:25 +08:00
|
|
|
}
|
2004-10-17 02:17:13 +08:00
|
|
|
| Types UNDEF {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = UndefValue::get($1->get());
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-10-17 02:17:13 +08:00
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
| Types SymbolicValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const PointerType *Ty = dyn_cast<PointerType>($1->get());
|
2001-10-03 14:12:09 +08:00
|
|
|
if (Ty == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Global const reference must be a pointer type!");
|
2001-10-03 14:12:09 +08:00
|
|
|
|
2002-08-16 01:58:33 +08:00
|
|
|
// ConstExprs can exist in the body of a function, thus creating
|
2004-07-18 08:08:11 +08:00
|
|
|
// GlobalValues whenever they refer to a variable. Because we are in
|
2002-08-16 01:58:33 +08:00
|
|
|
// the context of a function, getValNonImprovising will search the functions
|
|
|
|
// symbol table instead of the module symbol table for the global symbol,
|
|
|
|
// which throws things all off. To get around this, we just tell
|
|
|
|
// getValNonImprovising that we are at global scope here.
|
|
|
|
//
|
2003-10-17 04:12:13 +08:00
|
|
|
Function *SavedCurFn = CurFun.CurrentFunction;
|
|
|
|
CurFun.CurrentFunction = 0;
|
2002-08-16 01:58:33 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
Value *V = getValNonImprovising(Ty, $2);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-10-03 14:12:09 +08:00
|
|
|
|
2003-10-17 04:12:13 +08:00
|
|
|
CurFun.CurrentFunction = SavedCurFn;
|
2002-08-16 01:58:33 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
// If this is an initializer for a constant pointer, which is referencing a
|
|
|
|
// (currently) undefined variable, create a stub now that shall be replaced
|
|
|
|
// in the future with the right type of variable.
|
|
|
|
//
|
|
|
|
if (V == 0) {
|
|
|
|
assert(isa<PointerType>(Ty) && "Globals may only be used as pointers!");
|
|
|
|
const PointerType *PT = cast<PointerType>(Ty);
|
|
|
|
|
|
|
|
// First check to see if the forward references value is already created!
|
|
|
|
PerModuleInfo::GlobalRefsType::iterator I =
|
2004-07-18 08:08:11 +08:00
|
|
|
CurModule.GlobalRefs.find(std::make_pair(PT, $2));
|
2001-10-13 14:41:08 +08:00
|
|
|
|
|
|
|
if (I != CurModule.GlobalRefs.end()) {
|
2004-07-18 08:08:11 +08:00
|
|
|
V = I->second; // Placeholder already exists, use it...
|
2003-12-24 04:05:15 +08:00
|
|
|
$2.destroy();
|
2001-10-13 14:41:08 +08:00
|
|
|
} else {
|
2004-07-15 05:44:00 +08:00
|
|
|
std::string Name;
|
2004-07-15 07:03:46 +08:00
|
|
|
if ($2.Type == ValID::NameVal) Name = $2.Name;
|
|
|
|
|
2004-07-18 08:08:11 +08:00
|
|
|
// Create the forward referenced global.
|
2004-07-15 07:03:46 +08:00
|
|
|
GlobalValue *GV;
|
|
|
|
if (const FunctionType *FTy =
|
|
|
|
dyn_cast<FunctionType>(PT->getElementType())) {
|
|
|
|
GV = new Function(FTy, GlobalValue::ExternalLinkage, Name,
|
|
|
|
CurModule.CurrentModule);
|
|
|
|
} else {
|
2004-07-18 08:08:11 +08:00
|
|
|
GV = new GlobalVariable(PT->getElementType(), false,
|
2004-07-15 07:03:46 +08:00
|
|
|
GlobalValue::ExternalLinkage, 0,
|
|
|
|
Name, CurModule.CurrentModule);
|
|
|
|
}
|
2004-07-15 05:44:00 +08:00
|
|
|
|
2004-07-18 08:08:11 +08:00
|
|
|
// Keep track of the fact that we have a forward ref to recycle it
|
|
|
|
CurModule.GlobalRefs.insert(std::make_pair(std::make_pair(PT, $2), GV));
|
|
|
|
V = GV;
|
2001-10-13 14:41:08 +08:00
|
|
|
}
|
2001-10-03 14:12:09 +08:00
|
|
|
}
|
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = cast<GlobalValue>(V);
|
|
|
|
delete $1; // Free the type handle
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-07-15 06:59:28 +08:00
|
|
|
}
|
2002-08-17 05:14:40 +08:00
|
|
|
| Types ConstExpr {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
if ($1->get() != $2->getType())
|
2007-01-04 08:05:48 +08:00
|
|
|
GEN_ERROR("Mismatched types for constant expression: " +
|
|
|
|
(*$1)->getDescription() + " and " + $2->getType()->getDescription());
|
2002-08-17 05:14:40 +08:00
|
|
|
$$ = $2;
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-06-29 04:01:34 +08:00
|
|
|
}
|
|
|
|
| Types ZEROINITIALIZER {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const Type *Ty = $1->get();
|
2004-11-29 00:45:45 +08:00
|
|
|
if (isa<FunctionType>(Ty) || Ty == Type::LabelTy || isa<OpaqueType>(Ty))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Cannot create a null initialized value of this type!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = Constant::getNullValue(Ty);
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| IntType ESINT64VAL { // integral constants
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!ConstantInt::isValueValidForType($1, $2))
|
2006-12-21 01:20:09 +08:00
|
|
|
GEN_ERROR("Constant value doesn't fit in type!");
|
|
|
|
$$ = ConstantInt::get($1, $2);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| IntType EUINT64VAL { // integral constants
|
2006-12-21 01:20:09 +08:00
|
|
|
if (!ConstantInt::isValueValidForType($1, $2))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Constant value doesn't fit in type!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantInt::get($1, $2);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-10-09 08:25:32 +08:00
|
|
|
}
|
2007-01-13 13:00:20 +08:00
|
|
|
| INTTYPE TRUETOK { // Boolean constants
|
|
|
|
assert(cast<IntegerType>($1)->getBitWidth() == 1 && "Not Bool?");
|
2007-01-11 20:24:14 +08:00
|
|
|
$$ = ConstantInt::getTrue();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-08-16 02:17:28 +08:00
|
|
|
}
|
2007-01-13 13:00:20 +08:00
|
|
|
| INTTYPE FALSETOK { // Boolean constants
|
|
|
|
assert(cast<IntegerType>($1)->getBitWidth() == 1 && "Not Bool?");
|
2007-01-11 20:24:14 +08:00
|
|
|
$$ = ConstantInt::getFalse();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-08-16 02:17:28 +08:00
|
|
|
}
|
|
|
|
| FPType FPVAL { // Float & Double constants
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!ConstantFP::isValueValidForType($1, $2))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Floating point constant invalid for type!!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantFP::get($1, $2);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-08-16 02:17:28 +08:00
|
|
|
};
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-11-27 09:05:10 +08:00
|
|
|
ConstExpr: CastOps '(' ConstVal TO Types ')' {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
Constant *Val = $3;
|
2007-01-17 10:47:33 +08:00
|
|
|
const Type *DestTy = $5->get();
|
|
|
|
if (!CastInst::castIsValid($1, $3, DestTy))
|
|
|
|
GEN_ERROR("invalid cast opcode for cast from '" +
|
|
|
|
Val->getType()->getDescription() + "' to '" +
|
|
|
|
DestTy->getDescription() + "'!");
|
|
|
|
$$ = ConstantExpr::getCast($1, $3, DestTy);
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $5;
|
2002-07-15 06:59:28 +08:00
|
|
|
}
|
2002-08-17 05:14:40 +08:00
|
|
|
| GETELEMENTPTR '(' ConstVal IndexList ')' {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isa<PointerType>($3->getType()))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("GetElementPtr requires a pointer operand!");
|
2002-07-31 02:54:25 +08:00
|
|
|
|
|
|
|
const Type *IdxTy =
|
2006-12-03 13:45:44 +08:00
|
|
|
GetElementPtrInst::getIndexedType($3->getType(), *$4, true);
|
2002-07-31 02:54:25 +08:00
|
|
|
if (!IdxTy)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Index list invalid for constant getelementptr!");
|
2002-07-31 02:54:25 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
std::vector<Constant*> IdxVec;
|
|
|
|
for (unsigned i = 0, e = $4->size(); i != e; ++i)
|
|
|
|
if (Constant *C = dyn_cast<Constant>((*$4)[i]))
|
|
|
|
IdxVec.push_back(C);
|
|
|
|
else
|
|
|
|
GEN_ERROR("Indices to constant getelementptr must be constants!");
|
|
|
|
|
2002-08-17 05:14:40 +08:00
|
|
|
delete $4;
|
2002-07-18 08:14:27 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::getGetElementPtr($3, IdxVec);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-07-15 06:59:28 +08:00
|
|
|
}
|
2004-03-12 13:51:36 +08:00
|
|
|
| SELECT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
|
2007-01-12 02:21:29 +08:00
|
|
|
if ($3->getType() != Type::Int1Ty)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Select condition must be of boolean type!");
|
2006-12-03 13:45:44 +08:00
|
|
|
if ($5->getType() != $7->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Select operand types must match!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::getSelect($3, $5, $7);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-03-12 13:51:36 +08:00
|
|
|
}
|
2004-08-18 01:26:41 +08:00
|
|
|
| ArithmeticOps '(' ConstVal ',' ConstVal ')' {
|
2006-12-03 13:45:44 +08:00
|
|
|
if ($3->getType() != $5->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Binary operator types must match!");
|
2006-10-26 14:15:43 +08:00
|
|
|
CHECK_FOR_ERROR;
|
2006-12-06 03:15:41 +08:00
|
|
|
$$ = ConstantExpr::get($1, $3, $5);
|
2004-08-18 01:26:41 +08:00
|
|
|
}
|
|
|
|
| LogicalOps '(' ConstVal ',' ConstVal ')' {
|
2006-12-03 13:45:44 +08:00
|
|
|
if ($3->getType() != $5->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Logical operator types must match!");
|
2007-01-15 10:27:26 +08:00
|
|
|
if (!$3->getType()->isInteger()) {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isa<PackedType>($3->getType()) ||
|
2007-01-15 10:27:26 +08:00
|
|
|
!cast<PackedType>($3->getType())->getElementType()->isInteger())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Logical operator requires integral operands!");
|
2005-12-22 02:31:29 +08:00
|
|
|
}
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::get($1, $3, $5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-08-18 01:26:41 +08:00
|
|
|
}
|
2006-12-04 13:20:06 +08:00
|
|
|
| ICMP IPredicates '(' ConstVal ',' ConstVal ')' {
|
|
|
|
if ($4->getType() != $6->getType())
|
2006-12-03 13:45:44 +08:00
|
|
|
GEN_ERROR("icmp operand types must match!");
|
2006-12-04 13:20:06 +08:00
|
|
|
$$ = ConstantExpr::getICmp($2, $4, $6);
|
2006-12-03 13:45:44 +08:00
|
|
|
}
|
2006-12-04 13:20:06 +08:00
|
|
|
| FCMP FPredicates '(' ConstVal ',' ConstVal ')' {
|
|
|
|
if ($4->getType() != $6->getType())
|
2006-12-03 13:45:44 +08:00
|
|
|
GEN_ERROR("fcmp operand types must match!");
|
2006-12-04 13:20:06 +08:00
|
|
|
$$ = ConstantExpr::getFCmp($2, $4, $6);
|
2006-12-03 13:45:44 +08:00
|
|
|
}
|
2002-08-17 05:14:40 +08:00
|
|
|
| ShiftOps '(' ConstVal ',' ConstVal ')' {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if ($5->getType() != Type::Int8Ty)
|
|
|
|
GEN_ERROR("Shift count for shift constant must be i8 type!");
|
2007-01-15 10:27:26 +08:00
|
|
|
if (!$3->getType()->isInteger())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Shift constant expression requires integer operand!");
|
2006-11-08 14:47:33 +08:00
|
|
|
CHECK_FOR_ERROR;
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::get($1, $3, $5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-11 03:04:32 +08:00
|
|
|
}
|
|
|
|
| EXTRACTELEMENT '(' ConstVal ',' ConstVal ')' {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!ExtractElementInst::isValidOperands($3, $5))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid extractelement operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::getExtractElement($3, $5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-04-08 11:53:34 +08:00
|
|
|
}
|
|
|
|
| INSERTELEMENT '(' ConstVal ',' ConstVal ',' ConstVal ')' {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!InsertElementInst::isValidOperands($3, $5, $7))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid insertelement operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::getInsertElement($3, $5, $7);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-04-08 11:53:34 +08:00
|
|
|
}
|
|
|
|
| SHUFFLEVECTOR '(' ConstVal ',' ConstVal ',' ConstVal ')' {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!ShuffleVectorInst::isValidOperands($3, $5, $7))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid shufflevector operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ConstantExpr::getShuffleVector($3, $5, $7);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-08-15 01:12:33 +08:00
|
|
|
};
|
2002-07-15 06:59:28 +08:00
|
|
|
|
2006-04-08 11:53:34 +08:00
|
|
|
|
2003-07-15 01:20:40 +08:00
|
|
|
// ConstVector - A list of comma separated constants.
|
2001-06-07 04:29:01 +08:00
|
|
|
ConstVector : ConstVector ',' ConstVal {
|
2001-09-08 00:35:17 +08:00
|
|
|
($$ = $1)->push_back($3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| ConstVal {
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new std::vector<Constant*>();
|
2001-09-08 00:35:17 +08:00
|
|
|
$$->push_back($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-07-27 00:29:15 +08:00
|
|
|
|
2001-09-18 12:00:54 +08:00
|
|
|
// GlobalType - Match either GLOBAL or CONSTANT for global declarations...
|
2002-06-05 05:58:56 +08:00
|
|
|
GlobalType : GLOBAL { $$ = false; } | CONSTANT { $$ = true; };
|
2001-09-18 12:00:54 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-05-03 03:11:13 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Rules to match Modules
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
// Module rule: Capture the result of parsing the whole file into a result
|
|
|
|
// variable...
|
|
|
|
//
|
2006-12-30 04:29:48 +08:00
|
|
|
Module
|
|
|
|
: DefinitionList {
|
|
|
|
$$ = ParserResult = CurModule.CurrentModule;
|
|
|
|
CurModule.ModuleDone();
|
|
|
|
CHECK_FOR_ERROR;
|
|
|
|
}
|
|
|
|
| /*empty*/ {
|
|
|
|
$$ = ParserResult = CurModule.CurrentModule;
|
|
|
|
CurModule.ModuleDone();
|
|
|
|
CHECK_FOR_ERROR;
|
|
|
|
}
|
|
|
|
;
|
2002-05-03 03:11:13 +08:00
|
|
|
|
2006-12-30 04:29:48 +08:00
|
|
|
DefinitionList
|
|
|
|
: Definition
|
|
|
|
| DefinitionList Definition
|
|
|
|
;
|
|
|
|
|
|
|
|
Definition
|
2007-01-22 03:19:31 +08:00
|
|
|
: DEFINE { CurFun.isDeclare = false; } Function {
|
2003-10-17 04:12:13 +08:00
|
|
|
CurFun.FunctionDone();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-30 04:29:48 +08:00
|
|
|
}
|
|
|
|
| DECLARE { CurFun.isDeclare = true; } FunctionProto {
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-05-03 03:11:13 +08:00
|
|
|
}
|
2006-12-30 04:29:48 +08:00
|
|
|
| MODULE ASM_TOK AsmBlock {
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-24 07:05:15 +08:00
|
|
|
}
|
2006-12-30 04:29:48 +08:00
|
|
|
| IMPLEMENTATION {
|
2005-03-21 14:27:42 +08:00
|
|
|
// Emit an error if there are any unresolved types left.
|
|
|
|
if (!CurModule.LateResolveTypes.empty()) {
|
|
|
|
const ValID &DID = CurModule.LateResolveTypes.begin()->first;
|
2006-08-18 16:43:06 +08:00
|
|
|
if (DID.Type == ValID::NameVal) {
|
|
|
|
GEN_ERROR("Reference to an undefined type: '"+DID.getName() + "'");
|
|
|
|
} else {
|
|
|
|
GEN_ERROR("Reference to an undefined type: #" + itostr(DID.Num));
|
|
|
|
}
|
2005-03-21 14:27:42 +08:00
|
|
|
}
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-30 04:29:48 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| OptAssign TYPE Types {
|
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
2001-10-22 13:56:09 +08:00
|
|
|
// Eagerly resolve types. This is not an optimization, this is a
|
|
|
|
// requirement that is due to the fact that we could have this:
|
|
|
|
//
|
|
|
|
// %list = type { %list * }
|
|
|
|
// %list = type { %list * } ; repeated type decl
|
|
|
|
//
|
|
|
|
// If types are not resolved eagerly, then the two types will not be
|
|
|
|
// determined to be the same type!
|
|
|
|
//
|
2006-12-30 04:29:48 +08:00
|
|
|
ResolveTypeTo($1, *$3);
|
2004-07-13 16:10:10 +08:00
|
|
|
|
2006-12-30 04:29:48 +08:00
|
|
|
if (!setTypeName(*$3, $1) && !$1) {
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-13 16:10:10 +08:00
|
|
|
// If this is a named type that is not a redefinition, add it to the slot
|
|
|
|
// table.
|
2006-12-30 04:29:48 +08:00
|
|
|
CurModule.Types.push_back(*$3);
|
2001-09-08 00:35:17 +08:00
|
|
|
}
|
2006-12-03 13:45:44 +08:00
|
|
|
|
2006-12-30 04:29:48 +08:00
|
|
|
delete $3;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-24 07:05:15 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| OptAssign TYPE VOID {
|
|
|
|
ResolveTypeTo($1, $3);
|
|
|
|
|
|
|
|
if (!setTypeName($3, $1) && !$1) {
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
// If this is a named type that is not a redefinition, add it to the slot
|
|
|
|
// table.
|
|
|
|
CurModule.Types.push_back($3);
|
|
|
|
}
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
2007-01-13 03:20:47 +08:00
|
|
|
| OptAssign GVVisibilityStyle GlobalType ConstVal { /* "Externally Visible" Linkage */
|
|
|
|
if ($4 == 0)
|
2006-09-29 03:28:24 +08:00
|
|
|
GEN_ERROR("Global value initializer is not a constant!");
|
2007-01-13 03:20:47 +08:00
|
|
|
CurGV = ParseGlobalVariable($1, GlobalValue::ExternalLinkage,
|
|
|
|
$2, $3, $4->getType(), $4);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
} GlobalVarAttributes {
|
|
|
|
CurGV = 0;
|
2001-09-18 12:00:54 +08:00
|
|
|
}
|
2007-01-13 03:20:47 +08:00
|
|
|
| OptAssign GVInternalLinkage GVVisibilityStyle GlobalType ConstVal {
|
|
|
|
if ($5 == 0)
|
2006-12-30 04:29:48 +08:00
|
|
|
GEN_ERROR("Global value initializer is not a constant!");
|
2007-01-13 03:20:47 +08:00
|
|
|
CurGV = ParseGlobalVariable($1, $2, $3, $4, $5->getType(), $5);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
|
|
|
} GlobalVarAttributes {
|
2006-09-15 02:23:27 +08:00
|
|
|
CurGV = 0;
|
|
|
|
}
|
2007-01-13 03:20:47 +08:00
|
|
|
| OptAssign GVExternalLinkage GVVisibilityStyle GlobalType Types {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
2007-01-13 03:20:47 +08:00
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription());
|
|
|
|
CurGV = ParseGlobalVariable($1, $2, $3, $4, *$5, 0);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2007-01-13 03:20:47 +08:00
|
|
|
delete $5;
|
2006-09-29 03:28:24 +08:00
|
|
|
} GlobalVarAttributes {
|
2005-11-13 02:21:21 +08:00
|
|
|
CurGV = 0;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-07-14 14:10:16 +08:00
|
|
|
}
|
2006-12-30 04:29:48 +08:00
|
|
|
| TARGET TargetDefinition {
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-04-23 03:07:06 +08:00
|
|
|
}
|
2006-12-30 04:29:48 +08:00
|
|
|
| DEPLIBS '=' LibrariesDefinition {
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 01:58:28 +08:00
|
|
|
}
|
2006-12-30 04:29:48 +08:00
|
|
|
;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
|
2006-01-24 07:05:15 +08:00
|
|
|
AsmBlock : STRINGCONSTANT {
|
2006-01-24 12:14:29 +08:00
|
|
|
const std::string &AsmSoFar = CurModule.CurrentModule->getModuleInlineAsm();
|
2006-01-24 07:05:15 +08:00
|
|
|
char *EndStr = UnEscapeLexed($1, true);
|
|
|
|
std::string NewAsm($1, EndStr);
|
|
|
|
free($1);
|
|
|
|
|
|
|
|
if (AsmSoFar.empty())
|
2006-01-24 12:14:29 +08:00
|
|
|
CurModule.CurrentModule->setModuleInlineAsm(NewAsm);
|
2006-01-24 07:05:15 +08:00
|
|
|
else
|
2006-01-24 12:14:29 +08:00
|
|
|
CurModule.CurrentModule->setModuleInlineAsm(AsmSoFar+"\n"+NewAsm);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-24 07:05:15 +08:00
|
|
|
};
|
2003-04-23 03:07:06 +08:00
|
|
|
|
|
|
|
BigOrLittle : BIG { $$ = Module::BigEndian; };
|
|
|
|
BigOrLittle : LITTLE { $$ = Module::LittleEndian; };
|
|
|
|
|
|
|
|
TargetDefinition : ENDIAN '=' BigOrLittle {
|
|
|
|
CurModule.CurrentModule->setEndianness($3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-04-23 03:07:06 +08:00
|
|
|
}
|
|
|
|
| POINTERSIZE '=' EUINT64VAL {
|
|
|
|
if ($3 == 32)
|
|
|
|
CurModule.CurrentModule->setPointerSize(Module::Pointer32);
|
|
|
|
else if ($3 == 64)
|
|
|
|
CurModule.CurrentModule->setPointerSize(Module::Pointer64);
|
|
|
|
else
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid pointer size: '" + utostr($3) + "'!");
|
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 01:58:28 +08:00
|
|
|
}
|
|
|
|
| TRIPLE '=' STRINGCONSTANT {
|
2004-07-26 05:30:51 +08:00
|
|
|
CurModule.CurrentModule->setTargetTriple($3);
|
|
|
|
free($3);
|
2006-10-25 03:09:48 +08:00
|
|
|
}
|
2006-10-22 14:07:41 +08:00
|
|
|
| DATALAYOUT '=' STRINGCONSTANT {
|
2006-10-18 10:21:12 +08:00
|
|
|
CurModule.CurrentModule->setDataLayout($3);
|
|
|
|
free($3);
|
|
|
|
};
|
2003-04-23 03:07:06 +08:00
|
|
|
|
2004-07-26 05:30:51 +08:00
|
|
|
LibrariesDefinition : '[' LibList ']';
|
2004-07-26 01:58:28 +08:00
|
|
|
|
|
|
|
LibList : LibList ',' STRINGCONSTANT {
|
2004-07-26 05:30:51 +08:00
|
|
|
CurModule.CurrentModule->addLibrary($3);
|
|
|
|
free($3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 01:58:28 +08:00
|
|
|
}
|
|
|
|
| STRINGCONSTANT {
|
2004-07-26 05:30:51 +08:00
|
|
|
CurModule.CurrentModule->addLibrary($1);
|
|
|
|
free($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 01:58:28 +08:00
|
|
|
}
|
|
|
|
| /* empty: end of list */ {
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 01:58:28 +08:00
|
|
|
}
|
|
|
|
;
|
2003-04-23 03:07:06 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-03-27 02:01:55 +08:00
|
|
|
// Rules to match Function Headers
|
2001-06-07 04:29:01 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2003-08-22 13:42:10 +08:00
|
|
|
Name : VAR_ID | STRINGCONSTANT;
|
|
|
|
OptName : Name | /*empty*/ { $$ = 0; };
|
2001-06-07 04:29:01 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ArgListH : ArgListH ',' Types OptParamAttrs OptName {
|
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
|
|
|
if (*$3 == Type::VoidTy)
|
|
|
|
GEN_ERROR("void typed arguments are invalid!");
|
|
|
|
ArgListEntry E; E.Attrs = $4; E.Ty = $3; E.Name = $5;
|
2002-10-14 04:57:00 +08:00
|
|
|
$$ = $1;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
$1->push_back(E);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| Types OptParamAttrs OptName {
|
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
|
|
|
if (*$1 == Type::VoidTy)
|
|
|
|
GEN_ERROR("void typed arguments are invalid!");
|
|
|
|
ArgListEntry E; E.Attrs = $2; E.Ty = $1; E.Name = $3;
|
|
|
|
$$ = new ArgListType;
|
|
|
|
$$->push_back(E);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
ArgList : ArgListH {
|
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2002-10-14 04:57:00 +08:00
|
|
|
| ArgListH ',' DOTDOTDOT {
|
|
|
|
$$ = $1;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
struct ArgListEntry E;
|
|
|
|
E.Ty = new PATypeHolder(Type::VoidTy);
|
|
|
|
E.Name = 0;
|
|
|
|
E.Attrs = FunctionType::NoAttributeSet;
|
|
|
|
$$->push_back(E);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-10-14 04:57:00 +08:00
|
|
|
}
|
|
|
|
| DOTDOTDOT {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
$$ = new ArgListType;
|
|
|
|
struct ArgListEntry E;
|
|
|
|
E.Ty = new PATypeHolder(Type::VoidTy);
|
|
|
|
E.Name = 0;
|
|
|
|
E.Attrs = FunctionType::NoAttributeSet;
|
|
|
|
$$->push_back(E);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-10-14 04:57:00 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
| /* empty */ {
|
|
|
|
$$ = 0;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
FunctionHeaderH : OptCallingConv ResultTypes Name '(' ArgList ')'
|
|
|
|
OptFuncAttrs OptSection OptAlign {
|
2005-05-07 04:27:19 +08:00
|
|
|
UnEscapeLexed($3);
|
|
|
|
std::string FunctionName($3);
|
|
|
|
free($3); // Free strdup'd memory!
|
2001-11-27 02:54:16 +08:00
|
|
|
|
2007-01-03 05:53:43 +08:00
|
|
|
// Check the function result for abstractness if this is a define. We should
|
|
|
|
// have no abstract types at this point
|
2007-01-06 01:06:19 +08:00
|
|
|
if (!CurFun.isDeclare && CurModule.TypeIsUnresolved($2))
|
|
|
|
GEN_ERROR("Reference to abstract result: "+ $2->get()->getDescription());
|
2007-01-03 05:53:43 +08:00
|
|
|
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<const Type*> ParamTypeList;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
std::vector<FunctionType::ParameterAttributes> ParamAttrs;
|
2007-01-06 01:06:19 +08:00
|
|
|
ParamAttrs.push_back($7);
|
2005-05-07 04:27:19 +08:00
|
|
|
if ($5) { // If there are arguments...
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I) {
|
|
|
|
const Type* Ty = I->Ty->get();
|
2007-01-03 05:53:43 +08:00
|
|
|
if (!CurFun.isDeclare && CurModule.TypeIsUnresolved(I->Ty))
|
|
|
|
GEN_ERROR("Reference to abstract argument: " + Ty->getDescription());
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ParamTypeList.push_back(Ty);
|
|
|
|
if (Ty != Type::VoidTy)
|
|
|
|
ParamAttrs.push_back(I->Attrs);
|
|
|
|
}
|
2002-10-16 05:41:14 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
bool isVarArg = ParamTypeList.size() && ParamTypeList.back() == Type::VoidTy;
|
|
|
|
if (isVarArg) ParamTypeList.pop_back();
|
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg,
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ParamAttrs);
|
2002-10-16 05:41:14 +08:00
|
|
|
const PointerType *PFT = PointerType::get(FT);
|
2007-01-06 01:06:19 +08:00
|
|
|
delete $2;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2004-07-15 07:03:46 +08:00
|
|
|
ValID ID;
|
|
|
|
if (!FunctionName.empty()) {
|
|
|
|
ID = ValID::create((char*)FunctionName.c_str());
|
|
|
|
} else {
|
|
|
|
ID = ValID::create((int)CurModule.Values[PFT].size());
|
|
|
|
}
|
|
|
|
|
2004-07-15 03:33:47 +08:00
|
|
|
Function *Fn = 0;
|
2004-07-15 07:03:46 +08:00
|
|
|
// See if this function was forward referenced. If so, recycle the object.
|
|
|
|
if (GlobalValue *FWRef = CurModule.GetForwardRefForGlobal(PFT, ID)) {
|
|
|
|
// Move the function to the end of the list, from whereever it was
|
|
|
|
// previously inserted.
|
|
|
|
Fn = cast<Function>(FWRef);
|
|
|
|
CurModule.CurrentModule->getFunctionList().remove(Fn);
|
|
|
|
CurModule.CurrentModule->getFunctionList().push_back(Fn);
|
|
|
|
} else if (!FunctionName.empty() && // Merge with an earlier prototype?
|
|
|
|
(Fn = CurModule.CurrentModule->getFunction(FunctionName, FT))) {
|
|
|
|
// If this is the case, either we need to be a forward decl, or it needs
|
|
|
|
// to be.
|
2004-07-15 03:33:47 +08:00
|
|
|
if (!CurFun.isDeclare && !Fn->isExternal())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Redefinition of function '" + FunctionName + "'!");
|
2004-07-15 03:33:47 +08:00
|
|
|
|
2004-07-15 07:03:46 +08:00
|
|
|
// Make sure to strip off any argument names so we can't get conflicts.
|
|
|
|
if (Fn->isExternal())
|
2005-03-15 12:54:21 +08:00
|
|
|
for (Function::arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
|
2004-07-15 07:03:46 +08:00
|
|
|
AI != AE; ++AI)
|
|
|
|
AI->setName("");
|
2004-07-15 03:33:47 +08:00
|
|
|
} else { // Not already defined?
|
|
|
|
Fn = new Function(FT, GlobalValue::ExternalLinkage, FunctionName,
|
|
|
|
CurModule.CurrentModule);
|
2006-09-15 02:23:27 +08:00
|
|
|
|
2004-07-15 03:33:47 +08:00
|
|
|
InsertValue(Fn, CurModule.Values);
|
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2003-10-17 04:12:13 +08:00
|
|
|
CurFun.FunctionStart(Fn);
|
2006-09-17 21:06:18 +08:00
|
|
|
|
|
|
|
if (CurFun.isDeclare) {
|
|
|
|
// If we have declaration, always overwrite linkage. This will allow us to
|
|
|
|
// correctly handle cases, when pointer to function is passed as argument to
|
|
|
|
// another function.
|
|
|
|
Fn->setLinkage(CurFun.Linkage);
|
2007-01-13 03:20:47 +08:00
|
|
|
Fn->setVisibility(CurFun.Visibility);
|
2006-09-17 21:06:18 +08:00
|
|
|
}
|
2005-05-07 04:27:19 +08:00
|
|
|
Fn->setCallingConv($1);
|
2007-01-06 01:06:19 +08:00
|
|
|
Fn->setAlignment($9);
|
|
|
|
if ($8) {
|
|
|
|
Fn->setSection($8);
|
|
|
|
free($8);
|
2005-11-12 08:11:10 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-06-26 00:13:24 +08:00
|
|
|
// Add all of the arguments we parsed to the function...
|
2005-05-07 04:27:19 +08:00
|
|
|
if ($5) { // Is null if empty...
|
2002-10-14 04:57:00 +08:00
|
|
|
if (isVarArg) { // Nuke the last entry
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
assert($5->back().Ty->get() == Type::VoidTy && $5->back().Name == 0&&
|
2006-12-03 13:45:44 +08:00
|
|
|
"Not a varargs marker!");
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
delete $5->back().Ty;
|
2005-05-07 04:27:19 +08:00
|
|
|
$5->pop_back(); // Delete the last entry
|
2002-10-14 04:57:00 +08:00
|
|
|
}
|
2005-03-15 12:54:21 +08:00
|
|
|
Function::arg_iterator ArgIt = Fn->arg_begin();
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
unsigned Idx = 1;
|
|
|
|
for (ArgListType::iterator I = $5->begin(); I != $5->end(); ++I, ++ArgIt) {
|
|
|
|
delete I->Ty; // Delete the typeholder...
|
|
|
|
setValueName(ArgIt, I->Name); // Insert arg into symtab...
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-10-14 04:57:00 +08:00
|
|
|
InsertValue(ArgIt);
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
Idx++;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2006-12-03 13:45:44 +08:00
|
|
|
|
2005-05-07 04:27:19 +08:00
|
|
|
delete $5; // We're now done with the argument list
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-05-04 02:23:48 +08:00
|
|
|
BEGIN : BEGINTOK | '{'; // Allow BEGIN or '{' to start a function
|
|
|
|
|
2007-01-13 03:20:47 +08:00
|
|
|
FunctionHeader : FunctionDefineLinkage GVVisibilityStyle FunctionHeaderH BEGIN {
|
2003-10-17 04:12:13 +08:00
|
|
|
$$ = CurFun.CurrentFunction;
|
2001-09-08 00:35:17 +08:00
|
|
|
|
2003-04-17 04:28:45 +08:00
|
|
|
// Make sure that we keep track of the linkage type even if there was a
|
|
|
|
// previous "declare".
|
|
|
|
$$->setLinkage($1);
|
2007-01-13 03:20:47 +08:00
|
|
|
$$->setVisibility($2);
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2002-05-04 02:23:48 +08:00
|
|
|
END : ENDTOK | '}'; // Allow end of '}' to end a function
|
|
|
|
|
2002-03-27 02:01:55 +08:00
|
|
|
Function : BasicBlockList END {
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2007-01-13 03:20:47 +08:00
|
|
|
FunctionProto : FunctionDeclareLinkage GVVisibilityStyle FunctionHeaderH {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
CurFun.CurrentFunction->setLinkage($1);
|
2007-01-13 03:20:47 +08:00
|
|
|
CurFun.CurrentFunction->setVisibility($2);
|
2006-09-15 02:23:27 +08:00
|
|
|
$$ = CurFun.CurrentFunction;
|
|
|
|
CurFun.FunctionDone();
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Rules to match Basic Blocks
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2006-01-26 06:26:43 +08:00
|
|
|
OptSideEffect : /* empty */ {
|
|
|
|
$$ = false;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-26 06:26:43 +08:00
|
|
|
}
|
|
|
|
| SIDEEFFECT {
|
|
|
|
$$ = true;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-26 06:26:43 +08:00
|
|
|
};
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
ConstValueRef : ESINT64VAL { // A reference to a direct constant
|
|
|
|
$$ = ValID::create($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| EUINT64VAL {
|
|
|
|
$$ = ValID::create($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-07-15 08:17:01 +08:00
|
|
|
| FPVAL { // Perhaps it's an FP constant?
|
|
|
|
$$ = ValID::create($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-07-15 08:17:01 +08:00
|
|
|
}
|
2004-03-31 11:49:47 +08:00
|
|
|
| TRUETOK {
|
2007-01-11 20:24:14 +08:00
|
|
|
$$ = ValID::create(ConstantInt::getTrue());
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2004-03-31 11:49:47 +08:00
|
|
|
| FALSETOK {
|
2007-01-11 20:24:14 +08:00
|
|
|
$$ = ValID::create(ConstantInt::getFalse());
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-10-01 06:46:54 +08:00
|
|
|
| NULL_TOK {
|
|
|
|
$$ = ValID::createNull();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-07-15 06:59:28 +08:00
|
|
|
}
|
2004-10-17 02:17:13 +08:00
|
|
|
| UNDEF {
|
|
|
|
$$ = ValID::createUndef();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-10-17 02:17:13 +08:00
|
|
|
}
|
2005-12-22 01:53:02 +08:00
|
|
|
| ZEROINITIALIZER { // A vector zero constant.
|
|
|
|
$$ = ValID::createZeroInit();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-12-22 01:53:02 +08:00
|
|
|
}
|
2004-08-20 14:00:58 +08:00
|
|
|
| '<' ConstVector '>' { // Nonempty unsized packed vector
|
2006-12-03 13:45:44 +08:00
|
|
|
const Type *ETy = (*$2)[0]->getType();
|
2004-08-20 14:00:58 +08:00
|
|
|
int NumElements = $2->size();
|
|
|
|
|
|
|
|
PackedType* pt = PackedType::get(ETy, NumElements);
|
|
|
|
PATypeHolder* PTy = new PATypeHolder(
|
2006-12-03 13:45:44 +08:00
|
|
|
HandleUpRefs(
|
|
|
|
PackedType::get(
|
|
|
|
ETy,
|
|
|
|
NumElements)
|
|
|
|
)
|
|
|
|
);
|
2004-08-20 14:00:58 +08:00
|
|
|
|
|
|
|
// Verify all elements are correct type!
|
|
|
|
for (unsigned i = 0; i < $2->size(); i++) {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (ETy != (*$2)[i]->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Element #" + utostr(i) + " is not of type '" +
|
2004-08-20 14:00:58 +08:00
|
|
|
ETy->getDescription() +"' as required!\nIt is of type '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$2)[i]->getType()->getDescription() + "'.");
|
2004-08-20 14:00:58 +08:00
|
|
|
}
|
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ValID::create(ConstantPacked::get(pt, *$2));
|
2004-08-20 14:00:58 +08:00
|
|
|
delete PTy; delete $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-08-20 14:00:58 +08:00
|
|
|
}
|
2002-08-17 05:14:40 +08:00
|
|
|
| ConstExpr {
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = ValID::create($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-26 06:26:43 +08:00
|
|
|
}
|
|
|
|
| ASM_TOK OptSideEffect STRINGCONSTANT ',' STRINGCONSTANT {
|
|
|
|
char *End = UnEscapeLexed($3, true);
|
|
|
|
std::string AsmStr = std::string($3, End);
|
|
|
|
End = UnEscapeLexed($5, true);
|
|
|
|
std::string Constraints = std::string($5, End);
|
|
|
|
$$ = ValID::createInlineAsm(AsmStr, Constraints, $2);
|
|
|
|
free($3);
|
|
|
|
free($5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-08-17 05:14:40 +08:00
|
|
|
};
|
2001-10-01 06:46:54 +08:00
|
|
|
|
2001-10-13 14:41:08 +08:00
|
|
|
// SymbolicValueRef - Reference to one of two ways of symbolically refering to
|
|
|
|
// another value.
|
|
|
|
//
|
|
|
|
SymbolicValueRef : INTVAL { // Is it an integer reference...?
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = ValID::create($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2003-08-22 13:42:10 +08:00
|
|
|
| Name { // Is it a named reference...?
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = ValID::create($1);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-10-13 14:41:08 +08:00
|
|
|
|
|
|
|
// ValueRef - A reference to a definition... either constant or symbolic
|
2002-06-05 05:58:56 +08:00
|
|
|
ValueRef : SymbolicValueRef | ConstValueRef;
|
2001-10-13 14:41:08 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-07-27 00:29:15 +08:00
|
|
|
// ResolvedVal - a <type> <value> pair. This is used only in cases where the
|
|
|
|
// type immediately preceeds the value reference, and allows complex constant
|
|
|
|
// pool references (for things like: 'ret [2 x int] [ int 12, int 42]')
|
2001-10-03 09:49:25 +08:00
|
|
|
ResolvedVal : Types ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
|
|
|
$$ = getVal(*$1, $2);
|
|
|
|
delete $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
|
|
|
;
|
2001-07-26 06:47:46 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
BasicBlockList : BasicBlockList BasicBlock {
|
2004-07-13 15:59:27 +08:00
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2002-06-26 00:13:24 +08:00
|
|
|
| FunctionHeader BasicBlock { // Do not allow functions with 0 basic blocks
|
2004-07-13 15:59:27 +08:00
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
|
|
|
|
// Basic blocks are terminated by branching instructions:
|
|
|
|
// br, br/cc, switch, ret
|
|
|
|
//
|
2001-10-13 14:41:08 +08:00
|
|
|
BasicBlock : InstructionList OptAssign BBTerminatorInst {
|
2004-07-13 15:59:27 +08:00
|
|
|
setValueName($3, $2);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-10-13 14:41:08 +08:00
|
|
|
InsertValue($3);
|
|
|
|
|
|
|
|
$1->getInstList().push_back($3);
|
2001-06-07 04:29:01 +08:00
|
|
|
InsertValue($1);
|
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
InstructionList : InstructionList Inst {
|
2006-11-27 09:05:10 +08:00
|
|
|
if (CastInst *CI1 = dyn_cast<CastInst>($2))
|
|
|
|
if (CastInst *CI2 = dyn_cast<CastInst>(CI1->getOperand(0)))
|
|
|
|
if (CI2->getParent() == 0)
|
|
|
|
$1->getInstList().push_back(CI2);
|
2001-06-07 04:29:01 +08:00
|
|
|
$1->getInstList().push_back($2);
|
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| /* empty */ {
|
2006-12-06 07:28:06 +08:00
|
|
|
$$ = getBBVal(ValID::create((int)CurFun.NextBBNum++), true);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 09:40:20 +08:00
|
|
|
|
|
|
|
// Make sure to move the basic block to the correct location in the
|
|
|
|
// function, instead of leaving it inserted wherever it was first
|
|
|
|
// referenced.
|
2005-05-07 03:58:35 +08:00
|
|
|
Function::BasicBlockListType &BBL =
|
|
|
|
CurFun.CurrentFunction->getBasicBlockList();
|
|
|
|
BBL.splice(BBL.end(), BBL, $$);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-13 16:39:15 +08:00
|
|
|
}
|
|
|
|
| LABELSTR {
|
2006-12-06 07:28:06 +08:00
|
|
|
$$ = getBBVal(ValID::create($1), true);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-07-26 09:40:20 +08:00
|
|
|
|
|
|
|
// Make sure to move the basic block to the correct location in the
|
|
|
|
// function, instead of leaving it inserted wherever it was first
|
|
|
|
// referenced.
|
2005-05-07 03:58:35 +08:00
|
|
|
Function::BasicBlockListType &BBL =
|
|
|
|
CurFun.CurrentFunction->getBasicBlockList();
|
|
|
|
BBL.splice(BBL.end(), BBL, $$);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-07-27 00:29:15 +08:00
|
|
|
BBTerminatorInst : RET ResolvedVal { // Return with a result...
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new ReturnInst($2);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| RET VOID { // Return with no result...
|
|
|
|
$$ = new ReturnInst();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| BR LABEL ValueRef { // Unconditional Branch...
|
2006-09-29 03:28:24 +08:00
|
|
|
BasicBlock* tmpBB = getBBVal($3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
$$ = new BranchInst(tmpBB);
|
2001-06-07 04:29:01 +08:00
|
|
|
} // Conditional Branch...
|
2007-01-13 13:00:20 +08:00
|
|
|
| BR INTTYPE ValueRef ',' LABEL ValueRef ',' LABEL ValueRef {
|
|
|
|
assert(cast<IntegerType>($2)->getBitWidth() == 1 && "Not Bool?");
|
2006-09-29 03:28:24 +08:00
|
|
|
BasicBlock* tmpBBA = getBBVal($6);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
BasicBlock* tmpBBB = getBBVal($9);
|
|
|
|
CHECK_FOR_ERROR
|
2007-01-12 02:21:29 +08:00
|
|
|
Value* tmpVal = getVal(Type::Int1Ty, $3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
$$ = new BranchInst(tmpBBA, tmpBBB, tmpVal);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' JumpTable ']' {
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal = getVal($2, $3);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
|
|
|
BasicBlock* tmpBB = getBBVal($6);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
SwitchInst *S = new SwitchInst(tmpVal, tmpBB, $8->size());
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = S;
|
|
|
|
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<std::pair<Constant*,BasicBlock*> >::iterator I = $8->begin(),
|
2002-04-10 03:41:42 +08:00
|
|
|
E = $8->end();
|
2005-02-24 13:25:17 +08:00
|
|
|
for (; I != E; ++I) {
|
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(I->first))
|
|
|
|
S->addCase(CI, I->second);
|
|
|
|
else
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Switch case is constant, but not a simple integer!");
|
2005-02-24 13:25:17 +08:00
|
|
|
}
|
2004-04-18 07:49:15 +08:00
|
|
|
delete $8;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2003-05-16 05:30:00 +08:00
|
|
|
| SWITCH IntType ValueRef ',' LABEL ValueRef '[' ']' {
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal = getVal($2, $3);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
|
|
|
BasicBlock* tmpBB = getBBVal($6);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
SwitchInst *S = new SwitchInst(tmpVal, tmpBB, 0);
|
2003-05-16 05:30:00 +08:00
|
|
|
$$ = S;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-05-16 05:30:00 +08:00
|
|
|
}
|
2007-01-06 01:06:19 +08:00
|
|
|
| INVOKE OptCallingConv ResultTypes ValueRef '(' ValueRefList ')' OptFuncAttrs
|
2005-05-07 04:27:19 +08:00
|
|
|
TO LABEL ValueRef UNWIND LABEL ValueRef {
|
2001-10-13 14:41:08 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
// Handle the short syntax
|
|
|
|
const PointerType *PFTy = 0;
|
|
|
|
const FunctionType *Ty = 0;
|
2007-01-06 01:06:19 +08:00
|
|
|
if (!(PFTy = dyn_cast<PointerType>($3->get())) ||
|
2002-10-16 05:41:14 +08:00
|
|
|
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
|
2001-10-13 14:41:08 +08:00
|
|
|
// Pull out the types of all of the arguments...
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<const Type*> ParamTypes;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
FunctionType::ParamAttrsList ParamAttrs;
|
2007-01-06 01:06:19 +08:00
|
|
|
ParamAttrs.push_back($8);
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) {
|
|
|
|
const Type *Ty = I->Val->getType();
|
|
|
|
if (Ty == Type::VoidTy)
|
|
|
|
GEN_ERROR("Short call syntax cannot be used with varargs");
|
|
|
|
ParamTypes.push_back(Ty);
|
|
|
|
ParamAttrs.push_back(I->Attrs);
|
2001-10-13 14:41:08 +08:00
|
|
|
}
|
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs);
|
2002-10-16 05:41:14 +08:00
|
|
|
PFTy = PointerType::get(Ty);
|
2001-10-13 14:41:08 +08:00
|
|
|
}
|
|
|
|
|
2005-05-07 04:27:19 +08:00
|
|
|
Value *V = getVal(PFTy, $4); // Get the function we're calling...
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2007-01-06 01:06:19 +08:00
|
|
|
BasicBlock *Normal = getBBVal($11);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2007-01-06 01:06:19 +08:00
|
|
|
BasicBlock *Except = getBBVal($14);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-10-13 14:41:08 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
// Check the arguments
|
|
|
|
ValueList Args;
|
|
|
|
if ($6->empty()) { // Has no arguments?
|
|
|
|
// Make sure no arguments is a good thing!
|
|
|
|
if (Ty->getNumParams() != 0)
|
|
|
|
GEN_ERROR("No arguments passed to a function that "
|
|
|
|
"expects arguments!");
|
2001-10-13 14:41:08 +08:00
|
|
|
} else { // Has arguments?
|
2002-03-27 02:01:55 +08:00
|
|
|
// Loop through FunctionType's arguments and ensure they are specified
|
2001-10-13 14:41:08 +08:00
|
|
|
// correctly!
|
2004-02-09 12:14:01 +08:00
|
|
|
FunctionType::param_iterator I = Ty->param_begin();
|
|
|
|
FunctionType::param_iterator E = Ty->param_end();
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end();
|
2006-12-03 13:45:44 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
|
|
|
|
if (ArgI->Val->getType() != *I)
|
|
|
|
GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*I)->getDescription() + "'!");
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
Args.push_back(ArgI->Val);
|
|
|
|
}
|
2006-12-03 13:45:44 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (Ty->isVarArg()) {
|
|
|
|
if (I == E)
|
|
|
|
for (; ArgI != ArgE; ++ArgI)
|
|
|
|
Args.push_back(ArgI->Val); // push the remaining varargs
|
|
|
|
} else if (I != E || ArgI != ArgE)
|
2006-12-03 13:45:44 +08:00
|
|
|
GEN_ERROR("Invalid number of parameters detected!");
|
2001-10-13 14:41:08 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
|
|
|
|
// Create the InvokeInst
|
|
|
|
InvokeInst *II = new InvokeInst(V, Normal, Except, Args);
|
|
|
|
II->setCallingConv($2);
|
|
|
|
$$ = II;
|
2005-05-07 04:27:19 +08:00
|
|
|
delete $6;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-09-09 02:54:55 +08:00
|
|
|
}
|
|
|
|
| UNWIND {
|
|
|
|
$$ = new UnwindInst();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-10-17 02:17:13 +08:00
|
|
|
}
|
|
|
|
| UNREACHABLE {
|
|
|
|
$$ = new UnreachableInst();
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-10-13 14:41:08 +08:00
|
|
|
|
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
|
|
|
|
$$ = $1;
|
2006-12-03 13:45:44 +08:00
|
|
|
Constant *V = cast<Constant>(getValNonImprovising($2, $3));
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
if (V == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("May only switch on a constant pool value!");
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-09-29 03:28:24 +08:00
|
|
|
BasicBlock* tmpBB = getBBVal($6);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
$$->push_back(std::make_pair(V, tmpBB));
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| IntType ConstValueRef ',' LABEL ValueRef {
|
2003-04-23 02:42:41 +08:00
|
|
|
$$ = new std::vector<std::pair<Constant*, BasicBlock*> >();
|
2006-12-03 13:45:44 +08:00
|
|
|
Constant *V = cast<Constant>(getValNonImprovising($1, $2));
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
if (V == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("May only switch on a constant pool value!");
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2006-09-29 03:28:24 +08:00
|
|
|
BasicBlock* tmpBB = getBBVal($5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
$$->push_back(std::make_pair(V, tmpBB));
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
|
|
|
Inst : OptAssign InstVal {
|
2001-10-03 23:39:04 +08:00
|
|
|
// Is this definition named?? if so, assign the name...
|
2004-07-13 15:59:27 +08:00
|
|
|
setValueName($2, $1);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
InsertValue($2);
|
|
|
|
$$ = $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2001-06-11 23:04:20 +08:00
|
|
|
PHIList : Types '[' ValueRef ',' ValueRef ']' { // Used for PHI nodes
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
2003-04-23 02:42:41 +08:00
|
|
|
$$ = new std::list<std::pair<Value*, BasicBlock*> >();
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal = getVal(*$1, $3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
BasicBlock* tmpBB = getBBVal($5);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
$$->push_back(std::make_pair(tmpVal, tmpBB));
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $1;
|
2001-06-11 23:04:20 +08:00
|
|
|
}
|
|
|
|
| PHIList ',' '[' ValueRef ',' ValueRef ']' {
|
|
|
|
$$ = $1;
|
2006-09-29 03:28:24 +08:00
|
|
|
Value* tmpVal = getVal($1->front().first->getType(), $4);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
BasicBlock* tmpBB = getBBVal($6);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
$1->push_back(std::make_pair(tmpVal, tmpBB));
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-11 23:04:20 +08:00
|
|
|
|
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ValueRefList : Types ValueRef OptParamAttrs {
|
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$1)->getDescription());
|
|
|
|
// Used for call and invoke instructions
|
|
|
|
$$ = new ValueRefList();
|
|
|
|
ValueRefListEntry E; E.Attrs = $3; E.Val = getVal($1->get(), $2);
|
|
|
|
$$->push_back(E);
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| ValueRefList ',' Types ValueRef OptParamAttrs {
|
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
2001-06-07 04:29:01 +08:00
|
|
|
$$ = $1;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ValueRefListEntry E; E.Attrs = $5; E.Val = getVal($3->get(), $4);
|
|
|
|
$$->push_back(E);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
}
|
|
|
|
| /*empty*/ { $$ = new ValueRefList(); };
|
2001-06-07 04:29:01 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
IndexList // Used for gep instructions and constant expressions
|
2007-01-01 05:46:36 +08:00
|
|
|
: /*empty*/ { $$ = new std::vector<Value*>(); }
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
| IndexList ',' ResolvedVal {
|
|
|
|
$$ = $1;
|
|
|
|
$$->push_back($3);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
}
|
2007-01-01 05:25:25 +08:00
|
|
|
;
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2005-05-06 13:51:46 +08:00
|
|
|
OptTailCall : TAIL CALL {
|
|
|
|
$$ = true;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-05-06 13:51:46 +08:00
|
|
|
}
|
|
|
|
| CALL {
|
|
|
|
$$ = false;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-05-06 13:51:46 +08:00
|
|
|
};
|
|
|
|
|
2002-09-11 03:57:26 +08:00
|
|
|
InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2007-01-15 10:27:26 +08:00
|
|
|
if (!(*$2)->isInteger() && !(*$2)->isFloatingPoint() &&
|
2006-12-03 13:45:44 +08:00
|
|
|
!isa<PackedType>((*$2).get()))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR(
|
2004-08-20 14:00:58 +08:00
|
|
|
"Arithmetic operator requires integer, FP, or packed operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
if (isa<PackedType>((*$2).get()) &&
|
|
|
|
($1 == Instruction::URem ||
|
|
|
|
$1 == Instruction::SRem ||
|
|
|
|
$1 == Instruction::FRem))
|
2006-11-02 09:53:59 +08:00
|
|
|
GEN_ERROR("U/S/FRem not supported on packed types!");
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* val1 = getVal(*$2, $3);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* val2 = getVal(*$2, $5);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = BinaryOperator::create($1, val1, val2);
|
2002-09-11 03:57:26 +08:00
|
|
|
if ($$ == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("binary operator returned null!");
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $2;
|
2002-09-11 03:57:26 +08:00
|
|
|
}
|
|
|
|
| LogicalOps Types ValueRef ',' ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2007-01-15 10:27:26 +08:00
|
|
|
if (!(*$2)->isInteger()) {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isa<PackedType>($2->get()) ||
|
2007-01-15 10:27:26 +08:00
|
|
|
!cast<PackedType>($2->get())->getElementType()->isInteger())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Logical operator requires integral operands!");
|
2005-12-22 02:31:29 +08:00
|
|
|
}
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal1 = getVal(*$2, $3);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal2 = getVal(*$2, $5);
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = BinaryOperator::create($1, tmpVal1, tmpVal2);
|
2002-09-11 03:57:26 +08:00
|
|
|
if ($$ == 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("binary operator returned null!");
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $2;
|
2002-09-11 03:57:26 +08:00
|
|
|
}
|
2006-12-03 13:45:44 +08:00
|
|
|
| ICMP IPredicates Types ValueRef ',' ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
2007-01-04 10:57:22 +08:00
|
|
|
if (isa<PackedType>((*$3).get()))
|
|
|
|
GEN_ERROR("Packed types not supported by icmp instruction");
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal1 = getVal(*$3, $4);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
Value* tmpVal2 = getVal(*$3, $6);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
$$ = CmpInst::create($1, $2, tmpVal1, tmpVal2);
|
|
|
|
if ($$ == 0)
|
|
|
|
GEN_ERROR("icmp operator returned null!");
|
|
|
|
}
|
|
|
|
| FCMP FPredicates Types ValueRef ',' ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
2007-01-04 10:57:22 +08:00
|
|
|
if (isa<PackedType>((*$3).get()))
|
|
|
|
GEN_ERROR("Packed types not supported by fcmp instruction");
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal1 = getVal(*$3, $4);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
Value* tmpVal2 = getVal(*$3, $6);
|
|
|
|
CHECK_FOR_ERROR
|
|
|
|
$$ = CmpInst::create($1, $2, tmpVal1, tmpVal2);
|
|
|
|
if ($$ == 0)
|
|
|
|
GEN_ERROR("fcmp operator returned null!");
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2001-07-27 00:29:15 +08:00
|
|
|
| ShiftOps ResolvedVal ',' ResolvedVal {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if ($4->getType() != Type::Int8Ty)
|
|
|
|
GEN_ERROR("Shift amount must be i8 type!");
|
2007-01-15 10:27:26 +08:00
|
|
|
if (!$2->getType()->isInteger())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Shift constant expression requires integer operand!");
|
2006-11-08 14:47:33 +08:00
|
|
|
CHECK_FOR_ERROR;
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new ShiftInst($1, $2, $4);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-07-09 05:10:27 +08:00
|
|
|
}
|
2006-11-27 09:05:10 +08:00
|
|
|
| CastOps ResolvedVal TO Types {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$4)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* Val = $2;
|
2007-01-17 10:47:33 +08:00
|
|
|
const Type* DestTy = $4->get();
|
|
|
|
if (!CastInst::castIsValid($1, Val, DestTy))
|
|
|
|
GEN_ERROR("invalid cast opcode for cast from '" +
|
|
|
|
Val->getType()->getDescription() + "' to '" +
|
|
|
|
DestTy->getDescription() + "'!");
|
|
|
|
$$ = CastInst::create($1, Val, DestTy);
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $4;
|
2003-05-08 10:44:12 +08:00
|
|
|
}
|
2004-03-12 13:51:36 +08:00
|
|
|
| SELECT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
|
2007-01-12 02:21:29 +08:00
|
|
|
if ($2->getType() != Type::Int1Ty)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("select condition must be boolean!");
|
2006-12-03 13:45:44 +08:00
|
|
|
if ($4->getType() != $6->getType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("select value types should match!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new SelectInst($2, $4, $6);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2004-03-12 13:51:36 +08:00
|
|
|
}
|
2003-10-18 13:53:13 +08:00
|
|
|
| VAARG ResolvedVal ',' Types {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$4)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new VAArgInst($2, *$4);
|
|
|
|
delete $4;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-10-18 13:53:13 +08:00
|
|
|
}
|
2006-01-11 03:04:32 +08:00
|
|
|
| EXTRACTELEMENT ResolvedVal ',' ResolvedVal {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!ExtractElementInst::isValidOperands($2, $4))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid extractelement operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new ExtractElementInst($2, $4);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-11 03:04:32 +08:00
|
|
|
}
|
2006-01-18 04:06:25 +08:00
|
|
|
| INSERTELEMENT ResolvedVal ',' ResolvedVal ',' ResolvedVal {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!InsertElementInst::isValidOperands($2, $4, $6))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid insertelement operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new InsertElementInst($2, $4, $6);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-01-18 04:06:25 +08:00
|
|
|
}
|
2006-04-08 09:18:35 +08:00
|
|
|
| SHUFFLEVECTOR ResolvedVal ',' ResolvedVal ',' ResolvedVal {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!ShuffleVectorInst::isValidOperands($2, $4, $6))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid shufflevector operands!");
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new ShuffleVectorInst($2, $4, $6);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-04-08 09:18:35 +08:00
|
|
|
}
|
2003-10-20 05:34:28 +08:00
|
|
|
| PHI_TOK PHIList {
|
2001-06-11 23:04:20 +08:00
|
|
|
const Type *Ty = $2->front().first->getType();
|
2003-10-30 09:38:18 +08:00
|
|
|
if (!Ty->isFirstClassType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("PHI node operands must be of first class type!");
|
2001-06-11 23:04:20 +08:00
|
|
|
$$ = new PHINode(Ty);
|
2005-01-29 08:35:55 +08:00
|
|
|
((PHINode*)$$)->reserveOperandSpace($2->size());
|
2001-06-07 04:29:01 +08:00
|
|
|
while ($2->begin() != $2->end()) {
|
2001-06-11 23:04:20 +08:00
|
|
|
if ($2->front().first->getType() != Ty)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("All elements of a PHI node must be of the same type!");
|
2001-10-02 11:41:24 +08:00
|
|
|
cast<PHINode>($$)->addIncoming($2->front().first, $2->front().second);
|
2001-06-07 04:29:01 +08:00
|
|
|
$2->pop_front();
|
|
|
|
}
|
|
|
|
delete $2; // Free the list...
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2005-05-06 13:51:46 +08:00
|
|
|
}
|
2007-01-06 01:06:19 +08:00
|
|
|
| OptTailCall OptCallingConv ResultTypes ValueRef '(' ValueRefList ')'
|
|
|
|
OptFuncAttrs {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
|
|
|
|
// Handle the short syntax
|
2006-11-12 19:10:39 +08:00
|
|
|
const PointerType *PFTy = 0;
|
|
|
|
const FunctionType *Ty = 0;
|
2007-01-06 01:06:19 +08:00
|
|
|
if (!(PFTy = dyn_cast<PointerType>($3->get())) ||
|
2002-10-16 05:41:14 +08:00
|
|
|
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
|
2001-07-26 06:47:46 +08:00
|
|
|
// Pull out the types of all of the arguments...
|
2003-04-23 02:42:41 +08:00
|
|
|
std::vector<const Type*> ParamTypes;
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
FunctionType::ParamAttrsList ParamAttrs;
|
2007-01-06 01:06:19 +08:00
|
|
|
ParamAttrs.push_back($8);
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
for (ValueRefList::iterator I = $6->begin(), E = $6->end(); I != E; ++I) {
|
|
|
|
const Type *Ty = I->Val->getType();
|
|
|
|
if (Ty == Type::VoidTy)
|
|
|
|
GEN_ERROR("Short call syntax cannot be used with varargs");
|
|
|
|
ParamTypes.push_back(Ty);
|
|
|
|
ParamAttrs.push_back(I->Attrs);
|
2001-10-03 22:53:21 +08:00
|
|
|
}
|
2001-10-13 14:41:08 +08:00
|
|
|
|
2007-01-06 01:06:19 +08:00
|
|
|
Ty = FunctionType::get($3->get(), ParamTypes, false, ParamAttrs);
|
2002-10-16 05:41:14 +08:00
|
|
|
PFTy = PointerType::get(Ty);
|
2001-07-26 06:47:46 +08:00
|
|
|
}
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2005-05-07 04:27:19 +08:00
|
|
|
Value *V = getVal(PFTy, $4); // Get the function we're calling...
|
2006-09-29 03:28:24 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
// Check the arguments
|
|
|
|
ValueList Args;
|
|
|
|
if ($6->empty()) { // Has no arguments?
|
2002-07-26 04:52:56 +08:00
|
|
|
// Make sure no arguments is a good thing!
|
|
|
|
if (Ty->getNumParams() != 0)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("No arguments passed to a function that "
|
2002-07-26 04:52:56 +08:00
|
|
|
"expects arguments!");
|
2001-07-26 06:47:46 +08:00
|
|
|
} else { // Has arguments?
|
2002-03-27 02:01:55 +08:00
|
|
|
// Loop through FunctionType's arguments and ensure they are specified
|
2001-06-07 04:29:01 +08:00
|
|
|
// correctly!
|
|
|
|
//
|
2004-02-09 12:14:01 +08:00
|
|
|
FunctionType::param_iterator I = Ty->param_begin();
|
|
|
|
FunctionType::param_iterator E = Ty->param_end();
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
ValueRefList::iterator ArgI = $6->begin(), ArgE = $6->end();
|
2006-12-03 13:45:44 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
for (; ArgI != ArgE && I != E; ++ArgI, ++I) {
|
|
|
|
if (ArgI->Val->getType() != *I)
|
|
|
|
GEN_ERROR("Parameter " + ArgI->Val->getName()+ " is not of type '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*I)->getDescription() + "'!");
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
Args.push_back(ArgI->Val);
|
|
|
|
}
|
|
|
|
if (Ty->isVarArg()) {
|
|
|
|
if (I == E)
|
|
|
|
for (; ArgI != ArgE; ++ArgI)
|
|
|
|
Args.push_back(ArgI->Val); // push the remaining varargs
|
|
|
|
} else if (I != E || ArgI != ArgE)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid number of parameters detected!");
|
2001-07-26 06:47:46 +08:00
|
|
|
}
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
// Create the call node
|
|
|
|
CallInst *CI = new CallInst(V, Args);
|
|
|
|
CI->setTailCall($1);
|
|
|
|
CI->setCallingConv($2);
|
|
|
|
$$ = CI;
|
2005-05-07 04:27:19 +08:00
|
|
|
delete $6;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
| MemoryInst {
|
|
|
|
$$ = $1;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-06-07 04:29:01 +08:00
|
|
|
|
2003-09-09 02:20:29 +08:00
|
|
|
OptVolatile : VOLATILE {
|
|
|
|
$$ = true;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-09-09 02:20:29 +08:00
|
|
|
}
|
|
|
|
| /* empty */ {
|
|
|
|
$$ = false;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2003-09-09 02:20:29 +08:00
|
|
|
};
|
|
|
|
|
2001-07-09 05:10:27 +08:00
|
|
|
|
2005-05-06 13:51:46 +08:00
|
|
|
|
2005-11-06 14:34:12 +08:00
|
|
|
MemoryInst : MALLOC Types OptCAlign {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new MallocInst(*$2, 0, $3);
|
|
|
|
delete $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
| MALLOC Types ',' INTTYPE ValueRef OptCAlign {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal = getVal($4, $5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new MallocInst(*$2, tmpVal, $6);
|
|
|
|
delete $2;
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
2005-11-06 14:34:12 +08:00
|
|
|
| ALLOCA Types OptCAlign {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new AllocaInst(*$2, 0, $3);
|
|
|
|
delete $2;
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
llvm-svn: 33113
2007-01-12 15:05:14 +08:00
|
|
|
| ALLOCA Types ',' INTTYPE ValueRef OptCAlign {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal = getVal($4, $5);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new AllocaInst(*$2, tmpVal, $6);
|
|
|
|
delete $2;
|
2005-11-05 17:21:28 +08:00
|
|
|
}
|
2001-07-27 00:29:15 +08:00
|
|
|
| FREE ResolvedVal {
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isa<PointerType>($2->getType()))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Trying to free nonpointer type " +
|
2006-12-03 13:45:44 +08:00
|
|
|
$2->getType()->getDescription() + "!");
|
|
|
|
$$ = new FreeInst($2);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2001-06-07 04:29:01 +08:00
|
|
|
}
|
|
|
|
|
2003-09-09 02:20:29 +08:00
|
|
|
| OptVolatile LOAD Types ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$3)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isa<PointerType>($3->get()))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Can't load from nonpointer type: " +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$3)->getDescription());
|
|
|
|
if (!cast<PointerType>($3->get())->getElementType()->isFirstClassType())
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Can't load from pointer of non-first-class type: " +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$3)->getDescription());
|
|
|
|
Value* tmpVal = getVal(*$3, $4);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-09-29 03:28:24 +08:00
|
|
|
$$ = new LoadInst(tmpVal, "", $1);
|
2006-12-03 13:45:44 +08:00
|
|
|
delete $3;
|
2001-07-09 05:10:27 +08:00
|
|
|
}
|
2003-09-09 02:20:29 +08:00
|
|
|
| OptVolatile STORE ResolvedVal ',' Types ValueRef {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$5)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
const PointerType *PT = dyn_cast<PointerType>($5->get());
|
2003-09-02 00:31:28 +08:00
|
|
|
if (!PT)
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Can't store to a nonpointer type: " +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$5)->getDescription());
|
2003-09-02 00:31:28 +08:00
|
|
|
const Type *ElTy = PT->getElementType();
|
2006-12-03 13:45:44 +08:00
|
|
|
if (ElTy != $3->getType())
|
|
|
|
GEN_ERROR("Can't store '" + $3->getType()->getDescription() +
|
2001-12-15 00:28:42 +08:00
|
|
|
"' into space of type '" + ElTy->getDescription() + "'!");
|
2002-08-22 07:51:21 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
Value* tmpVal = getVal(*$5, $6);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new StoreInst($3, tmpVal, $1);
|
|
|
|
delete $5;
|
2001-07-09 07:22:50 +08:00
|
|
|
}
|
2001-11-27 00:54:11 +08:00
|
|
|
| GETELEMENTPTR Types ValueRef IndexList {
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
if (!UpRefs.empty())
|
|
|
|
GEN_ERROR("Invalid upreference in type: " + (*$2)->getDescription());
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!isa<PointerType>($2->get()))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("getelementptr insn requires pointer operand!");
|
2004-04-05 09:30:04 +08:00
|
|
|
|
2006-12-03 13:45:44 +08:00
|
|
|
if (!GetElementPtrInst::getIndexedType(*$2, *$4, true))
|
2006-08-18 16:43:06 +08:00
|
|
|
GEN_ERROR("Invalid getelementptr indices for type '" +
|
2006-12-03 13:45:44 +08:00
|
|
|
(*$2)->getDescription()+ "'!");
|
|
|
|
Value* tmpVal = getVal(*$2, $3);
|
2006-08-18 16:43:06 +08:00
|
|
|
CHECK_FOR_ERROR
|
2006-12-03 13:45:44 +08:00
|
|
|
$$ = new GetElementPtrInst(tmpVal, *$4);
|
|
|
|
delete $2;
|
2006-09-29 03:28:24 +08:00
|
|
|
delete $4;
|
2002-06-05 05:58:56 +08:00
|
|
|
};
|
2001-07-09 05:10:27 +08:00
|
|
|
|
2003-11-12 06:41:34 +08:00
|
|
|
|
2001-06-07 04:29:01 +08:00
|
|
|
%%
|
2006-08-18 16:43:06 +08:00
|
|
|
|
For PR950:
Major reorganization. This patch introduces the signedness changes for
the new integer types (i8, i16, i32, i64) which replace the old signed
versions (ubyte, sbyte, ushort, short, etc). This patch also implements
the function type parameter attributes feature. Together these conspired
to introduce new reduce/reduce errors into the grammar. Consequently, it
was necessary to introduce a new keyword into the grammar in order to
disambiguate. Without this, yacc would make incorrect shift/reduce and
reduce/reduce decisions and fail to parse the intended assembly.
Changes in assembly:
1. The "implementation" keyword is superfluous but still supported. You
can use it as a sentry which will ensure there are no remaining up
reference types. However, this is optional as those checks are also
performed elsewhere.
2. Parameter attributes are now implemented using an at sign to
indicate the attribute. The attributes are placed after the type
in a function declaration or after the argument value in a function
call. For example:
i8 @sext %myfunc(i16 @zext)
call i8 @sext %myfunc(i16 @zext %someVal)
The facility is available for supporting additional attributes and
they can be combined using the @(attr1,attr2,attr3) syntax. Right
now the only two supported are @sext and @zext
3. Functions must now be defined with the "define" keyword which is
analagous to the "declare" keyword for function declarations. The
introduction of this keyword disambiguates situations where a
named result type is confused with a new type or gvar definition.
For example:
%MyType = type i16
%MyType %func(%MyType) { ... }
With the introduction of optional parameter attributes between
the function name and the function result type, yacc will pick
the wrong rule to reduce unless it is disambiguated with "define"
before the function definition, as in:
define %MyType @zext %func(%MyType %someArg) { ... }
llvm-svn: 32781
2006-12-31 13:40:12 +08:00
|
|
|
// common code from the two 'RunVMAsmParser' functions
|
|
|
|
static Module* RunParser(Module * M) {
|
|
|
|
|
|
|
|
llvmAsmlineno = 1; // Reset the current line number...
|
|
|
|
CurModule.CurrentModule = M;
|
|
|
|
#if YYDEBUG
|
|
|
|
yydebug = Debug;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// Check to make sure the parser succeeded
|
|
|
|
if (yyparse()) {
|
|
|
|
if (ParserResult)
|
|
|
|
delete ParserResult;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check to make sure that parsing produced a result
|
|
|
|
if (!ParserResult)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
// Reset ParserResult variable while saving its value for the result.
|
|
|
|
Module *Result = ParserResult;
|
|
|
|
ParserResult = 0;
|
|
|
|
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2006-08-18 16:43:06 +08:00
|
|
|
void llvm::GenerateError(const std::string &message, int LineNo) {
|
|
|
|
if (LineNo == -1) LineNo = llvmAsmlineno;
|
|
|
|
// TODO: column number in exception
|
|
|
|
if (TheParseError)
|
|
|
|
TheParseError->setError(CurFilename, message, LineNo);
|
|
|
|
TriggerError = 1;
|
|
|
|
}
|
|
|
|
|
2001-07-08 12:57:15 +08:00
|
|
|
int yyerror(const char *ErrorMsg) {
|
2003-04-23 02:42:41 +08:00
|
|
|
std::string where
|
|
|
|
= std::string((CurFilename == "-") ? std::string("<stdin>") : CurFilename)
|
2002-07-15 06:59:28 +08:00
|
|
|
+ ":" + utostr((unsigned) llvmAsmlineno) + ": ";
|
2003-04-23 02:42:41 +08:00
|
|
|
std::string errMsg = std::string(ErrorMsg) + "\n" + where + " while reading ";
|
2004-03-31 04:58:25 +08:00
|
|
|
if (yychar == YYEMPTY || yychar == 0)
|
2002-07-15 06:59:28 +08:00
|
|
|
errMsg += "end-of-file.";
|
|
|
|
else
|
2003-04-23 02:42:41 +08:00
|
|
|
errMsg += "token: '" + std::string(llvmAsmtext, llvmAsmleng) + "'";
|
2006-08-18 16:43:06 +08:00
|
|
|
GenerateError(errMsg);
|
2001-06-07 04:29:01 +08:00
|
|
|
return 0;
|
|
|
|
}
|