mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-18 12:29:21 +00:00
Remove support for Not ConstantExpr. This simplifies the unary case to only
have to support the cast instruction, so the function is renamed to getCast. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3328 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
parent
9b2b80fd48
commit
ad333484ea
@ -431,8 +431,8 @@ protected:
|
||||
public:
|
||||
// Static methods to construct a ConstantExpr of different kinds.
|
||||
|
||||
// Unary constant expr - Use with unary operators and casts
|
||||
static ConstantExpr *get(unsigned Opcode, Constant *C, const Type *Ty);
|
||||
// Cast constant expr
|
||||
static ConstantExpr *getCast(Constant *C, const Type *Ty);
|
||||
|
||||
// Binary constant expr - Use with binary operators...
|
||||
static ConstantExpr *get(unsigned Opcode, Constant *C1, Constant *C2);
|
||||
|
@ -962,7 +962,7 @@ ConstVal: Types '[' ConstVector ']' { // Nonempty unsized arr
|
||||
|
||||
// FIXME: ConstExpr::get never return null! Do checking here in the parser.
|
||||
ConstExpr: Types CAST ConstVal {
|
||||
$$ = ConstantExpr::get(Instruction::Cast, $3, $1->get());
|
||||
$$ = ConstantExpr::getCast($3, $1->get());
|
||||
delete $1;
|
||||
}
|
||||
| Types GETELEMENTPTR '(' ConstVal IndexList ')' {
|
||||
|
@ -217,7 +217,8 @@ bool BytecodeParser::parseConstantValue(const uchar *&Buf, const uchar *EndBuf,
|
||||
|
||||
// Construct a ConstantExpr of the appropriate kind
|
||||
if (isExprNumArgs == 1) { // All one-operand expressions
|
||||
V = ConstantExpr::get(Opcode, ArgVec[0], Ty);
|
||||
assert(Opcode == Instruction::Cast);
|
||||
V = ConstantExpr::getCast(ArgVec[0], Ty);
|
||||
} else if (Opcode == Instruction::GetElementPtr) { // GetElementPtr
|
||||
std::vector<Constant*> IdxList(ArgVec.begin()+1, ArgVec.end());
|
||||
V = ConstantExpr::getGetElementPtr(ArgVec[0], IdxList);
|
||||
|
@ -122,13 +122,8 @@ bool BytecodeParser::ParseInstruction(const uchar *&Buf, const uchar *EndBuf,
|
||||
if (ParseRawInst(Buf, EndBuf, Raw))
|
||||
return failure(true);
|
||||
|
||||
if (Raw.Opcode >= Instruction::FirstUnaryOp &&
|
||||
Raw.Opcode < Instruction::NumUnaryOps && Raw.NumOperands == 1) {
|
||||
Res = UnaryOperator::create((Instruction::UnaryOps)Raw.Opcode,
|
||||
getValue(Raw.Ty,Raw.Arg1));
|
||||
return false;
|
||||
} else if (Raw.Opcode >= Instruction::FirstBinaryOp &&
|
||||
Raw.Opcode < Instruction::NumBinaryOps && Raw.NumOperands == 2) {
|
||||
if (Raw.Opcode >= Instruction::FirstBinaryOp &&
|
||||
Raw.Opcode < Instruction::NumBinaryOps && Raw.NumOperands == 2) {
|
||||
Res = BinaryOperator::create((Instruction::BinaryOps)Raw.Opcode,
|
||||
getValue(Raw.Ty, Raw.Arg1),
|
||||
getValue(Raw.Ty, Raw.Arg2));
|
||||
|
@ -119,10 +119,10 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
|
||||
Result = ConstantPointerRef::get(cast<GlobalValue>(V));
|
||||
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
|
||||
if (CE->getNumOperands() == 1) {
|
||||
// Cast instruction, unary operator
|
||||
// Cast instruction
|
||||
assert(CE->getOpcode() == Instruction::Cast);
|
||||
Value *V = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap);
|
||||
Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V),
|
||||
CE->getType());
|
||||
Result = ConstantExpr::getCast(cast<Constant>(V), CE->getType());
|
||||
} else if (CE->getNumOperands() == 2) {
|
||||
// Binary operator...
|
||||
Value *V1 = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap);
|
||||
|
@ -119,10 +119,10 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
|
||||
Result = ConstantPointerRef::get(cast<GlobalValue>(V));
|
||||
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
|
||||
if (CE->getNumOperands() == 1) {
|
||||
// Cast instruction, unary operator
|
||||
// Cast instruction
|
||||
assert(CE->getOpcode() == Instruction::Cast);
|
||||
Value *V = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap);
|
||||
Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V),
|
||||
CE->getType());
|
||||
Result = ConstantExpr::getCast(cast<Constant>(V), CE->getType());
|
||||
} else if (CE->getNumOperands() == 2) {
|
||||
// Binary operator...
|
||||
Value *V1 = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap);
|
||||
|
@ -466,26 +466,16 @@ ConstantPointerRef *ConstantPointerRef::get(GlobalValue *GV) {
|
||||
typedef pair<unsigned, vector<Constant*> > ExprMapKeyType;
|
||||
static ValueMap<const ExprMapKeyType, ConstantExpr> ExprConstants;
|
||||
|
||||
ConstantExpr *ConstantExpr::get(unsigned Opcode, Constant *C, const Type *Ty) {
|
||||
ConstantExpr *ConstantExpr::getCast(Constant *C, const Type *Ty) {
|
||||
|
||||
// Look up the constant in the table first to ensure uniqueness
|
||||
vector<Constant*> argVec(1, C);
|
||||
const ExprMapKeyType &Key = make_pair(Opcode, argVec);
|
||||
const ExprMapKeyType &Key = make_pair(Instruction::Cast, argVec);
|
||||
ConstantExpr *Result = ExprConstants.get(Ty, Key);
|
||||
if (Result) return Result;
|
||||
|
||||
// Its not in the table so create a new one and put it in the table.
|
||||
// Check the operands for consistency first
|
||||
assert(Opcode == Instruction::Cast ||
|
||||
(Opcode >= Instruction::FirstUnaryOp &&
|
||||
Opcode < Instruction::NumUnaryOps) &&
|
||||
"Invalid opcode in unary ConstantExpr!");
|
||||
|
||||
// type of operand will not match result for Cast operation
|
||||
assert((Opcode == Instruction::Cast || Ty == C->getType()) &&
|
||||
"Type of operand in unary constant expression should match result");
|
||||
|
||||
Result = new ConstantExpr(Opcode, C, Ty);
|
||||
Result = new ConstantExpr(Instruction::Cast, C, Ty);
|
||||
ExprConstants.add(Ty, Key, Result);
|
||||
return Result;
|
||||
}
|
||||
|
@ -119,10 +119,10 @@ static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
|
||||
Result = ConstantPointerRef::get(cast<GlobalValue>(V));
|
||||
} else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) {
|
||||
if (CE->getNumOperands() == 1) {
|
||||
// Cast instruction, unary operator
|
||||
// Cast instruction
|
||||
assert(CE->getOpcode() == Instruction::Cast);
|
||||
Value *V = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap);
|
||||
Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V),
|
||||
CE->getType());
|
||||
Result = ConstantExpr::getCast(cast<Constant>(V), CE->getType());
|
||||
} else if (CE->getNumOperands() == 2) {
|
||||
// Binary operator...
|
||||
Value *V1 = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap);
|
||||
|
Loading…
Reference in New Issue
Block a user