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