maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/Target/X86/InstPrinter/X86ATTInstPrinter.h

91 lines
3.0 KiB
C
Raw Normal View History

split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
//===-- X86ATTInstPrinter.h - Convert X86 MCInst to assembly syntax -------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This class prints an X86 MCInst to AT&T style .s file syntax.
//
//===----------------------------------------------------------------------===//
#ifndef X86_ATT_INST_PRINTER_H
#define X86_ATT_INST_PRINTER_H
Give MCInstPrinter a MCAsmInfo member, make X86ATTInstPrinter be a MCInstPrinter. llvm-svn: 81746
2009-09-14 09:49:26 +08:00
#include "llvm/MC/MCInstPrinter.h"
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
namespace llvm {
We need to pass the TargetMachine object to the InstPrinter if we are printing the alias of an InstAlias instead of the thing being aliased. Because we need to know the features that are valid for an InstAlias. This is part of a work-in-progress. llvm-svn: 127986
2011-03-21 12:13:46 +08:00
class MCOperand;
Replace the old algorithm that emitted the "print the alias for an instruction" with the newer, cleaner model. It uses the IAPrinter class to hold the information that is needed to match an instruction with its alias. This also takes into account the available features of the platform. There is one bit of ugliness. The way the logic determines if a pattern is unique is O(N**2), which is gross. But in reality, the number of items it's checking against isn't large. So while it's N**2, it shouldn't be a massive time sink. llvm-svn: 129110
2011-04-08 05:20:06 +08:00
class X86Subtarget;
We need to pass the TargetMachine object to the InstPrinter if we are printing the alias of an InstAlias instead of the thing being aliased. Because we need to know the features that are valid for an InstAlias. This is part of a work-in-progress. llvm-svn: 127986
2011-03-21 12:13:46 +08:00
class TargetMachine;
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
Give MCInstPrinter a MCAsmInfo member, make X86ATTInstPrinter be a MCInstPrinter. llvm-svn: 81746
2009-09-14 09:49:26 +08:00
class X86ATTInstPrinter : public MCInstPrinter {
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
public:
Replace the old algorithm that emitted the "print the alias for an instruction" with the newer, cleaner model. It uses the IAPrinter class to hold the information that is needed to match an instruction with its alias. This also takes into account the available features of the platform. There is one bit of ugliness. The way the logic determines if a pattern is unique is O(N**2), which is gross. But in reality, the number of items it's checking against isn't large. So while it's N**2, it shouldn't be a massive time sink. llvm-svn: 129110
2011-04-08 05:20:06 +08:00
X86ATTInstPrinter(TargetMachine &TM, const MCAsmInfo &MAI);
Give MCInstPrinter a MCAsmInfo member, make X86ATTInstPrinter be a MCInstPrinter. llvm-svn: 81746
2009-09-14 09:49:26 +08:00
Use the dwarf->llvm mapping to print register names in the cfi directives. Fixes PR9826. llvm-svn: 132317
2011-05-31 04:20:15 +08:00
StringRef getRegName(unsigned RegNo) const;
fix an ugly wart in the MCInstPrinter api where the raw_ostream to print an instruction to had to be specified at MCInstPrinter construction time instead of being able to pick at each call to printInstruction. llvm-svn: 100307
2010-04-04 13:04:31 +08:00
virtual void printInst(const MCInst *MI, raw_ostream &OS);
enhance llvm-mc -show-inst to print the enum of an instruction, like so: testb %al, %al ## <MCInst #2412 TEST8rr ## <MCOperand Reg:2> ## <MCOperand Reg:2>> jne LBB1_7 ## <MCInst #938 JNE_1 ## <MCOperand Expr:(LBB1_7)>> llvm-svn: 95935
2010-02-12 06:57:32 +08:00
virtual StringRef getOpcodeName(unsigned Opcode) const;
Replace the old algorithm that emitted the "print the alias for an instruction" with the newer, cleaner model. It uses the IAPrinter class to hold the information that is needed to match an instruction with its alias. This also takes into account the available features of the platform. There is one bit of ugliness. The way the logic determines if a pattern is unique is O(N**2), which is gross. But in reality, the number of items it's checking against isn't large. So while it's N**2, it shouldn't be a massive time sink. llvm-svn: 129110
2011-04-08 05:20:06 +08:00
// Methods used to print the alias of an instruction.
unsigned ComputeAvailableFeatures(const X86Subtarget *Subtarget) const;
Invert the meaning of printAliasInstr's return value. It now returns true on success and false on failure. Update callers. llvm-svn: 129722
2011-04-19 05:28:11 +08:00
// Autogenerated by tblgen, returns true if we successfully printed an
// alias.
Replace the old algorithm that emitted the "print the alias for an instruction" with the newer, cleaner model. It uses the IAPrinter class to hold the information that is needed to match an instruction with its alias. This also takes into account the available features of the platform. There is one bit of ugliness. The way the logic determines if a pattern is unique is O(N**2), which is gross. But in reality, the number of items it's checking against isn't large. So while it's N**2, it shouldn't be a massive time sink. llvm-svn: 129110
2011-04-08 05:20:06 +08:00
bool printAliasInstr(const MCInst *MI, raw_ostream &OS);
make tblgen produce a function that returns the name for a physreg. Nothing is using this info yet. llvm-svn: 81707
2009-09-14 04:08:00 +08:00
// Autogenerated by tblgen.
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printInstruction(const MCInst *MI, raw_ostream &OS);
the tblgen produced 'getRegisterName' method does not access the object, make it static instead of const. llvm-svn: 81711
2009-09-14 04:19:22 +08:00
static const char *getRegisterName(unsigned RegNo);
enhance llvm-mc -show-inst to print the enum of an instruction, like so: testb %al, %al ## <MCInst #2412 TEST8rr ## <MCOperand Reg:2> ## <MCOperand Reg:2>> jne LBB1_7 ## <MCInst #938 JNE_1 ## <MCOperand Expr:(LBB1_7)>> llvm-svn: 95935
2010-02-12 06:57:32 +08:00
static const char *getInstructionName(unsigned Opcode);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printOperand(const MCInst *MI, unsigned OpNo, raw_ostream &OS);
void printMemReference(const MCInst *MI, unsigned Op, raw_ostream &OS);
void printSSECC(const MCInst *MI, unsigned Op, raw_ostream &OS);
void print_pcrel_imm(const MCInst *MI, unsigned OpNo, raw_ostream &OS);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printopaquemem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printi8mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printi16mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printi32mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printi64mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printi128mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
Add 256-bit vaddsub, vhadd, vhsub, vblend and vdpp instructions! llvm-svn: 108769
2010-07-20 07:32:44 +08:00
void printi256mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printf32mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printf64mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printf80mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
change a ton of code to not implicitly use the "O" raw_ostream member of AsmPrinter. Instead, pass it in explicitly. llvm-svn: 100306
2010-04-04 12:47:45 +08:00
void printf128mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
}
Start the support for AVX instructions with 256-bit %ymm registers. A couple of notes: - The instructions are being added with dummy placeholder patterns using some 256 specifiers, this is not meant to work now, but since there are some multiclasses generic enough to accept them, when we go for codegen, the stuff will be already there. - Add VEX encoding bits to support YMM - Add MOVUPS and MOVAPS in the first round - Use "Y" as suffix for those Instructions: MOVUPSYrr, ... - All AVX instructions in X86InstrSSE.td will move soon to a new X86InstrAVX file. llvm-svn: 107996
2010-07-10 02:27:43 +08:00
void printf256mem(const MCInst *MI, unsigned OpNo, raw_ostream &O) {
printMemReference(MI, OpNo, O);
}
split MCInst printing out of the X86ATTInstPrinter class into its own X86ATTInstPrinter class. The inst printer now has just one dependence on the code generator (TRI). llvm-svn: 81703
2009-09-14 03:30:11 +08:00
};
}
#endif