53 case X86::ADDR16_PREFIX:
54 case X86::ADDR32_PREFIX:
66 return Inst.
getOpcode() == X86::CALL64pcrel32;
130 return Reg == X86::NoRegister ||
131 getX86MCRegisterClass(X86::GR64RegClassID).contains(
Reg);
135 if (getX86MCRegisterClass(X86::GR32RegClassID).
contains(
Reg))
137 return RegInfo->getSubReg(
Reg, X86::sub_32bit);
140void X86::X86MCLFIRewriter::emitWithPrefixes(
const MCInst &Inst,
142 const MCSubtargetInfo &STI) {
143 for (
const MCInst &Prefix : Prefixes)
144 Out.emitInstruction(Prefix, STI);
146 Out.emitInstruction(Inst, STI);
149void X86::X86MCLFIRewriter::discardPrefixes() {
150 for (
const MCInst &Prefix : Prefixes)
151 error(Prefix,
"unsupported instruction prefix");
162void X86::X86MCLFIRewriter::rewriteSyscall(
const MCInst &Inst, MCStreamer &Out,
163 const MCSubtargetInfo &STI) {
164 Out.emitBundleLock(
false, STI);
170 MCInstBuilder(X86::LEA64r)
174 .addReg(X86::NoRegister)
176 .addReg(X86::NoRegister),
180 Out.emitInstruction(MCInstBuilder(X86::JMP64m)
183 .addReg(X86::NoRegister)
185 .addReg(X86::NoRegister),
188 Out.emitLabel(Symbol);
189 Out.emitBundleUnlock(STI);
194void X86::X86MCLFIRewriter::emitSandboxBranchReg(MCRegister
Reg,
196 const MCSubtargetInfo &STI) {
197 MCRegister Reg32 = RegInfo->getSubReg(
Reg, X86::sub_32bit);
199 Out.emitInstruction(MCInstBuilder(X86::AND32ri8)
232void X86::X86MCLFIRewriter::rewriteIndirectBranch(
const MCInst &Inst,
234 const MCSubtargetInfo &STI) {
243 MCInstBuilder Mov(X86::MOV64rm);
247 Mov.setLoc(Inst.
getLoc());
248 doRewriteInst(Mov, Out, STI);
253 return error(Inst,
"indirect branch through reserved register");
256 Out.emitBundleLock(isCall(Inst), STI);
258 emitSandboxBranchReg(Target, Out, STI);
261 MCInstBuilder(isCall(Inst) ? X86::CALL64r : X86::JMP64r).addReg(Target);
264 Out.emitInstruction(Branch, STI);
266 Out.emitBundleUnlock(STI);
271void X86::X86MCLFIRewriter::rewriteDirectCall(
const MCInst &Inst,
273 const MCSubtargetInfo &STI) {
274 Out.emitBundleLock(
true, STI);
275 emitWithPrefixes(Inst, Out, STI);
276 Out.emitBundleUnlock(STI);
300void X86::X86MCLFIRewriter::rewriteReturn(
const MCInst &Inst, MCStreamer &Out,
301 const MCSubtargetInfo &STI) {
303 return error(Inst,
"unsupported return instruction");
312 doRewriteInst(MCInstBuilder(X86::ADD64ri32)
320 Out.emitBundleLock(
false, STI);
326 Out.emitBundleUnlock(STI);
336 .addReg(X86::NoRegister)
338 .addReg(X86::NoRegister),
342bool X86::X86MCLFIRewriter::isFSAccess(
const MCInst &Inst) {
343 return (mayLoad(Inst) || mayStore(Inst)) &&
365void X86::X86MCLFIRewriter::rewriteFSAccess(
const MCInst &Inst, MCStreamer &Out,
366 const MCSubtargetInfo &STI) {
368 assert(MemIdx >= 0 &&
"expected an %fs memory operand");
372 bool HasBase =
BaseReg != X86::NoRegister;
373 bool HasIndex = IndexReg != X86::NoRegister;
379 if (!HasBase && !HasIndex && !HasDisp) {
384 return emitWithPrefixes(
Modified, Out, STI);
388 BaseReg == X86::RSP || BaseReg == X86::RIP)
389 return error(Inst,
"unsupported addressing mode for %fs access");
398 if (
Desc.getNumDefs() > 0 &&
399 getX86MCRegisterClass(X86::GR64RegClassID).
contains(DestReg) &&
406 return error(Inst,
"%fs access reads reserved register %r11");
417 if (HasBase && HasIndex) {
418 Out.emitInstruction(MCInstBuilder(X86::LEA64r)
424 .addReg(X86::NoRegister),
437 if (HasBase && !HasIndex)
456 case X86::MASKMOVDQU:
457 case X86::MASKMOVDQU64:
458 case X86::VMASKMOVDQU:
459 case X86::VMASKMOVDQU64:
460 case X86::MMX_MASKMOVQ:
461 case X86::MMX_MASKMOVQ64:
466 case X86::MOVDIR64B32:
467 case X86::MOVDIR64B64:
468 case X86::MOVDIR64B32_EVEX:
469 case X86::MOVDIR64B64_EVEX:
472 case X86::ENQCMD32_EVEX:
473 case X86::ENQCMD64_EVEX:
476 case X86::ENQCMDS32_EVEX:
477 case X86::ENQCMDS64_EVEX:
501 case X86::LOCK_BTC_RM16rm:
502 case X86::LOCK_BTC_RM32rm:
503 case X86::LOCK_BTC_RM64rm:
504 case X86::LOCK_BTR_RM16rm:
505 case X86::LOCK_BTR_RM32rm:
506 case X86::LOCK_BTR_RM64rm:
507 case X86::LOCK_BTS_RM16rm:
508 case X86::LOCK_BTS_RM32rm:
509 case X86::LOCK_BTS_RM64rm:
536 return Index && getX86MCRegisterClass(X86::GR64RegClassID).contains(Index);
544 const MCRegisterClass &GR32 = getX86MCRegisterClass(X86::GR32RegClassID);
555void X86::X86MCLFIRewriter::sandboxMemOperand(MCInst &Inst,
int MemIdx)
const {
563 if (
Index.getReg() == X86::RIZ) {
564 Index.setReg(X86::NoRegister);
586 Base.setReg(getReg32(
Base.getReg()));
593void X86::X86MCLFIRewriter::sandboxMemAccess(MCInst &Inst)
const {
599 sandboxMemOperand(Inst, MemIdx);
602void X86::X86MCLFIRewriter::rewriteMemAccess(
const MCInst &Inst,
604 const MCSubtargetInfo &STI) {
605 MCInst Sandboxed(Inst);
606 sandboxMemAccess(Sandboxed);
607 emitWithPrefixes(Sandboxed, Out, STI);
611struct StringOpPointers {
623 case X86::REP_STOSB_64:
624 case X86::REP_STOSW_64:
625 case X86::REP_STOSD_64:
626 case X86::REP_STOSQ_64:
631 return StringOpPointers{
true,
false};
636 case X86::REP_MOVSB_64:
637 case X86::REP_MOVSW_64:
638 case X86::REP_MOVSD_64:
639 case X86::REP_MOVSQ_64:
644 return StringOpPointers{
true,
true};
649 return StringOpPointers{
false,
true};
657 Out.emitInstruction(
MCInstBuilder(X86::MOV32rr).addReg(Reg32).addReg(Reg32),
666 .addReg(X86::NoRegister),
679void X86::X86MCLFIRewriter::rewriteStringOperation(
const MCInst &Inst,
681 const MCSubtargetInfo &STI) {
683 assert(Ptrs &&
"expected a string instruction");
687 for (
const MCOperand &
Op : Inst) {
690 if (
Op.getReg() == X86::EDI ||
Op.getReg() == X86::ESI)
691 return error(Inst,
"unsupported address size for string instruction");
692 if (
Op.getReg() == X86::FS)
693 return error(Inst,
"unsupported segment override for string instruction");
696 Out.emitBundleLock(
false, STI);
703 emitWithPrefixes(Inst, Out, STI);
705 Out.emitBundleUnlock(STI);
738 return X86::LEA64_32r;
742 return X86::ADD32ri8;
748 return X86::SUB32ri8;
754 return X86::AND32ri8;
766 return X86::XOR32ri8;
774MCRegister X86::X86MCLFIRewriter::getWrittenStackReg(
const MCInst &Inst)
const {
776 for (
unsigned I = 0,
E =
Desc.getNumDefs();
I <
E; ++
I) {
778 if (
Op.isReg() && RegInfo->regsOverlap(
Op.getReg(), X86::RSP))
781 return X86::NoRegister;
792 .addReg(X86::NoRegister),
802void X86::X86MCLFIRewriter::rewriteStackModification(
803 MCRegister StackReg,
const MCInst &Inst, MCStreamer &Out,
804 const MCSubtargetInfo &STI) {
805 if (StackReg != X86::RSP)
806 return error(Inst,
"unsupported modification of the stack pointer");
816 Out.emitBundleLock(
false, STI);
818 MCInstBuilder(X86::MOV32rr).addReg(X86::ESP).addReg(X86::R11D), STI);
820 Out.emitBundleUnlock(STI);
835 return error(Inst,
"unsupported modification of the stack pointer");
837 MCInstBuilder
Load(X86::MOV64rm);
842 doRewriteInst(
Load, Out, STI);
844 MCInstBuilder RegForm(*RegOpcode);
845 for (
int I = 0;
I < MemIdx; ++
I)
848 RegForm.setLoc(Inst.
getLoc());
849 return doRewriteInst(RegForm, Out, STI);
854 return error(Inst,
"unsupported modification of the stack pointer");
860 for (
unsigned I = 0,
E = std::min<unsigned>(OpInfo.
size(),
866 if (getX86MCRegisterClass(X86::GR64RegClassID).
contains(
Op.getReg()))
867 Op.setReg(RegInfo->getSubReg(
Op.getReg(), X86::sub_32bit));
870 Out.emitBundleLock(
false, STI);
873 Out.emitBundleUnlock(STI);
883void X86::X86MCLFIRewriter::rewriteLeave(
const MCInst &Inst, MCStreamer &Out,
884 const MCSubtargetInfo &STI) {
885 doRewriteInst(MCInstBuilder(X86::MOV64rr)
890 Out.emitInstruction(MCInstBuilder(X86::POP64r).addReg(X86::RBP), STI);
893void X86::X86MCLFIRewriter::doRewriteInst(
const MCInst &Inst, MCStreamer &Out,
894 const MCSubtargetInfo &STI) {
896 return error(Inst,
"LFI only supports 64-bit mode");
902 return error(Inst,
"unsupported instruction prefix");
903 Prefixes.push_back(Inst);
910 return error(Inst,
"unsupported lock prefix");
914 return error(Inst,
"illegal modification of reserved LFI register");
917 return error(Inst,
"illegal modification of reserved segment base");
920 return rewriteSyscall(Inst, Out, STI);
923 return rewriteReturn(Inst, Out, STI);
926 return rewriteDirectCall(Inst, Out, STI);
930 return error(Inst,
"unsupported branch instruction");
932 if (isIndirectBranch(Inst) || isCall(Inst)) {
934 return error(Inst,
"unsupported indirect branch");
935 return rewriteIndirectBranch(Inst, Out, STI);
938 for (
const MCOperand &
Op : Inst)
940 return error(Inst,
"invalid use of reserved segment register %gs");
942 if (MCRegister StackReg = getWrittenStackReg(Inst))
943 return rewriteStackModification(StackReg, Inst, Out, STI);
951 return error(Inst,
"unsupported memory access");
954 return error(Inst,
"unsupported bit test with a register bit offset");
956 if (isFSAccess(Inst))
957 return rewriteFSAccess(Inst, Out, STI);
963 return error(Inst,
"unsupported 32-bit address size");
966 return rewriteStringOperation(Inst, Out, STI);
968 if (Inst.getOpcode() == X86::LEAVE64)
969 return rewriteLeave(Inst, Out, STI);
971 if (Inst.getOpcode() == X86::ENTER &&
972 (!Inst.getOperand(1).isImm() ||
973 static_cast<uint64_t>(Inst.getOperand(1).getImm()) > 1))
974 return error(Inst,
"unsupported nesting level for enter");
976 rewriteMemAccess(Inst, Out, STI);
987 size_t PrefixesBefore = Prefixes.size();
989 doRewriteInst(Inst, Out, STI);
991 if (Prefixes.size() == PrefixesBefore)
static constexpr MCRegister LFIScratchReg
static constexpr MCRegister LFICtxReg
static bool isSyscall(const MCInst &Inst)
static constexpr MCRegister LFIBaseReg
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static MCDisassembler::DecodeStatus addOperand(MCInst &Inst, const MCOperand &Opnd)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
static bool isPrefix(unsigned Opcode, const MCInstrInfo &MCII)
Check if the instruction is a prefix.
static bool isWriteSegmentBase(unsigned Opcode)
static void emitStackFixup(MCStreamer &Out, const MCSubtargetInfo &STI)
static std::optional< unsigned > memToRegOpcode(unsigned Opcode)
static bool has32BitAddress(const MCInst &Inst, int MemIdx)
static bool isDirectCall(const MCInst &Inst)
static void emitTPLoad(MCRegister Reg, MCStreamer &Out, const MCSubtargetInfo &STI)
static bool hasNoTrackPrefix(const MCInst &Inst, const MCInstrInfo &InstInfo)
static bool isGR64OrNone(MCRegister Reg)
static bool isPrefix(const MCInst &Inst, const MCInstrInfo &InstInfo)
static bool isSupportedIndirectBranch(const MCInst &Inst)
static int findFSMemOperand(const MCInst &Inst, const MCInstrInfo &InstInfo)
static bool hasGPRIndex(const MCInst &Inst, int MemIdx)
static bool isSupportedPrefix(const MCInst &Inst)
static constexpr int TPOffset
static void emitStringPtrFixup(MCRegister Reg, MCRegister Reg32, MCStreamer &Out, const MCSubtargetInfo &STI)
static bool isSyscall(const MCInst &Inst)
static bool hasImplicitMemPointer(unsigned Opcode)
static constexpr MCRegister LFIBaseSeg
static bool readsRegister(const MCInst &Inst, const MCInstrDesc &Desc, MCRegister Reg, const MCRegisterInfo &RI)
static bool isSandboxBaseReg(MCRegister Reg)
static std::optional< unsigned > demote64BitOpcode(unsigned Opcode)
static bool ignoresMemOperand(unsigned Opcode)
static bool isBitTestWithRegOffset(unsigned Opcode)
static constexpr int SyscallOffset
static std::optional< StringOpPointers > getStringOpPointers(unsigned Opcode)
size_t size() const
Get the array size.
Instances of this class represent a single low-level machine instruction.
unsigned getNumOperands() const
unsigned getFlags() const
unsigned getOpcode() const
const MCOperand & getOperand(unsigned i) const
Describe properties that are true of each instruction in the target description file.
Interface to description of machine instruction set.
std::unique_ptr< MCRegisterInfo > RegInfo
Instances of this class represent operands of the MCInst class.
void setReg(MCRegister Reg)
Set the register number.
MCRegister getReg() const
Returns the register number.
MCRegisterClass - Base class of TargetRegisterClass.
bool contains(MCRegister Reg) const
contains - Return true if the specified register is included in this register class.
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
bool regsOverlap(MCRegister RegA, MCRegister RegB) const
Returns true if the two registers are equal or alias each other.
Wrapper class representing physical registers. Should be passed by value.
Streaming machine code generation interface.
Generic base class for all target subtargets.
bool hasFeature(unsigned Feature) const
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
A Use represents the edge between a Value definition and its users.
void finish(MCStreamer &Out) override
bool rewriteInst(const MCInst &Inst, MCStreamer &Out, const MCSubtargetInfo &STI) override
void onLabel(const MCSymbol *Symbol, MCStreamer &Out) override
bool isPrefix(uint64_t TSFlags)
int getMemoryOperandIdx(const MCInstrDesc &Desc)
@ RawFrmMemOffs
RawFrmMemOffs - This form is for instructions that store an absolute memory offset as an immediate wi...
constexpr unsigned LFIBundleSize
BaseReg
Stack frame base register. Bit 0 of FREInfo.Info.
This is an optimization pass for GlobalISel generic memory operations.
@ Load
The value being inserted comes from a load (InsertElement only).
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
DWARFExpression::Operation Op
ArrayRef(const T &OneElt) -> ArrayRef< T >