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

A few inline asm cleanups:

Browse Source 
- Make targetlowering.h fit in 80 cols.
  - Make LowerAsmOperandForConstraint const.
  - Make lowerXConstraint -> LowerXConstraint
  - Make LowerXConstraint return a const char* instead of taking a string byref.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50312 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2008-04-26 23:02:14 +00:00
parent 2ba1c06d48
commit 5e764233f3
6 changed files with 40 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
include/llvm/Target/TargetLowering.h
View File

@ -1100,16 +1100,19 @@ public:
std::string *Current = &Codes[0];
TargetLowering::ConstraintType CurType = TLI.getConstraintType(*Current);
if (Codes.size() == 1) { // Single-letter constraints ('r') are very common.
// Single-letter constraints ('r') are very common.
if (Codes.size() == 1) {
ConstraintCode = *Current;
ConstraintType = CurType;
} else {
unsigned CurGenerality = getConstraintGenerality(CurType);
// If we have multiple constraints, try to pick the most general one ahead
// of time. This isn't a wonderful solution, but handles common cases.
// If we have multiple constraints, try to pick the most general one
// ahead of time. This isn't a wonderful solution, but handles common
// cases.
for (unsigned j = 1, e = Codes.size(); j != e; ++j) {
TargetLowering::ConstraintType ThisType = TLI.getConstraintType(Codes[j]);
TargetLowering::ConstraintType ThisType =
TLI.getConstraintType(Codes[j]);
unsigned ThisGenerality = getConstraintGenerality(ThisType);
if (ThisGenerality > CurGenerality) {
// This constraint letter is more general than the previous one,
@ -1124,17 +1127,17 @@ public:
ConstraintType = CurType;
}
// 'X' matches anything.
if (ConstraintCode == "X" && CallOperandVal) {
// Labels and constants are handled elsewhere ('X' is the only thing
// that matches labels).
if (isa<BasicBlock>(CallOperandVal) || isa<ConstantInt>(CallOperandVal))
return;
// This matches anything. Labels and constants we handle elsewhere
// ('X' is the only thing that matches labels). Otherwise, try to
// resolve it to something we know about by looking at the actual
// operand type.
std::string s = "";
TLI.lowerXConstraint(ConstraintVT, s);
if (s!="") {
ConstraintCode = s;
// Otherwise, try to resolve it to something we know about by looking at
// the actual operand type.
if (const char *Repl = TLI.LowerXConstraint(ConstraintVT)) {
ConstraintCode = Repl;
ConstraintType = TLI.getConstraintType(ConstraintCode);
}
}
@ -1168,15 +1171,15 @@ public:
/// LowerXConstraint - try to replace an X constraint, which matches anything,
/// with another that has more specific requirements based on the type of the
/// corresponding operand.
virtual void lowerXConstraint(MVT::ValueType ConstraintVT,
std::string&) const;
/// corresponding operand. This returns null if there is no replacement to
/// make.
virtual const char *LowerXConstraint(MVT::ValueType ConstraintVT) const;
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
/// vector. If it is invalid, don't add anything to Ops.
virtual void LowerAsmOperandForConstraint(SDOperand Op, char ConstraintLetter,
std::vector<SDOperand> &Ops,
SelectionDAG &DAG);
SelectionDAG &DAG) const;
//===--------------------------------------------------------------------===//
// Scheduler hooks

14
lib/CodeGen/SelectionDAG/TargetLowering.cpp
View File

@ -1534,14 +1534,12 @@ TargetLowering::getConstraintType(const std::string &Constraint) const {
/// LowerXConstraint - try to replace an X constraint, which matches anything,
/// with another that has more specific requirements based on the type of the
/// corresponding operand.
void TargetLowering::lowerXConstraint(MVT::ValueType ConstraintVT,
std::string& s) const {
const char *TargetLowering::LowerXConstraint(MVT::ValueType ConstraintVT) const{
if (MVT::isInteger(ConstraintVT))
s = "r";
else if (MVT::isFloatingPoint(ConstraintVT))
s = "f"; // works for many targets
else
s = "";
return "r";
if (MVT::isFloatingPoint(ConstraintVT))
return "f"; // works for many targets
return 0;
}
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
@ -1549,7 +1547,7 @@ void TargetLowering::lowerXConstraint(MVT::ValueType ConstraintVT,
void TargetLowering::LowerAsmOperandForConstraint(SDOperand Op,
char ConstraintLetter,
std::vector<SDOperand> &Ops,
SelectionDAG &DAG) {
SelectionDAG &DAG) const {
switch (ConstraintLetter) {
default: break;
case 'X': // Allows any operand; labels (basic block) use this.

2
lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -3984,7 +3984,7 @@ PPCTargetLowering::getRegForInlineAsmConstraint(const std::string &Constraint,
/// vector. If it is invalid, don't add anything to Ops.
void PPCTargetLowering::LowerAsmOperandForConstraint(SDOperand Op, char Letter,
std::vector<SDOperand>&Ops,
SelectionDAG &DAG) {
SelectionDAG &DAG) const {
SDOperand Result(0,0);
switch (Letter) {
default: break;

2
lib/Target/PowerPC/PPCISelLowering.h
View File

@ -293,7 +293,7 @@ namespace llvm {
virtual void LowerAsmOperandForConstraint(SDOperand Op,
char ConstraintLetter,
std::vector<SDOperand> &Ops,
SelectionDAG &DAG);
SelectionDAG &DAG) const;
/// isLegalAddressingMode - Return true if the addressing mode represented
/// by AM is legal for this target, for a load/store of the specified type.

21
lib/Target/X86/X86ISelLowering.cpp
View File

@ -6280,17 +6280,18 @@ X86TargetLowering::getConstraintType(const std::string &Constraint) const {
/// LowerXConstraint - try to replace an X constraint, which matches anything,
/// with another that has more specific requirements based on the type of the
/// corresponding operand.
void X86TargetLowering::lowerXConstraint(MVT::ValueType ConstraintVT,
std::string& s) const {
const char *X86TargetLowering::
LowerXConstraint(MVT::ValueType ConstraintVT) const {
// FP X constraints get lowered to SSE1/2 registers if available, otherwise
// 'f' like normal targets.
if (MVT::isFloatingPoint(ConstraintVT)) {
if (Subtarget->hasSSE2())
s = "Y";
else if (Subtarget->hasSSE1())
s = "x";
else
s = "f";
} else
return TargetLowering::lowerXConstraint(ConstraintVT, s);
return "Y";
if (Subtarget->hasSSE1())
return "x";
}
return TargetLowering::LowerXConstraint(ConstraintVT);
}
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
@ -6298,7 +6299,7 @@ void X86TargetLowering::lowerXConstraint(MVT::ValueType ConstraintVT,
void X86TargetLowering::LowerAsmOperandForConstraint(SDOperand Op,
char Constraint,
std::vector<SDOperand>&Ops,
SelectionDAG &DAG) {
SelectionDAG &DAG) const {
SDOperand Result(0, 0);
switch (Constraint) {

5
lib/Target/X86/X86ISelLowering.h
View File

@ -371,15 +371,14 @@ namespace llvm {
getRegClassForInlineAsmConstraint(const std::string &Constraint,
MVT::ValueType VT) const;
virtual void lowerXConstraint(MVT::ValueType ConstraintVT,
std::string&) const;
virtual const char *LowerXConstraint(MVT::ValueType ConstraintVT) const;
/// LowerAsmOperandForConstraint - Lower the specified operand into the Ops
/// vector. If it is invalid, don't add anything to Ops.
virtual void LowerAsmOperandForConstraint(SDOperand Op,
char ConstraintLetter,
std::vector<SDOperand> &Ops,
SelectionDAG &DAG);
SelectionDAG &DAG) const;
/// getRegForInlineAsmConstraint - Given a physical register constraint
/// (e.g. {edx}), return the register number and the register class for the