namespace llvm {
-
-SignedType *SignedType::SByteTy = 0;
-SignedType *SignedType::SShortTy = 0;
-SignedType *SignedType::SIntTy = 0;
-SignedType *SignedType::SLongTy = 0;
-
-inline bool SignedType::classof(const Type *T) {
- if (T->getTypeID() != IntegerTyID)
- return false;
- return (T == SByteTy || T == SShortTy || T == SIntTy || T == SLongTy );
-}
-
-SignedType::SignedType(const IntegerType* ITy)
- : IntegerType(ITy->getBitWidth()), base_type(ITy)
-{
-}
-
-const SignedType *SignedType::get(const IntegerType* ITy) {
- if (ITy == Type::Int8Ty) {
- if (!SByteTy)
- SByteTy = new SignedType(IntegerType::get(8));
- return SByteTy;
- } else if (ITy == Type::Int16Ty) {
- if (!SShortTy)
- SShortTy = new SignedType(IntegerType::get(16));
- return SShortTy;
- } else if (ITy == Type::Int32Ty) {
- if (!SIntTy)
- SIntTy = new SignedType(IntegerType::get(32));
- return SIntTy;
- } else if (ITy == Type::Int64Ty) {
- if (!SLongTy)
- SLongTy = new SignedType(IntegerType::get(64));
- return SLongTy;
- } else
- assert(0 && "Invalid integer type for SignedType::get");
-}
-
-static inline Signedness getSign(const Type *&Ty) {
- if (const SignedType *STy = dyn_cast<SignedType>(Ty)) {
- Ty = STy->getBaseType();
- return Signed;
- } else if (isa<IntegerType>(Ty))
- return Unsigned;
- return Signless;
-}
-
-static const Type*
-resolveTypeImpl(const Type* Ty, std::vector<const Type*>& TyStack)
-{
- // Nothing to resolve if it isn't a derived type
- if (!Ty->isDerivedType())
- return Ty;
-
- // Prevent infinite recursion for recursive types
- for (std::vector<const Type*>::const_iterator I = TyStack.begin(),
- E = TyStack.end(); I != E; ++I)
- if (Ty == *I)
- return Ty;
-
- // Okay, haven't seen this derived type yet, push it on the stack.
- const Type* Result = Ty;
- TyStack.push_back(Ty);
-
- // Process the type
- switch (Ty->getTypeID()) {
- default: assert(0 && "Invalid derived type");
- case Type::IntegerTyID:
- break;
- case Type::FunctionTyID: {
- const FunctionType* FTy = cast<FunctionType>(Ty);
- const Type* RetTy = resolveTypeImpl(FTy->getReturnType(), TyStack);
- std::vector<const Type*> Types;
- FunctionType::ParamAttrsList Attrs;
- Attrs.push_back(FTy->getParamAttrs(0));
- for (unsigned i = 0; i < FTy->getNumParams(); ++i) {
- Types.push_back(resolveTypeImpl(FTy->getParamType(i), TyStack));
- Attrs.push_back(FTy->getParamAttrs(i+1));
- }
- Result = FunctionType::get(RetTy, Types, FTy->isVarArg(), Attrs);
- break;
- }
- case Type::StructTyID:
- case Type::PackedStructTyID: {
- const StructType *STy = cast<StructType>(Ty);
- std::vector<const Type*> FieldTypes;
- for (unsigned i = 0; i < STy->getNumElements(); ++i)
- FieldTypes.push_back(resolveTypeImpl(STy->getElementType(i), TyStack));
- Result = StructType::get(FieldTypes, STy->isPacked());
- break;
- }
- case Type::ArrayTyID: {
- const ArrayType *ATy = cast<ArrayType>(Ty);
- uint64_t NElems = ATy->getNumElements();
- const Type *ElemTy = resolveTypeImpl(ATy->getElementType(), TyStack);
- Result = ArrayType::get(ElemTy, NElems);
- break;
- }
- case Type::PointerTyID: {
- const PointerType *PTy = cast<PointerType>(Ty);
- const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
- Result = PointerType::get(ElemTy);
- break;
- }
- case Type::PackedTyID: {
- const PackedType *PTy = cast<PackedType>(Ty);
- unsigned NElems = PTy->getNumElements();
- const Type *ElemTy = resolveTypeImpl(PTy->getElementType(), TyStack);
- Result = PackedType::get(ElemTy, NElems);
- break;
- }
- }
- // Done with it, pop it off.
- TyStack.pop_back();
- return Result;
-}
-
-static inline const Type* resolveType(const Type* Ty) {
- if (!Ty)
- return 0;
- if (const SignedType* STy = dyn_cast<SignedType>(Ty))
- return STy->getBaseType();
- std::vector<const Type*> TyStack;
- return resolveTypeImpl(Ty, TyStack);
-}
-
std::istream* LexInput;
static std::string CurFilename;
static BasicBlock *CurBB;
static GlobalVariable *CurGV;
-
-
// This contains info used when building the body of a function. It is
// destroyed when the function is completed.
//
std::map<BasicBlock*, std::pair<ValID, int> > BBForwardRefs;
std::vector<BasicBlock*> NumberedBlocks;
RenameMapType RenameMap;
- std::set<Value*> SignedValues;
unsigned NextBBNum;
inline PerFunctionInfo() {
Values.clear(); // Clear out function local definitions
RenameMap.clear();
- SignedValues.clear();
CurrentFunction = 0;
isDeclare = false;
Linkage = GlobalValue::ExternalLinkage;
return List.size()-1;
}
-static const Type *getTypeVal(const ValID &D, bool DoNotImprovise = false) {
+static const Type *getType(const ValID &D, bool DoNotImprovise = false) {
switch (D.Type) {
case ValID::NumberVal: // Is it a numbered definition?
// Module constants occupy the lowest numbered slots...
// 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...
- assert(!isa<SignedType>(Ty) && "Can't create value with SignedType");
V = new Argument(Ty);
// Remember where this forward reference came from. FIXME, shouldn't we try
return;
}
- assert(!isa<SignedType>(V->getType()) && "Shouldn't have SignedType Value");
assert(inFunctionScope() && "Must be in function scope");
// Search the function's symbol table for an existing value of this name
// ValueRef - Unresolved reference to a definition or BB
%type <ValIDVal> ValueRef ConstValueRef SymbolicValueRef
%type <ValueVal> ResolvedVal // <type> <valref> pair
+
// Tokens and types for handling constant integer values
//
// ESINT64VAL - A negative number within long long range
%token <OtherOpVal> EXTRACTELEMENT INSERTELEMENT SHUFFLEVECTOR
%token VAARG_old VANEXT_old //OBSOLETE
+// Support for ICmp/FCmp Predicates, which is 1.9++ but not 2.0
%type <IPred> IPredicates
%type <FPred> FPredicates
%token EQ NE SLT SGT SLE SGE ULT UGT ULE UGE
$$.S = Signless;
}
| SymbolicValueRef { // Named types are also simple types...
- const Type* tmp = getTypeVal($1);
+ const Type* tmp = getType($1);
$$.T = new PATypeHolder(tmp);
$$.S = Signless; // FIXME: what if its signed?
}
projects / oota-llvm.git / blobdiff