lib/Target/X86/AsmParser/X86AsmInstrumentation.cpp

   1 //===-- X86AsmInstrumentation.cpp - Instrument X86 inline assembly C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "MCTargetDesc/X86BaseInfo.h"
  11 #include "X86AsmInstrumentation.h"
  12 #include "X86Operand.h"
  13 #include "llvm/ADT/StringExtras.h"
  14 #include "llvm/MC/MCContext.h"
  15 #include "llvm/MC/MCInst.h"
  16 #include "llvm/MC/MCInstBuilder.h"
  17 #include "llvm/MC/MCStreamer.h"
  18 #include "llvm/MC/MCSubtargetInfo.h"
  19 #include "llvm/Support/CommandLine.h"
  20 #include "llvm/Support/Compiler.h"
  21 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  22
  23 namespace llvm {
  24 namespace {
  25
  26 static cl::opt<bool> ClAsanInstrumentInlineAssembly(
  27     "asan-instrument-inline-assembly", cl::desc("instrument inline assembly"),
  28     cl::Hidden, cl::init(false));
  29
  30 bool IsStackReg(unsigned Reg) {
  31   return Reg == X86::RSP || Reg == X86::ESP || Reg == X86::SP;
  32 }
  33
  34 std::string FuncName(unsigned AccessSize, bool IsWrite) {
  35   return std::string("__sanitizer_sanitize_") + (IsWrite ? "store" : "load") +
  36          (utostr(AccessSize));
  37 }
  38
  39 class X86AddressSanitizer : public X86AsmInstrumentation {
  40 public:
  41   X86AddressSanitizer(MCSubtargetInfo &sti) : STI(sti) {}
  42   virtual ~X86AddressSanitizer() {}
  43
  44   // X86AsmInstrumentation implementation:
  45   virtual void InstrumentInstruction(
  46       const MCInst &Inst, SmallVectorImpl<MCParsedAsmOperand *> &Operands,
  47       MCContext &Ctx, MCStreamer &Out) override {
  48     InstrumentMOV(Inst, Operands, Ctx, Out);
  49   }
  50
  51   // Should be implemented differently in x86_32 and x86_64 subclasses.
  52   virtual void InstrumentMemOperandImpl(X86Operand *Op, unsigned AccessSize,
  53                                         bool IsWrite, MCContext &Ctx,
  54                                         MCStreamer &Out) = 0;
  55
  56   void InstrumentMemOperand(MCParsedAsmOperand *Op, unsigned AccessSize,
  57                             bool IsWrite, MCContext &Ctx, MCStreamer &Out);
  58   void InstrumentMOV(const MCInst &Inst,
  59                      SmallVectorImpl<MCParsedAsmOperand *> &Operands,
  60                      MCContext &Ctx, MCStreamer &Out);
  61   void EmitInstruction(MCStreamer &Out, const MCInst &Inst) {
  62     Out.EmitInstruction(Inst, STI);
  63   }
  64
  65 protected:
  66   MCSubtargetInfo &STI;
  67 };
  68
  69 void X86AddressSanitizer::InstrumentMemOperand(
  70     MCParsedAsmOperand *Op, unsigned AccessSize, bool IsWrite, MCContext &Ctx,
  71     MCStreamer &Out) {
  72   assert(Op && Op->isMem() && "Op should be a memory operand.");
  73   assert((AccessSize & (AccessSize - 1)) == 0 && AccessSize <= 16 &&
  74          "AccessSize should be a power of two, less or equal than 16.");
  75
  76   X86Operand *MemOp = static_cast<X86Operand *>(Op);
  77   // FIXME: get rid of this limitation.
  78   if (IsStackReg(MemOp->getMemBaseReg()) || IsStackReg(MemOp->getMemIndexReg()))
  79     return;
  80
  81   InstrumentMemOperandImpl(MemOp, AccessSize, IsWrite, Ctx, Out);
  82 }
  83
  84 void X86AddressSanitizer::InstrumentMOV(
  85     const MCInst &Inst, SmallVectorImpl<MCParsedAsmOperand *> &Operands,
  86     MCContext &Ctx, MCStreamer &Out) {
  87   // Access size in bytes.
  88   unsigned AccessSize = 0;
  89   unsigned long OpIx = Operands.size();
  90   switch (Inst.getOpcode()) {
  91   case X86::MOV8mi:
  92   case X86::MOV8mr:
  93     AccessSize = 1;
  94     OpIx = 2;
  95     break;
  96   case X86::MOV8rm:
  97     AccessSize = 1;
  98     OpIx = 1;
  99     break;
 100   case X86::MOV16mi:
 101   case X86::MOV16mr:
 102     AccessSize = 2;
 103     OpIx = 2;
 104     break;
 105   case X86::MOV16rm:
 106     AccessSize = 2;
 107     OpIx = 1;
 108     break;
 109   case X86::MOV32mi:
 110   case X86::MOV32mr:
 111     AccessSize = 4;
 112     OpIx = 2;
 113     break;
 114   case X86::MOV32rm:
 115     AccessSize = 4;
 116     OpIx = 1;
 117     break;
 118   case X86::MOV64mi32:
 119   case X86::MOV64mr:
 120     AccessSize = 8;
 121     OpIx = 2;
 122     break;
 123   case X86::MOV64rm:
 124     AccessSize = 8;
 125     OpIx = 1;
 126     break;
 127   case X86::MOVAPDmr:
 128   case X86::MOVAPSmr:
 129     AccessSize = 16;
 130     OpIx = 2;
 131     break;
 132   case X86::MOVAPDrm:
 133   case X86::MOVAPSrm:
 134     AccessSize = 16;
 135     OpIx = 1;
 136     break;
 137   }
 138   if (OpIx >= Operands.size())
 139     return;
 140
 141   const bool IsWrite = (OpIx != 1);
 142   InstrumentMemOperand(Operands[OpIx], AccessSize, IsWrite, Ctx, Out);
 143 }
 144
 145 class X86AddressSanitizer32 : public X86AddressSanitizer {
 146 public:
 147   X86AddressSanitizer32(MCSubtargetInfo &sti) : X86AddressSanitizer(sti) {}
 148   virtual ~X86AddressSanitizer32() {}
 149
 150   virtual void InstrumentMemOperandImpl(X86Operand *Op, unsigned AccessSize,
 151                                         bool IsWrite, MCContext &Ctx,
 152                                         MCStreamer &Out) override;
 153 };
 154
 155 void X86AddressSanitizer32::InstrumentMemOperandImpl(
 156     X86Operand *Op, unsigned AccessSize, bool IsWrite, MCContext &Ctx,
 157     MCStreamer &Out) {
 158   // FIXME: emit .cfi directives for correct stack unwinding.
 159   EmitInstruction(Out, MCInstBuilder(X86::PUSH32r).addReg(X86::EAX));
 160   {
 161     MCInst Inst;
 162     Inst.setOpcode(X86::LEA32r);
 163     Inst.addOperand(MCOperand::CreateReg(X86::EAX));
 164     Op->addMemOperands(Inst, 5);
 165     EmitInstruction(Out, Inst);
 166   }
 167   EmitInstruction(Out, MCInstBuilder(X86::PUSH32r).addReg(X86::EAX));
 168   {
 169     const std::string Func = FuncName(AccessSize, IsWrite);
 170     const MCSymbol *FuncSym = Ctx.GetOrCreateSymbol(StringRef(Func));
 171     const MCSymbolRefExpr *FuncExpr =
 172         MCSymbolRefExpr::Create(FuncSym, MCSymbolRefExpr::VK_PLT, Ctx);
 173     EmitInstruction(Out, MCInstBuilder(X86::CALLpcrel32).addExpr(FuncExpr));
 174   }
 175   EmitInstruction(Out, MCInstBuilder(X86::ADD32ri).addReg(X86::ESP)
 176                            .addReg(X86::ESP).addImm(4));
 177   EmitInstruction(Out, MCInstBuilder(X86::POP32r).addReg(X86::EAX));
 178 }
 179
 180 class X86AddressSanitizer64 : public X86AddressSanitizer {
 181 public:
 182   X86AddressSanitizer64(MCSubtargetInfo &sti) : X86AddressSanitizer(sti) {}
 183   virtual ~X86AddressSanitizer64() {}
 184
 185   virtual void InstrumentMemOperandImpl(X86Operand *Op, unsigned AccessSize,
 186                                         bool IsWrite, MCContext &Ctx,
 187                                         MCStreamer &Out) override;
 188 };
 189
 190 void X86AddressSanitizer64::InstrumentMemOperandImpl(
 191     X86Operand *Op, unsigned AccessSize, bool IsWrite, MCContext &Ctx,
 192     MCStreamer &Out) {
 193   // FIXME: emit .cfi directives for correct stack unwinding.
 194   // Set %rsp below current red zone (128 bytes wide)
 195   EmitInstruction(Out, MCInstBuilder(X86::SUB64ri32).addReg(X86::RSP)
 196                            .addReg(X86::RSP).addImm(128));
 197   EmitInstruction(Out, MCInstBuilder(X86::PUSH64r).addReg(X86::RDI));
 198   {
 199     MCInst Inst;
 200     Inst.setOpcode(X86::LEA64r);
 201     Inst.addOperand(MCOperand::CreateReg(X86::RDI));
 202     Op->addMemOperands(Inst, 5);
 203     EmitInstruction(Out, Inst);
 204   }
 205   {
 206     const std::string Func = FuncName(AccessSize, IsWrite);
 207     const MCSymbol *FuncSym = Ctx.GetOrCreateSymbol(StringRef(Func));
 208     const MCSymbolRefExpr *FuncExpr =
 209         MCSymbolRefExpr::Create(FuncSym, MCSymbolRefExpr::VK_PLT, Ctx);
 210     EmitInstruction(Out, MCInstBuilder(X86::CALL64pcrel32).addExpr(FuncExpr));
 211   }
 212   EmitInstruction(Out, MCInstBuilder(X86::POP64r).addReg(X86::RDI));
 213   EmitInstruction(Out, MCInstBuilder(X86::ADD64ri32).addReg(X86::RSP)
 214                            .addReg(X86::RSP).addImm(128));
 215 }
 216
 217 } // End anonymous namespace
 218
 219 X86AsmInstrumentation::X86AsmInstrumentation() {}
 220 X86AsmInstrumentation::~X86AsmInstrumentation() {}
 221
 222 void X86AsmInstrumentation::InstrumentInstruction(
 223     const MCInst &Inst, SmallVectorImpl<MCParsedAsmOperand *> &Operands,
 224     MCContext &Ctx, MCStreamer &Out) {}
 225
 226 X86AsmInstrumentation *CreateX86AsmInstrumentation(MCSubtargetInfo &STI) {
 227   if (ClAsanInstrumentInlineAssembly) {
 228     if ((STI.getFeatureBits() & X86::Mode32Bit) != 0)
 229       return new X86AddressSanitizer32(STI);
 230     if ((STI.getFeatureBits() & X86::Mode64Bit) != 0)
 231       return new X86AddressSanitizer64(STI);
 232   }
 233   return new X86AsmInstrumentation();
 234 }
 235
 236 } // End llvm namespace