mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-07-06 17:24:34 +00:00
land David Blaikie's patch to de-constify Type, with a few tweaks.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@135375 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
@ -99,7 +99,7 @@ namespace {
|
||||
|
||||
/// UnnamedStructIDs - This contains a unique ID for each struct that is
|
||||
/// either anonymous or has no name.
|
||||
DenseMap<const StructType*, unsigned> UnnamedStructIDs;
|
||||
DenseMap<StructType*, unsigned> UnnamedStructIDs;
|
||||
|
||||
public:
|
||||
static char ID;
|
||||
@ -152,20 +152,20 @@ namespace {
|
||||
return false;
|
||||
}
|
||||
|
||||
raw_ostream &printType(raw_ostream &Out, const Type *Ty,
|
||||
raw_ostream &printType(raw_ostream &Out, Type *Ty,
|
||||
bool isSigned = false,
|
||||
const std::string &VariableName = "",
|
||||
bool IgnoreName = false,
|
||||
const AttrListPtr &PAL = AttrListPtr());
|
||||
raw_ostream &printSimpleType(raw_ostream &Out, const Type *Ty,
|
||||
raw_ostream &printSimpleType(raw_ostream &Out, Type *Ty,
|
||||
bool isSigned,
|
||||
const std::string &NameSoFar = "");
|
||||
|
||||
void printStructReturnPointerFunctionType(raw_ostream &Out,
|
||||
const AttrListPtr &PAL,
|
||||
const PointerType *Ty);
|
||||
PointerType *Ty);
|
||||
|
||||
std::string getStructName(const StructType *ST);
|
||||
std::string getStructName(StructType *ST);
|
||||
|
||||
/// writeOperandDeref - Print the result of dereferencing the specified
|
||||
/// operand with '*'. This is equivalent to printing '*' then using
|
||||
@ -188,7 +188,7 @@ namespace {
|
||||
void writeOperandWithCast(Value* Operand, const ICmpInst &I);
|
||||
bool writeInstructionCast(const Instruction &I);
|
||||
|
||||
void writeMemoryAccess(Value *Operand, const Type *OperandType,
|
||||
void writeMemoryAccess(Value *Operand, Type *OperandType,
|
||||
bool IsVolatile, unsigned Alignment);
|
||||
|
||||
private :
|
||||
@ -200,7 +200,7 @@ namespace {
|
||||
void printIntrinsicDefinition(const Function &F, raw_ostream &Out);
|
||||
|
||||
void printModuleTypes();
|
||||
void printContainedStructs(const Type *Ty, SmallPtrSet<const Type *, 16> &);
|
||||
void printContainedStructs(Type *Ty, SmallPtrSet<Type *, 16> &);
|
||||
void printFloatingPointConstants(Function &F);
|
||||
void printFloatingPointConstants(const Constant *C);
|
||||
void printFunctionSignature(const Function *F, bool Prototype);
|
||||
@ -209,7 +209,7 @@ namespace {
|
||||
void printBasicBlock(BasicBlock *BB);
|
||||
void printLoop(Loop *L);
|
||||
|
||||
void printCast(unsigned opcode, const Type *SrcTy, const Type *DstTy);
|
||||
void printCast(unsigned opcode, Type *SrcTy, Type *DstTy);
|
||||
void printConstant(Constant *CPV, bool Static);
|
||||
void printConstantWithCast(Constant *CPV, unsigned Opcode);
|
||||
bool printConstExprCast(const ConstantExpr *CE, bool Static);
|
||||
@ -360,7 +360,7 @@ static std::string CBEMangle(const std::string &S) {
|
||||
return Result;
|
||||
}
|
||||
|
||||
std::string CWriter::getStructName(const StructType *ST) {
|
||||
std::string CWriter::getStructName(StructType *ST) {
|
||||
if (!ST->isAnonymous() && !ST->getName().empty())
|
||||
return CBEMangle("l_"+ST->getName().str());
|
||||
|
||||
@ -373,20 +373,20 @@ std::string CWriter::getStructName(const StructType *ST) {
|
||||
/// print it as "Struct (*)(...)", for struct return functions.
|
||||
void CWriter::printStructReturnPointerFunctionType(raw_ostream &Out,
|
||||
const AttrListPtr &PAL,
|
||||
const PointerType *TheTy) {
|
||||
const FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
|
||||
PointerType *TheTy) {
|
||||
FunctionType *FTy = cast<FunctionType>(TheTy->getElementType());
|
||||
std::string tstr;
|
||||
raw_string_ostream FunctionInnards(tstr);
|
||||
FunctionInnards << " (*) (";
|
||||
bool PrintedType = false;
|
||||
|
||||
FunctionType::param_iterator I = FTy->param_begin(), E = FTy->param_end();
|
||||
const Type *RetTy = cast<PointerType>(*I)->getElementType();
|
||||
Type *RetTy = cast<PointerType>(*I)->getElementType();
|
||||
unsigned Idx = 1;
|
||||
for (++I, ++Idx; I != E; ++I, ++Idx) {
|
||||
if (PrintedType)
|
||||
FunctionInnards << ", ";
|
||||
const Type *ArgTy = *I;
|
||||
Type *ArgTy = *I;
|
||||
if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
|
||||
assert(ArgTy->isPointerTy());
|
||||
ArgTy = cast<PointerType>(ArgTy)->getElementType();
|
||||
@ -408,7 +408,7 @@ void CWriter::printStructReturnPointerFunctionType(raw_ostream &Out,
|
||||
}
|
||||
|
||||
raw_ostream &
|
||||
CWriter::printSimpleType(raw_ostream &Out, const Type *Ty, bool isSigned,
|
||||
CWriter::printSimpleType(raw_ostream &Out, Type *Ty, bool isSigned,
|
||||
const std::string &NameSoFar) {
|
||||
assert((Ty->isPrimitiveType() || Ty->isIntegerTy() || Ty->isVectorTy()) &&
|
||||
"Invalid type for printSimpleType");
|
||||
@ -444,7 +444,7 @@ CWriter::printSimpleType(raw_ostream &Out, const Type *Ty, bool isSigned,
|
||||
" __attribute__((vector_size(64))) " + NameSoFar);
|
||||
|
||||
case Type::VectorTyID: {
|
||||
const VectorType *VTy = cast<VectorType>(Ty);
|
||||
VectorType *VTy = cast<VectorType>(Ty);
|
||||
return printSimpleType(Out, VTy->getElementType(), isSigned,
|
||||
" __attribute__((vector_size(" +
|
||||
utostr(TD->getTypeAllocSize(VTy)) + " ))) " + NameSoFar);
|
||||
@ -461,7 +461,7 @@ CWriter::printSimpleType(raw_ostream &Out, const Type *Ty, bool isSigned,
|
||||
// Pass the Type* and the variable name and this prints out the variable
|
||||
// declaration.
|
||||
//
|
||||
raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
|
||||
raw_ostream &CWriter::printType(raw_ostream &Out, Type *Ty,
|
||||
bool isSigned, const std::string &NameSoFar,
|
||||
bool IgnoreName, const AttrListPtr &PAL) {
|
||||
if (Ty->isPrimitiveType() || Ty->isIntegerTy() || Ty->isVectorTy()) {
|
||||
@ -471,14 +471,14 @@ raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
|
||||
|
||||
switch (Ty->getTypeID()) {
|
||||
case Type::FunctionTyID: {
|
||||
const FunctionType *FTy = cast<FunctionType>(Ty);
|
||||
FunctionType *FTy = cast<FunctionType>(Ty);
|
||||
std::string tstr;
|
||||
raw_string_ostream FunctionInnards(tstr);
|
||||
FunctionInnards << " (" << NameSoFar << ") (";
|
||||
unsigned Idx = 1;
|
||||
for (FunctionType::param_iterator I = FTy->param_begin(),
|
||||
E = FTy->param_end(); I != E; ++I) {
|
||||
const Type *ArgTy = *I;
|
||||
Type *ArgTy = *I;
|
||||
if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
|
||||
assert(ArgTy->isPointerTy());
|
||||
ArgTy = cast<PointerType>(ArgTy)->getElementType();
|
||||
@ -502,7 +502,7 @@ raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
|
||||
return Out;
|
||||
}
|
||||
case Type::StructTyID: {
|
||||
const StructType *STy = cast<StructType>(Ty);
|
||||
StructType *STy = cast<StructType>(Ty);
|
||||
|
||||
// Check to see if the type is named.
|
||||
if (!IgnoreName)
|
||||
@ -523,7 +523,7 @@ raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
|
||||
}
|
||||
|
||||
case Type::PointerTyID: {
|
||||
const PointerType *PTy = cast<PointerType>(Ty);
|
||||
PointerType *PTy = cast<PointerType>(Ty);
|
||||
std::string ptrName = "*" + NameSoFar;
|
||||
|
||||
if (PTy->getElementType()->isArrayTy() ||
|
||||
@ -537,7 +537,7 @@ raw_ostream &CWriter::printType(raw_ostream &Out, const Type *Ty,
|
||||
}
|
||||
|
||||
case Type::ArrayTyID: {
|
||||
const ArrayType *ATy = cast<ArrayType>(Ty);
|
||||
ArrayType *ATy = cast<ArrayType>(Ty);
|
||||
unsigned NumElements = ATy->getNumElements();
|
||||
if (NumElements == 0) NumElements = 1;
|
||||
// Arrays are wrapped in structs to allow them to have normal
|
||||
@ -560,7 +560,7 @@ void CWriter::printConstantArray(ConstantArray *CPA, bool Static) {
|
||||
// As a special case, print the array as a string if it is an array of
|
||||
// ubytes or an array of sbytes with positive values.
|
||||
//
|
||||
const Type *ETy = CPA->getType()->getElementType();
|
||||
Type *ETy = CPA->getType()->getElementType();
|
||||
bool isString = (ETy == Type::getInt8Ty(CPA->getContext()) ||
|
||||
ETy == Type::getInt8Ty(CPA->getContext()));
|
||||
|
||||
@ -682,7 +682,7 @@ static bool isFPCSafeToPrint(const ConstantFP *CFP) {
|
||||
/// Print out the casting for a cast operation. This does the double casting
|
||||
/// necessary for conversion to the destination type, if necessary.
|
||||
/// @brief Print a cast
|
||||
void CWriter::printCast(unsigned opc, const Type *SrcTy, const Type *DstTy) {
|
||||
void CWriter::printCast(unsigned opc, Type *SrcTy, Type *DstTy) {
|
||||
// Print the destination type cast
|
||||
switch (opc) {
|
||||
case Instruction::UIToFP:
|
||||
@ -917,7 +917,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
|
||||
}
|
||||
|
||||
if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
|
||||
const Type* Ty = CI->getType();
|
||||
Type* Ty = CI->getType();
|
||||
if (Ty == Type::getInt1Ty(CPV->getContext()))
|
||||
Out << (CI->getZExtValue() ? '1' : '0');
|
||||
else if (Ty == Type::getInt32Ty(CPV->getContext()))
|
||||
@ -1027,7 +1027,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
|
||||
printConstantArray(CA, Static);
|
||||
} else {
|
||||
assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
|
||||
const ArrayType *AT = cast<ArrayType>(CPV->getType());
|
||||
ArrayType *AT = cast<ArrayType>(CPV->getType());
|
||||
Out << '{';
|
||||
if (AT->getNumElements()) {
|
||||
Out << ' ';
|
||||
@ -1054,7 +1054,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
|
||||
printConstantVector(CV, Static);
|
||||
} else {
|
||||
assert(isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV));
|
||||
const VectorType *VT = cast<VectorType>(CPV->getType());
|
||||
VectorType *VT = cast<VectorType>(CPV->getType());
|
||||
Out << "{ ";
|
||||
Constant *CZ = Constant::getNullValue(VT->getElementType());
|
||||
printConstant(CZ, Static);
|
||||
@ -1074,7 +1074,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
|
||||
Out << ")";
|
||||
}
|
||||
if (isa<ConstantAggregateZero>(CPV) || isa<UndefValue>(CPV)) {
|
||||
const StructType *ST = cast<StructType>(CPV->getType());
|
||||
StructType *ST = cast<StructType>(CPV->getType());
|
||||
Out << '{';
|
||||
if (ST->getNumElements()) {
|
||||
Out << ' ';
|
||||
@ -1123,7 +1123,7 @@ void CWriter::printConstant(Constant *CPV, bool Static) {
|
||||
// care of detecting that case and printing the cast for the ConstantExpr.
|
||||
bool CWriter::printConstExprCast(const ConstantExpr* CE, bool Static) {
|
||||
bool NeedsExplicitCast = false;
|
||||
const Type *Ty = CE->getOperand(0)->getType();
|
||||
Type *Ty = CE->getOperand(0)->getType();
|
||||
bool TypeIsSigned = false;
|
||||
switch (CE->getOpcode()) {
|
||||
case Instruction::Add:
|
||||
@ -1175,7 +1175,7 @@ bool CWriter::printConstExprCast(const ConstantExpr* CE, bool Static) {
|
||||
void CWriter::printConstantWithCast(Constant* CPV, unsigned Opcode) {
|
||||
|
||||
// Extract the operand's type, we'll need it.
|
||||
const Type* OpTy = CPV->getType();
|
||||
Type* OpTy = CPV->getType();
|
||||
|
||||
// Indicate whether to do the cast or not.
|
||||
bool shouldCast = false;
|
||||
@ -1267,7 +1267,7 @@ std::string CWriter::GetValueName(const Value *Operand) {
|
||||
void CWriter::writeInstComputationInline(Instruction &I) {
|
||||
// We can't currently support integer types other than 1, 8, 16, 32, 64.
|
||||
// Validate this.
|
||||
const Type *Ty = I.getType();
|
||||
Type *Ty = I.getType();
|
||||
if (Ty->isIntegerTy() && (Ty!=Type::getInt1Ty(I.getContext()) &&
|
||||
Ty!=Type::getInt8Ty(I.getContext()) &&
|
||||
Ty!=Type::getInt16Ty(I.getContext()) &&
|
||||
@ -1330,7 +1330,7 @@ void CWriter::writeOperand(Value *Operand, bool Static) {
|
||||
// This function takes care of detecting that case and printing the cast
|
||||
// for the Instruction.
|
||||
bool CWriter::writeInstructionCast(const Instruction &I) {
|
||||
const Type *Ty = I.getOperand(0)->getType();
|
||||
Type *Ty = I.getOperand(0)->getType();
|
||||
switch (I.getOpcode()) {
|
||||
case Instruction::Add:
|
||||
case Instruction::Sub:
|
||||
@ -1362,7 +1362,7 @@ bool CWriter::writeInstructionCast(const Instruction &I) {
|
||||
void CWriter::writeOperandWithCast(Value* Operand, unsigned Opcode) {
|
||||
|
||||
// Extract the operand's type, we'll need it.
|
||||
const Type* OpTy = Operand->getType();
|
||||
Type* OpTy = Operand->getType();
|
||||
|
||||
// Indicate whether to do the cast or not.
|
||||
bool shouldCast = false;
|
||||
@ -1430,7 +1430,7 @@ void CWriter::writeOperandWithCast(Value* Operand, const ICmpInst &Cmp) {
|
||||
bool castIsSigned = Cmp.isSigned();
|
||||
|
||||
// If the operand was a pointer, convert to a large integer type.
|
||||
const Type* OpTy = Operand->getType();
|
||||
Type* OpTy = Operand->getType();
|
||||
if (OpTy->isPointerTy())
|
||||
OpTy = TD->getIntPtrType(Operand->getContext());
|
||||
|
||||
@ -2060,7 +2060,7 @@ void CWriter::printModuleTypes() {
|
||||
Out << '\n';
|
||||
|
||||
// Keep track of which structures have been printed so far.
|
||||
SmallPtrSet<const Type *, 16> StructPrinted;
|
||||
SmallPtrSet<Type *, 16> StructPrinted;
|
||||
|
||||
// Loop over all structures then push them into the stack so they are
|
||||
// printed in the correct order.
|
||||
@ -2077,8 +2077,8 @@ void CWriter::printModuleTypes() {
|
||||
//
|
||||
// TODO: Make this work properly with vector types
|
||||
//
|
||||
void CWriter::printContainedStructs(const Type *Ty,
|
||||
SmallPtrSet<const Type *, 16> &StructPrinted) {
|
||||
void CWriter::printContainedStructs(Type *Ty,
|
||||
SmallPtrSet<Type *, 16> &StructPrinted) {
|
||||
// Don't walk through pointers.
|
||||
if (Ty->isPointerTy() || Ty->isPrimitiveType() || Ty->isIntegerTy())
|
||||
return;
|
||||
@ -2088,7 +2088,7 @@ void CWriter::printContainedStructs(const Type *Ty,
|
||||
E = Ty->subtype_end(); I != E; ++I)
|
||||
printContainedStructs(*I, StructPrinted);
|
||||
|
||||
if (const StructType *ST = dyn_cast<StructType>(Ty)) {
|
||||
if (StructType *ST = dyn_cast<StructType>(Ty)) {
|
||||
// Check to see if we have already printed this struct.
|
||||
if (!StructPrinted.insert(Ty)) return;
|
||||
|
||||
@ -2120,7 +2120,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
|
||||
}
|
||||
|
||||
// Loop over the arguments, printing them...
|
||||
const FunctionType *FT = cast<FunctionType>(F->getFunctionType());
|
||||
FunctionType *FT = cast<FunctionType>(F->getFunctionType());
|
||||
const AttrListPtr &PAL = F->getAttributes();
|
||||
|
||||
std::string tstr;
|
||||
@ -2150,7 +2150,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
|
||||
ArgName = GetValueName(I);
|
||||
else
|
||||
ArgName = "";
|
||||
const Type *ArgTy = I->getType();
|
||||
Type *ArgTy = I->getType();
|
||||
if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
|
||||
ArgTy = cast<PointerType>(ArgTy)->getElementType();
|
||||
ByValParams.insert(I);
|
||||
@ -2177,7 +2177,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
|
||||
|
||||
for (; I != E; ++I) {
|
||||
if (PrintedArg) FunctionInnards << ", ";
|
||||
const Type *ArgTy = *I;
|
||||
Type *ArgTy = *I;
|
||||
if (PAL.paramHasAttr(Idx, Attribute::ByVal)) {
|
||||
assert(ArgTy->isPointerTy());
|
||||
ArgTy = cast<PointerType>(ArgTy)->getElementType();
|
||||
@ -2205,7 +2205,7 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
|
||||
FunctionInnards << ')';
|
||||
|
||||
// Get the return tpe for the function.
|
||||
const Type *RetTy;
|
||||
Type *RetTy;
|
||||
if (!isStructReturn)
|
||||
RetTy = F->getReturnType();
|
||||
else {
|
||||
@ -2222,8 +2222,8 @@ void CWriter::printFunctionSignature(const Function *F, bool Prototype) {
|
||||
static inline bool isFPIntBitCast(const Instruction &I) {
|
||||
if (!isa<BitCastInst>(I))
|
||||
return false;
|
||||
const Type *SrcTy = I.getOperand(0)->getType();
|
||||
const Type *DstTy = I.getType();
|
||||
Type *SrcTy = I.getOperand(0)->getType();
|
||||
Type *DstTy = I.getType();
|
||||
return (SrcTy->isFloatingPointTy() && DstTy->isIntegerTy()) ||
|
||||
(DstTy->isFloatingPointTy() && SrcTy->isIntegerTy());
|
||||
}
|
||||
@ -2237,7 +2237,7 @@ void CWriter::printFunction(Function &F) {
|
||||
|
||||
// If this is a struct return function, handle the result with magic.
|
||||
if (isStructReturn) {
|
||||
const Type *StructTy =
|
||||
Type *StructTy =
|
||||
cast<PointerType>(F.arg_begin()->getType())->getElementType();
|
||||
Out << " ";
|
||||
printType(Out, StructTy, false, "StructReturn");
|
||||
@ -2656,7 +2656,7 @@ void CWriter::visitFCmpInst(FCmpInst &I) {
|
||||
Out << ")";
|
||||
}
|
||||
|
||||
static const char * getFloatBitCastField(const Type *Ty) {
|
||||
static const char * getFloatBitCastField(Type *Ty) {
|
||||
switch (Ty->getTypeID()) {
|
||||
default: llvm_unreachable("Invalid Type");
|
||||
case Type::FloatTyID: return "Float";
|
||||
@ -2672,8 +2672,8 @@ static const char * getFloatBitCastField(const Type *Ty) {
|
||||
}
|
||||
|
||||
void CWriter::visitCastInst(CastInst &I) {
|
||||
const Type *DstTy = I.getType();
|
||||
const Type *SrcTy = I.getOperand(0)->getType();
|
||||
Type *DstTy = I.getType();
|
||||
Type *SrcTy = I.getOperand(0)->getType();
|
||||
if (isFPIntBitCast(I)) {
|
||||
Out << '(';
|
||||
// These int<->float and long<->double casts need to be handled specially
|
||||
@ -2719,7 +2719,7 @@ void CWriter::visitSelectInst(SelectInst &I) {
|
||||
|
||||
// Returns the macro name or value of the max or min of an integer type
|
||||
// (as defined in limits.h).
|
||||
static void printLimitValue(const IntegerType &Ty, bool isSigned, bool isMax,
|
||||
static void printLimitValue(IntegerType &Ty, bool isSigned, bool isMax,
|
||||
raw_ostream &Out) {
|
||||
const char* type;
|
||||
const char* sprefix = "";
|
||||
@ -2745,16 +2745,16 @@ static void printLimitValue(const IntegerType &Ty, bool isSigned, bool isMax,
|
||||
}
|
||||
|
||||
#ifndef NDEBUG
|
||||
static bool isSupportedIntegerSize(const IntegerType &T) {
|
||||
static bool isSupportedIntegerSize(IntegerType &T) {
|
||||
return T.getBitWidth() == 8 || T.getBitWidth() == 16 ||
|
||||
T.getBitWidth() == 32 || T.getBitWidth() == 64;
|
||||
}
|
||||
#endif
|
||||
|
||||
void CWriter::printIntrinsicDefinition(const Function &F, raw_ostream &Out) {
|
||||
const FunctionType *funT = F.getFunctionType();
|
||||
const Type *retT = F.getReturnType();
|
||||
const IntegerType *elemT = cast<IntegerType>(funT->getParamType(1));
|
||||
FunctionType *funT = F.getFunctionType();
|
||||
Type *retT = F.getReturnType();
|
||||
IntegerType *elemT = cast<IntegerType>(funT->getParamType(1));
|
||||
|
||||
assert(isSupportedIntegerSize(*elemT) &&
|
||||
"CBackend does not support arbitrary size integers.");
|
||||
@ -2908,8 +2908,8 @@ void CWriter::visitCallInst(CallInst &I) {
|
||||
|
||||
Value *Callee = I.getCalledValue();
|
||||
|
||||
const PointerType *PTy = cast<PointerType>(Callee->getType());
|
||||
const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
||||
PointerType *PTy = cast<PointerType>(Callee->getType());
|
||||
FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
|
||||
|
||||
// If this is a call to a struct-return function, assign to the first
|
||||
// parameter instead of passing it to the call.
|
||||
@ -3217,7 +3217,7 @@ void CWriter::visitInlineAsm(CallInst &CI) {
|
||||
std::vector<std::pair<Value*, int> > ResultVals;
|
||||
if (CI.getType() == Type::getVoidTy(CI.getContext()))
|
||||
;
|
||||
else if (const StructType *ST = dyn_cast<StructType>(CI.getType())) {
|
||||
else if (StructType *ST = dyn_cast<StructType>(CI.getType())) {
|
||||
for (unsigned i = 0, e = ST->getNumElements(); i != e; ++i)
|
||||
ResultVals.push_back(std::make_pair(&CI, (int)i));
|
||||
} else {
|
||||
@ -3348,7 +3348,7 @@ void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I,
|
||||
// Find out if the last index is into a vector. If so, we have to print this
|
||||
// specially. Since vectors can't have elements of indexable type, only the
|
||||
// last index could possibly be of a vector element.
|
||||
const VectorType *LastIndexIsVector = 0;
|
||||
VectorType *LastIndexIsVector = 0;
|
||||
{
|
||||
for (gep_type_iterator TmpI = I; TmpI != E; ++TmpI)
|
||||
LastIndexIsVector = dyn_cast<VectorType>(*TmpI);
|
||||
@ -3421,7 +3421,7 @@ void CWriter::printGEPExpression(Value *Ptr, gep_type_iterator I,
|
||||
Out << ")";
|
||||
}
|
||||
|
||||
void CWriter::writeMemoryAccess(Value *Operand, const Type *OperandType,
|
||||
void CWriter::writeMemoryAccess(Value *Operand, Type *OperandType,
|
||||
bool IsVolatile, unsigned Alignment) {
|
||||
|
||||
bool IsUnaligned = Alignment &&
|
||||
@ -3463,7 +3463,7 @@ void CWriter::visitStoreInst(StoreInst &I) {
|
||||
Out << " = ";
|
||||
Value *Operand = I.getOperand(0);
|
||||
Constant *BitMask = 0;
|
||||
if (const IntegerType* ITy = dyn_cast<IntegerType>(Operand->getType()))
|
||||
if (IntegerType* ITy = dyn_cast<IntegerType>(Operand->getType()))
|
||||
if (!ITy->isPowerOf2ByteWidth())
|
||||
// We have a bit width that doesn't match an even power-of-2 byte
|
||||
// size. Consequently we must & the value with the type's bit mask
|
||||
@ -3492,7 +3492,7 @@ void CWriter::visitVAArgInst(VAArgInst &I) {
|
||||
}
|
||||
|
||||
void CWriter::visitInsertElementInst(InsertElementInst &I) {
|
||||
const Type *EltTy = I.getType()->getElementType();
|
||||
Type *EltTy = I.getType()->getElementType();
|
||||
writeOperand(I.getOperand(0));
|
||||
Out << ";\n ";
|
||||
Out << "((";
|
||||
@ -3507,7 +3507,7 @@ void CWriter::visitInsertElementInst(InsertElementInst &I) {
|
||||
void CWriter::visitExtractElementInst(ExtractElementInst &I) {
|
||||
// We know that our operand is not inlined.
|
||||
Out << "((";
|
||||
const Type *EltTy =
|
||||
Type *EltTy =
|
||||
cast<VectorType>(I.getOperand(0)->getType())->getElementType();
|
||||
printType(Out, PointerType::getUnqual(EltTy));
|
||||
Out << ")(&" << GetValueName(I.getOperand(0)) << "))[";
|
||||
@ -3519,9 +3519,9 @@ void CWriter::visitShuffleVectorInst(ShuffleVectorInst &SVI) {
|
||||
Out << "(";
|
||||
printType(Out, SVI.getType());
|
||||
Out << "){ ";
|
||||
const VectorType *VT = SVI.getType();
|
||||
VectorType *VT = SVI.getType();
|
||||
unsigned NumElts = VT->getNumElements();
|
||||
const Type *EltTy = VT->getElementType();
|
||||
Type *EltTy = VT->getElementType();
|
||||
|
||||
for (unsigned i = 0; i != NumElts; ++i) {
|
||||
if (i) Out << ", ";
|
||||
@ -3557,7 +3557,7 @@ void CWriter::visitInsertValueInst(InsertValueInst &IVI) {
|
||||
Out << GetValueName(&IVI);
|
||||
for (const unsigned *b = IVI.idx_begin(), *i = b, *e = IVI.idx_end();
|
||||
i != e; ++i) {
|
||||
const Type *IndexedTy =
|
||||
Type *IndexedTy =
|
||||
ExtractValueInst::getIndexedType(IVI.getOperand(0)->getType(),
|
||||
ArrayRef<unsigned>(b, i+1));
|
||||
if (IndexedTy->isArrayTy())
|
||||
@ -3579,7 +3579,7 @@ void CWriter::visitExtractValueInst(ExtractValueInst &EVI) {
|
||||
Out << GetValueName(EVI.getOperand(0));
|
||||
for (const unsigned *b = EVI.idx_begin(), *i = b, *e = EVI.idx_end();
|
||||
i != e; ++i) {
|
||||
const Type *IndexedTy =
|
||||
Type *IndexedTy =
|
||||
ExtractValueInst::getIndexedType(EVI.getOperand(0)->getType(),
|
||||
ArrayRef<unsigned>(b, i+1));
|
||||
if (IndexedTy->isArrayTy())
|
||||
|
||||
Reference in New Issue
Block a user