replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make MachineOperand's value named 'contents'. Make really, really sure 

it is always completely initialized and copied.
Also, fix up many comments and asserts.

llvm-svn: 12100
This commit is contained in:
Brian Gaeke 2004-03-03 19:07:27 +00:00
parent 3001c6e264
commit 015972103d
2 changed files with 105 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
llvm/include/llvm/CodeGen/MachineInstr.h
View File

@ -121,60 +121,69 @@ private:
MachineBasicBlock *MBB; // For MO_MachineBasicBlock type
std::string *SymbolName; // For MO_ExternalSymbol type
};
} contents;
char flags; // see bit field definitions above
MachineOperandType opType:8; // Pack into 8 bits efficiently after flags.
int regNum; // register number for an explicit register
// will be set for a value after reg allocation
private:
void zeroContents () {
memset (&contents, 0, sizeof (contents));
}
MachineOperand(int ImmVal = 0, MachineOperandType OpTy = MO_VirtualRegister)
: immedVal(ImmVal),
flags(0),
opType(OpTy),
regNum(-1) {}
: flags(0), opType(OpTy), regNum(-1) {
zeroContents ();
}
MachineOperand(int Reg, MachineOperandType OpTy, UseType UseTy)
: immedVal(0), flags(UseTy), opType(OpTy), regNum(Reg) { }
: flags(UseTy), opType(OpTy), regNum(Reg) {
zeroContents ();
}
MachineOperand(Value *V, MachineOperandType OpTy, UseType UseTy,
bool isPCRelative = false)
: value(V),
flags(UseTy | (isPCRelative ? PCRELATIVE : 0)),
opType(OpTy),
regNum(-1) {
: flags(UseTy | (isPCRelative?PCRELATIVE:0)), opType(OpTy), regNum(-1) {
zeroContents ();
contents.value = V;
}
MachineOperand(MachineBasicBlock *mbb)
: MBB(mbb), flags(0), opType(MO_MachineBasicBlock), regNum(-1) { }
: flags(0), opType(MO_MachineBasicBlock), regNum(-1) {
zeroContents ();
contents.MBB = mbb;
}
MachineOperand(const std::string &SymName, bool isPCRelative)
: SymbolName(new std::string(SymName)), flags(isPCRelative ? PCRELATIVE :0),
opType(MO_ExternalSymbol), regNum(-1) {}
: flags(isPCRelative?PCRELATIVE:0), opType(MO_ExternalSymbol), regNum(-1) {
zeroContents ();
contents.SymbolName = new std::string (SymName);
}
public:
MachineOperand(const MachineOperand &M) : immedVal(M.immedVal),
flags(M.flags),
opType(M.opType),
regNum(M.regNum) {
MachineOperand(const MachineOperand &M)
: flags(M.flags), opType(M.opType), regNum(M.regNum) {
zeroContents ();
contents = M.contents;
if (isExternalSymbol())
SymbolName = new std::string(M.getSymbolName());
contents.SymbolName = new std::string(M.getSymbolName());
}
~MachineOperand() {
if (isExternalSymbol())
delete SymbolName;
delete contents.SymbolName;
}
const MachineOperand &operator=(const MachineOperand &MO) {
if (isExternalSymbol()) // if old operand had a symbol name,
delete SymbolName; // release old memory
immedVal = MO.immedVal;
delete contents.SymbolName; // release old memory
contents = MO.contents;
flags = MO.flags;
opType = MO.opType;
regNum = MO.regNum;
if (isExternalSymbol())
SymbolName = new std::string(MO.getSymbolName());
contents.SymbolName = new std::string(MO.getSymbolName());
return *this;
}
@ -184,9 +193,7 @@ public:
/// getUseType - Returns the MachineOperandUseType of this operand.
///
UseType getUseType() const {
return UseType(flags & (USEFLAG|DEFFLAG));
}
UseType getUseType() const { return UseType(flags & (USEFLAG|DEFFLAG)); }
/// isPCRelative - This returns the value of the PCRELATIVE flag, which
/// indicates whether this operand should be emitted as a PC relative value
@ -205,6 +212,8 @@ public:
return opType == MO_MachineRegister || opType == MO_VirtualRegister;
}
/// Accessors that tell you what kind of MachineOperand you're looking at.
///
bool isMachineBasicBlock() const { return opType == MO_MachineBasicBlock; }
bool isPCRelativeDisp() const { return opType == MO_PCRelativeDisp; }
bool isImmediate() const {
@ -215,42 +224,54 @@ public:
bool isGlobalAddress() const { return opType == MO_GlobalAddress; }
bool isExternalSymbol() const { return opType == MO_ExternalSymbol; }
Value* getVRegValue() const {
assert(opType == MO_VirtualRegister || opType == MO_CCRegister ||
isPCRelativeDisp());
return value;
}
/// getVRegValueOrNull - Get the Value* out of a MachineOperand if it
/// has one. This is deprecated and only used by the SPARC v9 backend.
///
Value* getVRegValueOrNull() const {
return (opType == MO_VirtualRegister || opType == MO_CCRegister ||
isPCRelativeDisp()) ? value : NULL;
isPCRelativeDisp()) ? contents.value : NULL;
}
/// MachineOperand accessors that only work on certain types of
/// MachineOperand...
///
Value* getVRegValue() const {
assert ((opType == MO_VirtualRegister || opType == MO_CCRegister
|| isPCRelativeDisp()) && "Wrong MachineOperand accessor");
return contents.value;
}
int getMachineRegNum() const {
assert(opType == MO_MachineRegister);
assert(opType == MO_MachineRegister && "Wrong MachineOperand accessor");
return regNum;
}
int getImmedValue() const { assert(isImmediate()); return immedVal; }
void setImmedValue(int ImmVal) { assert(isImmediate()); immedVal = ImmVal; }
int getImmedValue() const {
assert(isImmediate() && "Wrong MachineOperand accessor");
return contents.immedVal;
}
MachineBasicBlock *getMachineBasicBlock() const {
assert(isMachineBasicBlock() && "Can't get MBB in non-MBB operand!");
return MBB;
assert(isMachineBasicBlock() && "Wrong MachineOperand accessor");
return contents.MBB;
}
int getFrameIndex() const {
assert(isFrameIndex() && "Wrong MachineOperand accessor");
return contents.immedVal;
}
int getFrameIndex() const { assert(isFrameIndex()); return immedVal; }
unsigned getConstantPoolIndex() const {
assert(isConstantPoolIndex());
return immedVal;
assert(isConstantPoolIndex() && "Wrong MachineOperand accessor");
return contents.immedVal;
}
GlobalValue *getGlobal() const {
assert(isGlobalAddress());
return (GlobalValue*)value;
assert(isGlobalAddress() && "Wrong MachineOperand accessor");
return (GlobalValue*)contents.value;
}
const std::string &getSymbolName() const {
assert(isExternalSymbol());
return *SymbolName;
assert(isExternalSymbol() && "Wrong MachineOperand accessor");
return *contents.SymbolName;
}
/// MachineOperand methods for testing that work on any kind of
/// MachineOperand...
///
bool isUse () const { return flags & USEFLAG; }
MachineOperand& setUse () { flags |= USEFLAG; return *this; }
bool isDef () const { return flags & DEFFLAG; }
@ -260,38 +281,52 @@ public:
bool isHiBits64 () const { return flags & HIFLAG64; }
bool isLoBits64 () const { return flags & LOFLAG64; }
// used to check if a machine register has been allocated to this operand
/// hasAllocatedReg - Returns true iff a machine register has been
/// allocated to this operand.
///
bool hasAllocatedReg() const {
return (regNum >= 0 &&
(opType == MO_VirtualRegister || opType == MO_CCRegister ||
opType == MO_MachineRegister));
}
// used to get the reg number if when one is allocated
/// getReg - Returns the register number. It is a runtime error to call this
/// if a register is not allocated.
///
unsigned getReg() const {
assert(hasAllocatedReg());
return regNum;
}
// ********** TODO: get rid of this duplicate code! ***********
/// MachineOperand mutators...
///
void setReg(unsigned Reg) {
// This method's comment used to say: 'TODO: get rid of this duplicate
// code.' It's not clear where the duplication is.
assert(hasAllocatedReg() && "This operand cannot have a register number!");
regNum = Reg;
}
void setImmedValue(int immVal) {
assert(isImmediate() && "Wrong MachineOperand mutator");
contents.immedVal = immVal;
}
friend std::ostream& operator<<(std::ostream& os, const MachineOperand& mop);
private:
// Construction methods needed for fine-grain control.
// These must be accessed via coresponding methods in MachineInstr.
/// markHi32, markLo32, etc. - These methods must be accessed via
/// corresponding methods in MachineInstr. These methods are deprecated
/// and only used by the SPARC v9 back-end.
///
void markHi32() { flags |= HIFLAG32; }
void markLo32() { flags |= LOFLAG32; }
void markHi64() { flags |= HIFLAG64; }
void markLo64() { flags |= LOFLAG64; }
// Replaces the Value with its corresponding physical register after
// register allocation is complete
/// setRegForValue - Replaces the Value with its corresponding physical
/// register after register allocation is complete. This is deprecated
/// and only used by the SPARC v9 back-end.
///
void setRegForValue(int reg) {
assert(opType == MO_VirtualRegister || opType == MO_CCRegister ||
opType == MO_MachineRegister);
@ -326,13 +361,13 @@ class MachineInstr {
std::vector<MachineOperand> operands; // the operands
MachineInstr* prev, *next; // links for our intrusive list
MachineBasicBlock* parent; // pointer to the owning basic block
// OperandComplete - Return true if it's illegal to add a new operand
bool OperandsComplete() const;
MachineInstr(const MachineInstr &); // DO NOT IMPLEMENT
void operator=(const MachineInstr&); // DO NOT IMPLEMENT
private:
// Intrusive list support
//
friend class ilist_traits<MachineInstr>;
@ -358,7 +393,7 @@ public:
const MachineBasicBlock* getParent() const { return parent; }
MachineBasicBlock* getParent() { return parent; }
/// Accessors for opcode.
/// getOpcode - Returns the opcode of this MachineInstr.
///
const int getOpcode() const { return Opcode; }

12
llvm/lib/CodeGen/MachineInstr.cpp
View File

@ -100,7 +100,7 @@ void MachineInstr::SetMachineOperandVal(unsigned i,
Value* V) {
assert(i < operands.size()); // may be explicit or implicit op
operands[i].opType = opTy;
operands[i].value = V;
operands[i].contents.value = V;
operands[i].regNum = -1;
}
@ -113,8 +113,8 @@ MachineInstr::SetMachineOperandConst(unsigned i,
"immed. constant cannot be defined");
operands[i].opType = opTy;
operands[i].value = NULL;
operands[i].immedVal = intValue;
operands[i].contents.value = NULL;
operands[i].contents.immedVal = intValue;
operands[i].regNum = -1;
operands[i].flags = 0;
}
@ -123,7 +123,7 @@ void MachineInstr::SetMachineOperandReg(unsigned i, int regNum) {
assert(i < getNumOperands()); // must be explicit op
operands[i].opType = MachineOperand::MO_MachineRegister;
operands[i].value = NULL;
operands[i].contents.value = NULL;
operands[i].regNum = regNum;
}
@ -162,7 +162,7 @@ MachineInstr::substituteValue(const Value* oldVal, Value* newVal,
notDefsAndUses && (O.isDef() && !O.isUse()) ||
!notDefsAndUses && O.isDef())
{
O.getMachineOperand().value = newVal;
O.getMachineOperand().contents.value = newVal;
++numSubst;
}
else
@ -175,7 +175,7 @@ MachineInstr::substituteValue(const Value* oldVal, Value* newVal,
notDefsAndUses && (getImplicitOp(i).isDef() && !getImplicitOp(i).isUse()) ||
!notDefsAndUses && getImplicitOp(i).isDef())
{
getImplicitOp(i).value = newVal;
getImplicitOp(i).contents.value = newVal;
++numSubst;
}
else