6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-23 02:32:11 +00:00
Code Issues Projects Releases Wiki Activity

trailing whitespace

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@113975 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jim Grosbach 2010-09-15 16:08:15 +00:00
parent e6334d84f7
commit 85dbce31d0
1 changed files with 49 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
include/llvm/CodeGen/MachineOperand.h
View File

@ -18,7 +18,7 @@
#include <cassert> #include <cassert>
namespace llvm { namespace llvm {
class BlockAddress; class BlockAddress;
class ConstantFP; class ConstantFP;
class GlobalValue; class GlobalValue;
@ -30,7 +30,7 @@ class TargetMachine;
class TargetRegisterInfo; class TargetRegisterInfo;
class raw_ostream; class raw_ostream;
class MCSymbol; class MCSymbol;
/// MachineOperand class - Representation of each machine instruction operand. /// MachineOperand class - Representation of each machine instruction operand.
/// ///
class MachineOperand { class MachineOperand {
@ -54,21 +54,21 @@ private:
/// OpKind - Specify what kind of operand this is. This discriminates the /// OpKind - Specify what kind of operand this is. This discriminates the
/// union. /// union.
unsigned char OpKind; // MachineOperandType unsigned char OpKind; // MachineOperandType
/// SubReg - Subregister number, only valid for MO_Register. A value of 0 /// SubReg - Subregister number, only valid for MO_Register. A value of 0
/// indicates the MO_Register has no subReg. /// indicates the MO_Register has no subReg.
unsigned char SubReg; unsigned char SubReg;
/// TargetFlags - This is a set of target-specific operand flags. /// TargetFlags - This is a set of target-specific operand flags.
unsigned char TargetFlags; unsigned char TargetFlags;
/// IsDef/IsImp/IsKill/IsDead flags - These are only valid for MO_Register /// IsDef/IsImp/IsKill/IsDead flags - These are only valid for MO_Register
/// operands. /// operands.
/// IsDef - True if this is a def, false if this is a use of the register. /// IsDef - True if this is a def, false if this is a use of the register.
/// ///
bool IsDef : 1; bool IsDef : 1;
/// IsImp - True if this is an implicit def or use, false if it is explicit. /// IsImp - True if this is an implicit def or use, false if it is explicit.
/// ///
bool IsImp : 1; bool IsImp : 1;
@ -94,7 +94,7 @@ private:
/// not a real instruction. Such uses should be ignored during codegen. /// not a real instruction. Such uses should be ignored during codegen.
bool IsDebug : 1; bool IsDebug : 1;
/// ParentMI - This is the instruction that this operand is embedded into. /// ParentMI - This is the instruction that this operand is embedded into.
/// This is valid for all operand types, when the operand is in an instr. /// This is valid for all operand types, when the operand is in an instr.
MachineInstr *ParentMI; MachineInstr *ParentMI;
@ -111,7 +111,7 @@ private:
MachineOperand **Prev; // Access list for register. MachineOperand **Prev; // Access list for register.
MachineOperand *Next; MachineOperand *Next;
} Reg; } Reg;
/// OffsetedInfo - This struct contains the offset and an object identifier. /// OffsetedInfo - This struct contains the offset and an object identifier.
/// this represent the object as with an optional offset from it. /// this represent the object as with an optional offset from it.
struct { struct {
@ -124,7 +124,7 @@ private:
int64_t Offset; // An offset from the object. int64_t Offset; // An offset from the object.
} OffsetedInfo; } OffsetedInfo;
} Contents; } Contents;
explicit MachineOperand(MachineOperandType K) : OpKind(K), ParentMI(0) { explicit MachineOperand(MachineOperandType K) : OpKind(K), ParentMI(0) {
TargetFlags = 0; TargetFlags = 0;
} }
@ -132,17 +132,17 @@ public:
/// getType - Returns the MachineOperandType for this operand. /// getType - Returns the MachineOperandType for this operand.
/// ///
MachineOperandType getType() const { return (MachineOperandType)OpKind; } MachineOperandType getType() const { return (MachineOperandType)OpKind; }
unsigned char getTargetFlags() const { return TargetFlags; } unsigned char getTargetFlags() const { return TargetFlags; }
void setTargetFlags(unsigned char F) { TargetFlags = F; } void setTargetFlags(unsigned char F) { TargetFlags = F; }
void addTargetFlag(unsigned char F) { TargetFlags |= F; } void addTargetFlag(unsigned char F) { TargetFlags |= F; }
/// getParent - Return the instruction that this operand belongs to. /// getParent - Return the instruction that this operand belongs to.
/// ///
MachineInstr *getParent() { return ParentMI; } MachineInstr *getParent() { return ParentMI; }
const MachineInstr *getParent() const { return ParentMI; } const MachineInstr *getParent() const { return ParentMI; }
void print(raw_ostream &os, const TargetMachine *TM = 0) const; void print(raw_ostream &os, const TargetMachine *TM = 0) const;
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
@ -182,42 +182,42 @@ public:
assert(isReg() && "This is not a register operand!"); assert(isReg() && "This is not a register operand!");
return Contents.Reg.RegNo; return Contents.Reg.RegNo;
} }
unsigned getSubReg() const { unsigned getSubReg() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return (unsigned)SubReg; return (unsigned)SubReg;
} }
bool isUse() const { bool isUse() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return !IsDef; return !IsDef;
} }
bool isDef() const { bool isDef() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return IsDef; return IsDef;
} }
bool isImplicit() const { bool isImplicit() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return IsImp; return IsImp;
} }
bool isDead() const { bool isDead() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return IsDead; return IsDead;
} }
bool isKill() const { bool isKill() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return IsKill; return IsKill;
} }
bool isUndef() const { bool isUndef() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return IsUndef; return IsUndef;
} }
bool isEarlyClobber() const { bool isEarlyClobber() const {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
return IsEarlyClobber; return IsEarlyClobber;
@ -238,11 +238,11 @@ public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Mutators for Register Operands // Mutators for Register Operands
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// Change the register this operand corresponds to. /// Change the register this operand corresponds to.
/// ///
void setReg(unsigned Reg); void setReg(unsigned Reg);
void setSubReg(unsigned subReg) { void setSubReg(unsigned subReg) {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
SubReg = (unsigned char)subReg; SubReg = (unsigned char)subReg;
@ -266,14 +266,14 @@ public:
assert((Val || !isDebug()) && "Marking a debug operation as def"); assert((Val || !isDebug()) && "Marking a debug operation as def");
IsDef = !Val; IsDef = !Val;
} }
void setIsDef(bool Val = true) { void setIsDef(bool Val = true) {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
assert((!Val || !isDebug()) && "Marking a debug operation as def"); assert((!Val || !isDebug()) && "Marking a debug operation as def");
IsDef = Val; IsDef = Val;
} }
void setImplicit(bool Val = true) { void setImplicit(bool Val = true) {
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
IsImp = Val; IsImp = Val;
} }
@ -283,7 +283,7 @@ public:
assert((!Val || !isDebug()) && "Marking a debug operation as kill"); assert((!Val || !isDebug()) && "Marking a debug operation as kill");
IsKill = Val; IsKill = Val;
} }
void setIsDead(bool Val = true) { void setIsDead(bool Val = true) {
assert(isReg() && IsDef && "Wrong MachineOperand accessor"); assert(isReg() && IsDef && "Wrong MachineOperand accessor");
IsDead = Val; IsDead = Val;
@ -293,7 +293,7 @@ public:
assert(isReg() && "Wrong MachineOperand accessor"); assert(isReg() && "Wrong MachineOperand accessor");
IsUndef = Val; IsUndef = Val;
} }
void setIsEarlyClobber(bool Val = true) { void setIsEarlyClobber(bool Val = true) {
assert(isReg() && IsDef && "Wrong MachineOperand accessor"); assert(isReg() && IsDef && "Wrong MachineOperand accessor");
IsEarlyClobber = Val; IsEarlyClobber = Val;
@ -307,17 +307,17 @@ public:
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Accessors for various operand types. // Accessors for various operand types.
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
int64_t getImm() const { int64_t getImm() const {
assert(isImm() && "Wrong MachineOperand accessor"); assert(isImm() && "Wrong MachineOperand accessor");
return Contents.ImmVal; return Contents.ImmVal;
} }
const ConstantFP *getFPImm() const { const ConstantFP *getFPImm() const {
assert(isFPImm() && "Wrong MachineOperand accessor"); assert(isFPImm() && "Wrong MachineOperand accessor");
return Contents.CFP; return Contents.CFP;
} }
MachineBasicBlock *getMBB() const { MachineBasicBlock *getMBB() const {
assert(isMBB() && "Wrong MachineOperand accessor"); assert(isMBB() && "Wrong MachineOperand accessor");
return Contents.MBB; return Contents.MBB;
@ -328,7 +328,7 @@ public:
"Wrong MachineOperand accessor"); "Wrong MachineOperand accessor");
return Contents.OffsetedInfo.Val.Index; return Contents.OffsetedInfo.Val.Index;
} }
const GlobalValue *getGlobal() const { const GlobalValue *getGlobal() const {
assert(isGlobal() && "Wrong MachineOperand accessor"); assert(isGlobal() && "Wrong MachineOperand accessor");
return Contents.OffsetedInfo.Val.GV; return Contents.OffsetedInfo.Val.GV;
@ -343,7 +343,7 @@ public:
assert(isMCSymbol() && "Wrong MachineOperand accessor"); assert(isMCSymbol() && "Wrong MachineOperand accessor");
return Contents.Sym; return Contents.Sym;
} }
/// getOffset - Return the offset from the symbol in this operand. This always /// getOffset - Return the offset from the symbol in this operand. This always
/// returns 0 for ExternalSymbol operands. /// returns 0 for ExternalSymbol operands.
int64_t getOffset() const { int64_t getOffset() const {
@ -351,7 +351,7 @@ public:
"Wrong MachineOperand accessor"); "Wrong MachineOperand accessor");
return Contents.OffsetedInfo.Offset; return Contents.OffsetedInfo.Offset;
} }
const char *getSymbolName() const { const char *getSymbolName() const {
assert(isSymbol() && "Wrong MachineOperand accessor"); assert(isSymbol() && "Wrong MachineOperand accessor");
return Contents.OffsetedInfo.Val.SymbolName; return Contents.OffsetedInfo.Val.SymbolName;
@ -361,11 +361,11 @@ public:
assert(isMetadata() && "Wrong MachineOperand accessor"); assert(isMetadata() && "Wrong MachineOperand accessor");
return Contents.MD; return Contents.MD;
} }
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Mutators for various operand types. // Mutators for various operand types.
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
void setImm(int64_t immVal) { void setImm(int64_t immVal) {
assert(isImm() && "Wrong MachineOperand mutator"); assert(isImm() && "Wrong MachineOperand mutator");
Contents.ImmVal = immVal; Contents.ImmVal = immVal;
@ -376,54 +376,54 @@ public:
"Wrong MachineOperand accessor"); "Wrong MachineOperand accessor");
Contents.OffsetedInfo.Offset = Offset; Contents.OffsetedInfo.Offset = Offset;
} }
void setIndex(int Idx) { void setIndex(int Idx) {
assert((isFI() || isCPI() || isJTI()) && assert((isFI() || isCPI() || isJTI()) &&
"Wrong MachineOperand accessor"); "Wrong MachineOperand accessor");
Contents.OffsetedInfo.Val.Index = Idx; Contents.OffsetedInfo.Val.Index = Idx;
} }
void setMBB(MachineBasicBlock *MBB) { void setMBB(MachineBasicBlock *MBB) {
assert(isMBB() && "Wrong MachineOperand accessor"); assert(isMBB() && "Wrong MachineOperand accessor");
Contents.MBB = MBB; Contents.MBB = MBB;
} }
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Other methods. // Other methods.
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
/// isIdenticalTo - Return true if this operand is identical to the specified /// isIdenticalTo - Return true if this operand is identical to the specified
/// operand. Note: This method ignores isKill and isDead properties. /// operand. Note: This method ignores isKill and isDead properties.
bool isIdenticalTo(const MachineOperand &Other) const; bool isIdenticalTo(const MachineOperand &Other) const;
/// ChangeToImmediate - Replace this operand with a new immediate operand of /// ChangeToImmediate - Replace this operand with a new immediate operand of
/// the specified value. If an operand is known to be an immediate already, /// the specified value. If an operand is known to be an immediate already,
/// the setImm method should be used. /// the setImm method should be used.
void ChangeToImmediate(int64_t ImmVal); void ChangeToImmediate(int64_t ImmVal);
/// ChangeToRegister - Replace this operand with a new register operand of /// ChangeToRegister - Replace this operand with a new register operand of
/// the specified value. If an operand is known to be an register already, /// the specified value. If an operand is known to be an register already,
/// the setReg method should be used. /// the setReg method should be used.
void ChangeToRegister(unsigned Reg, bool isDef, bool isImp = false, void ChangeToRegister(unsigned Reg, bool isDef, bool isImp = false,
bool isKill = false, bool isDead = false, bool isKill = false, bool isDead = false,
bool isUndef = false, bool isDebug = false); bool isUndef = false, bool isDebug = false);
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Construction methods. // Construction methods.
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
static MachineOperand CreateImm(int64_t Val) { static MachineOperand CreateImm(int64_t Val) {
MachineOperand Op(MachineOperand::MO_Immediate); MachineOperand Op(MachineOperand::MO_Immediate);
Op.setImm(Val); Op.setImm(Val);
return Op; return Op;
} }
static MachineOperand CreateFPImm(const ConstantFP *CFP) { static MachineOperand CreateFPImm(const ConstantFP *CFP) {
MachineOperand Op(MachineOperand::MO_FPImmediate); MachineOperand Op(MachineOperand::MO_FPImmediate);
Op.Contents.CFP = CFP; Op.Contents.CFP = CFP;
return Op; return Op;
} }
static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false, static MachineOperand CreateReg(unsigned Reg, bool isDef, bool isImp = false,
bool isKill = false, bool isDead = false, bool isKill = false, bool isDead = false,
bool isUndef = false, bool isUndef = false,
@ -506,7 +506,7 @@ public:
Op.Contents.Sym = Sym; Op.Contents.Sym = Sym;
return Op; return Op;
} }
friend class MachineInstr; friend class MachineInstr;
friend class MachineRegisterInfo; friend class MachineRegisterInfo;
private: private:
@ -521,7 +521,7 @@ private:
assert(isReg() && "Can only add reg operand to use lists"); assert(isReg() && "Can only add reg operand to use lists");
return Contents.Reg.Prev != 0; return Contents.Reg.Prev != 0;
} }
/// AddRegOperandToRegInfo - Add this register operand to the specified /// AddRegOperandToRegInfo - Add this register operand to the specified
/// MachineRegisterInfo. If it is null, then the next/prev fields should be /// MachineRegisterInfo. If it is null, then the next/prev fields should be
/// explicitly nulled out. /// explicitly nulled out.