6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-03-04 05:31:51 +00:00
Code Issues Projects Releases Wiki Activity

Eliminate yet another copy of getOpcode.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76236 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2009-07-17 20:58:59 +00:00
parent 8413b225a6
commit 8906f95006
1 changed files with 6 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
lib/CodeGen/ScheduleDAGInstrs.cpp
View File

@ -14,7 +14,7 @@
#define DEBUG_TYPE "sched-instrs"
#include "ScheduleDAGInstrs.h"
#include "llvm/Constants.h"
#include "llvm/Operator.h"
#include "llvm/Analysis/AliasAnalysis.h"
#include "llvm/CodeGen/MachineFunctionPass.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
@ -46,25 +46,14 @@ void ScheduleDAGInstrs::Run(MachineBasicBlock *bb,
ScheduleDAG::Run(bb, end);
}
/// getOpcode - If this is an Instruction or a ConstantExpr, return the
/// opcode value. Otherwise return UserOp1.
static unsigned getOpcode(const Value *V) {
if (const Instruction *I = dyn_cast<Instruction>(V))
return I->getOpcode();
if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
return CE->getOpcode();
// Use UserOp1 to mean there's no opcode.
return Instruction::UserOp1;
}
/// getUnderlyingObjectFromInt - This is the function that does the work of
/// looking through basic ptrtoint+arithmetic+inttoptr sequences.
static const Value *getUnderlyingObjectFromInt(const Value *V) {
do {
if (const User *U = dyn_cast<User>(V)) {
if (const Operator *U = dyn_cast<Operator>(V)) {
// If we find a ptrtoint, we can transfer control back to the
// regular getUnderlyingObjectFromInt.
if (getOpcode(U) == Instruction::PtrToInt)
if (U->getOpcode() == Instruction::PtrToInt)
return U->getOperand(0);
// If we find an add of a constant or a multiplied value, it's
// likely that the other operand will lead us to the base
@ -72,9 +61,9 @@ static const Value *getUnderlyingObjectFromInt(const Value *V) {
// object address is somehow being computed bt the multiply,
// because our callers only care when the result is an
// identifibale object.
if (getOpcode(U) != Instruction::Add ||
if (U->getOpcode() != Instruction::Add ||
(!isa<ConstantInt>(U->getOperand(1)) &&
getOpcode(U->getOperand(1)) != Instruction::Mul))
Operator::getOpcode(U->getOperand(1)) != Instruction::Mul))
return V;
V = U->getOperand(0);
} else {
@ -91,7 +80,7 @@ static const Value *getUnderlyingObject(const Value *V) {
do {
V = V->getUnderlyingObject();
// If it found an inttoptr, use special code to continue climing.
if (getOpcode(V) != Instruction::IntToPtr)
if (Operator::getOpcode(V) != Instruction::IntToPtr)
break;
const Value *O = getUnderlyingObjectFromInt(cast<User>(V)->getOperand(0));
// If that succeeded in finding a pointer, continue the search.