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

Remove support for Not ConstantExpr. This simplifies the unary case to only

Browse Source 
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:
Chris Lattner 2002-08-14 18:24:09 +00:00
parent 9b2b80fd48
commit ad333484ea
8 changed files with 19 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Constants.h
View File

@ -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);

2
lib/AsmParser/llvmAsmParser.y
View File

@ -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 ')' {

3
lib/Bytecode/Reader/ConstantReader.cpp
View File

@ -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);

9
lib/Bytecode/Reader/InstructionReader.cpp
View File

@ -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));

6
lib/Linker/LinkModules.cpp
View File

@ -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);

6
lib/Transforms/Utils/Linker.cpp
View File

@ -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);

16
lib/VMCore/Constants.cpp
View File

@ -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;
}

6
lib/VMCore/Linker.cpp
View File

@ -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);