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 "X86RegisterInfo.h"
  14 #include "llvm/ADT/StringExtras.h"
  15 #include "llvm/ADT/Triple.h"
  16 #include "llvm/MC/MCAsmInfo.h"
  17 #include "llvm/MC/MCContext.h"
  18 #include "llvm/MC/MCInst.h"
  19 #include "llvm/MC/MCInstBuilder.h"
  20 #include "llvm/MC/MCInstrInfo.h"
  21 #include "llvm/MC/MCParser/MCParsedAsmOperand.h"
  22 #include "llvm/MC/MCStreamer.h"
  23 #include "llvm/MC/MCSubtargetInfo.h"
  24 #include "llvm/MC/MCTargetAsmParser.h"
  25 #include "llvm/MC/MCTargetOptions.h"
  26 #include "llvm/Support/CommandLine.h"
  27 #include <algorithm>
  28 #include <cassert>
  29 #include <vector>
  30
  31 // Following comment describes how assembly instrumentation works.
  32 // Currently we have only AddressSanitizer instrumentation, but we're
  33 // planning to implement MemorySanitizer for inline assembly too. If
  34 // you're not familiar with AddressSanitizer algorithm, please, read
  35 // https://code.google.com/p/address-sanitizer/wiki/AddressSanitizerAlgorithm.
  36 //
  37 // When inline assembly is parsed by an instance of X86AsmParser, all
  38 // instructions are emitted via EmitInstruction method. That's the
  39 // place where X86AsmInstrumentation analyzes an instruction and
  40 // decides, whether the instruction should be emitted as is or
  41 // instrumentation is required. The latter case happens when an
  42 // instruction reads from or writes to memory. Now instruction opcode
  43 // is explicitly checked, and if an instruction has a memory operand
  44 // (for instance, movq (%rsi, %rcx, 8), %rax) - it should be
  45 // instrumented.  There're also exist instructions that modify
  46 // memory but don't have an explicit memory operands, for instance,
  47 // movs.
  48 //
  49 // Let's consider at first 8-byte memory accesses when an instruction
  50 // has an explicit memory operand. In this case we need two registers -
  51 // AddressReg to compute address of a memory cells which are accessed
  52 // and ShadowReg to compute corresponding shadow address. So, we need
  53 // to spill both registers before instrumentation code and restore them
  54 // after instrumentation. Thus, in general, instrumentation code will
  55 // look like this:
  56 // PUSHF  # Store flags, otherwise they will be overwritten
  57 // PUSH AddressReg  # spill AddressReg
  58 // PUSH ShadowReg   # spill ShadowReg
  59 // LEA MemOp, AddressReg  # compute address of the memory operand
  60 // MOV AddressReg, ShadowReg
  61 // SHR ShadowReg, 3
  62 // # ShadowOffset(AddressReg >> 3) contains address of a shadow
  63 // # corresponding to MemOp.
  64 // CMP ShadowOffset(ShadowReg), 0  # test shadow value
  65 // JZ .Done  # when shadow equals to zero, everything is fine
  66 // MOV AddressReg, RDI
  67 // # Call __asan_report function with AddressReg as an argument
  68 // CALL __asan_report
  69 // .Done:
  70 // POP ShadowReg  # Restore ShadowReg
  71 // POP AddressReg  # Restore AddressReg
  72 // POPF  # Restore flags
  73 //
  74 // Memory accesses with different size (1-, 2-, 4- and 16-byte) are
  75 // handled in a similar manner, but small memory accesses (less than 8
  76 // byte) require an additional ScratchReg, which is used for shadow value.
  77 //
  78 // If, suppose, we're instrumenting an instruction like movs, only
  79 // contents of RDI, RDI + AccessSize * RCX, RSI, RSI + AccessSize *
  80 // RCX are checked.  In this case there're no need to spill and restore
  81 // AddressReg , ShadowReg or flags four times, they're saved on stack
  82 // just once, before instrumentation of these four addresses, and restored
  83 // at the end of the instrumentation.
  84 //
  85 // There exist several things which complicate this simple algorithm.
  86 // * Instrumented memory operand can have RSP as a base or an index
  87 //   register.  So we need to add a constant offset before computation
  88 //   of memory address, since flags, AddressReg, ShadowReg, etc. were
  89 //   already stored on stack and RSP was modified.
  90 // * Debug info (usually, DWARF) should be adjusted, because sometimes
  91 //   RSP is used as a frame register. So, we need to select some
  92 //   register as a frame register and temprorary override current CFA
  93 //   register.
  94
  95 namespace llvm {
  96 namespace {
  97
  98 static cl::opt<bool> ClAsanInstrumentAssembly(
  99     "asan-instrument-assembly",
 100     cl::desc("instrument assembly with AddressSanitizer checks"), cl::Hidden,
 101     cl::init(false));
 102
 103 const int64_t MinAllowedDisplacement = std::numeric_limits<int32_t>::min();
 104 const int64_t MaxAllowedDisplacement = std::numeric_limits<int32_t>::max();
 105
 106 int64_t ApplyDisplacementBounds(int64_t Displacement) {
 107   return std::max(std::min(MaxAllowedDisplacement, Displacement),
 108                   MinAllowedDisplacement);
 109 }
 110
 111 void CheckDisplacementBounds(int64_t Displacement) {
 112   assert(Displacement >= MinAllowedDisplacement &&
 113          Displacement <= MaxAllowedDisplacement);
 114 }
 115
 116 bool IsStackReg(unsigned Reg) { return Reg == X86::RSP || Reg == X86::ESP; }
 117
 118 bool IsSmallMemAccess(unsigned AccessSize) { return AccessSize < 8; }
 119
 120 class X86AddressSanitizer : public X86AsmInstrumentation {
 121 public:
 122   struct RegisterContext {
 123   private:
 124     enum RegOffset {
 125       REG_OFFSET_ADDRESS = 0,
 126       REG_OFFSET_SHADOW,
 127       REG_OFFSET_SCRATCH
 128     };
 129
 130   public:
 131     RegisterContext(unsigned AddressReg, unsigned ShadowReg,
 132                     unsigned ScratchReg) {
 133       BusyRegs.push_back(convReg(AddressReg, 64));
 134       BusyRegs.push_back(convReg(ShadowReg, 64));
 135       BusyRegs.push_back(convReg(ScratchReg, 64));
 136     }
 137
 138     unsigned AddressReg(unsigned Size) const {
 139       return convReg(BusyRegs[REG_OFFSET_ADDRESS], Size);
 140     }
 141
 142     unsigned ShadowReg(unsigned Size) const {
 143       return convReg(BusyRegs[REG_OFFSET_SHADOW], Size);
 144     }
 145
 146     unsigned ScratchReg(unsigned Size) const {
 147       return convReg(BusyRegs[REG_OFFSET_SCRATCH], Size);
 148     }
 149
 150     void AddBusyReg(unsigned Reg) {
 151       if (Reg != X86::NoRegister)
 152         BusyRegs.push_back(convReg(Reg, 64));
 153     }
 154
 155     void AddBusyRegs(const X86Operand &Op) {
 156       AddBusyReg(Op.getMemBaseReg());
 157       AddBusyReg(Op.getMemIndexReg());
 158     }
 159
 160     unsigned ChooseFrameReg(unsigned Size) const {
 161       static const MCPhysReg Candidates[] = { X86::RBP, X86::RAX, X86::RBX,
 162                                               X86::RCX, X86::RDX, X86::RDI,
 163                                               X86::RSI };
 164       for (unsigned Reg : Candidates) {
 165         if (!std::count(BusyRegs.begin(), BusyRegs.end(), Reg))
 166           return convReg(Reg, Size);
 167       }
 168       return X86::NoRegister;
 169     }
 170
 171   private:
 172     unsigned convReg(unsigned Reg, unsigned Size) const {
 173       return Reg == X86::NoRegister ? Reg : getX86SubSuperRegister(Reg, Size);
 174     }
 175
 176     std::vector<unsigned> BusyRegs;
 177   };
 178
 179   X86AddressSanitizer(const MCSubtargetInfo *&STI)
 180       : X86AsmInstrumentation(STI), RepPrefix(false), OrigSPOffset(0) {}
 181
 182   ~X86AddressSanitizer() override {}
 183
 184   // X86AsmInstrumentation implementation:
 185   void InstrumentAndEmitInstruction(const MCInst &Inst,
 186                                     OperandVector &Operands,
 187                                     MCContext &Ctx,
 188                                     const MCInstrInfo &MII,
 189                                     MCStreamer &Out) override {
 190     InstrumentMOVS(Inst, Operands, Ctx, MII, Out);
 191     if (RepPrefix)
 192       EmitInstruction(Out, MCInstBuilder(X86::REP_PREFIX));
 193
 194     InstrumentMOV(Inst, Operands, Ctx, MII, Out);
 195
 196     RepPrefix = (Inst.getOpcode() == X86::REP_PREFIX);
 197     if (!RepPrefix)
 198       EmitInstruction(Out, Inst);
 199   }
 200
 201   // Adjusts up stack and saves all registers used in instrumentation.
 202   virtual void InstrumentMemOperandPrologue(const RegisterContext &RegCtx,
 203                                             MCContext &Ctx,
 204                                             MCStreamer &Out) = 0;
 205
 206   // Restores all registers used in instrumentation and adjusts stack.
 207   virtual void InstrumentMemOperandEpilogue(const RegisterContext &RegCtx,
 208                                             MCContext &Ctx,
 209                                             MCStreamer &Out) = 0;
 210
 211   virtual void InstrumentMemOperandSmall(X86Operand &Op, unsigned AccessSize,
 212                                          bool IsWrite,
 213                                          const RegisterContext &RegCtx,
 214                                          MCContext &Ctx, MCStreamer &Out) = 0;
 215   virtual void InstrumentMemOperandLarge(X86Operand &Op, unsigned AccessSize,
 216                                          bool IsWrite,
 217                                          const RegisterContext &RegCtx,
 218                                          MCContext &Ctx, MCStreamer &Out) = 0;
 219
 220   virtual void InstrumentMOVSImpl(unsigned AccessSize, MCContext &Ctx,
 221                                   MCStreamer &Out) = 0;
 222
 223   void InstrumentMemOperand(X86Operand &Op, unsigned AccessSize, bool IsWrite,
 224                             const RegisterContext &RegCtx, MCContext &Ctx,
 225                             MCStreamer &Out);
 226   void InstrumentMOVSBase(unsigned DstReg, unsigned SrcReg, unsigned CntReg,
 227                           unsigned AccessSize, MCContext &Ctx, MCStreamer &Out);
 228
 229   void InstrumentMOVS(const MCInst &Inst, OperandVector &Operands,
 230                       MCContext &Ctx, const MCInstrInfo &MII, MCStreamer &Out);
 231   void InstrumentMOV(const MCInst &Inst, OperandVector &Operands,
 232                      MCContext &Ctx, const MCInstrInfo &MII, MCStreamer &Out);
 233
 234 protected:
 235   void EmitLabel(MCStreamer &Out, MCSymbol *Label) { Out.EmitLabel(Label); }
 236
 237   void EmitLEA(X86Operand &Op, unsigned Size, unsigned Reg, MCStreamer &Out) {
 238     assert(Size == 32 || Size == 64);
 239     MCInst Inst;
 240     Inst.setOpcode(Size == 32 ? X86::LEA32r : X86::LEA64r);
 241     Inst.addOperand(MCOperand::createReg(getX86SubSuperRegister(Reg, Size)));
 242     Op.addMemOperands(Inst, 5);
 243     EmitInstruction(Out, Inst);
 244   }
 245
 246   void ComputeMemOperandAddress(X86Operand &Op, unsigned Size,
 247                                 unsigned Reg, MCContext &Ctx, MCStreamer &Out);
 248
 249   // Creates new memory operand with Displacement added to an original
 250   // displacement. Residue will contain a residue which could happen when the
 251   // total displacement exceeds 32-bit limitation.
 252   std::unique_ptr<X86Operand> AddDisplacement(X86Operand &Op,
 253                                               int64_t Displacement,
 254                                               MCContext &Ctx, int64_t *Residue);
 255
 256   bool is64BitMode() const {
 257     return STI->getFeatureBits()[X86::Mode64Bit];
 258   }
 259   bool is32BitMode() const {
 260     return STI->getFeatureBits()[X86::Mode32Bit];
 261   }
 262   bool is16BitMode() const {
 263     return STI->getFeatureBits()[X86::Mode16Bit];
 264   }
 265
 266   unsigned getPointerWidth() {
 267     if (is16BitMode()) return 16;
 268     if (is32BitMode()) return 32;
 269     if (is64BitMode()) return 64;
 270     llvm_unreachable("invalid mode");
 271   }
 272
 273   // True when previous instruction was actually REP prefix.
 274   bool RepPrefix;
 275
 276   // Offset from the original SP register.
 277   int64_t OrigSPOffset;
 278 };
 279
 280 void X86AddressSanitizer::InstrumentMemOperand(
 281     X86Operand &Op, unsigned AccessSize, bool IsWrite,
 282     const RegisterContext &RegCtx, MCContext &Ctx, MCStreamer &Out) {
 283   assert(Op.isMem() && "Op should be a memory operand.");
 284   assert((AccessSize & (AccessSize - 1)) == 0 && AccessSize <= 16 &&
 285          "AccessSize should be a power of two, less or equal than 16.");
 286   // FIXME: take into account load/store alignment.
 287   if (IsSmallMemAccess(AccessSize))
 288     InstrumentMemOperandSmall(Op, AccessSize, IsWrite, RegCtx, Ctx, Out);
 289   else
 290     InstrumentMemOperandLarge(Op, AccessSize, IsWrite, RegCtx, Ctx, Out);
 291 }
 292
 293 void X86AddressSanitizer::InstrumentMOVSBase(unsigned DstReg, unsigned SrcReg,
 294                                              unsigned CntReg,
 295                                              unsigned AccessSize,
 296                                              MCContext &Ctx, MCStreamer &Out) {
 297   // FIXME: check whole ranges [DstReg .. DstReg + AccessSize * (CntReg - 1)]
 298   // and [SrcReg .. SrcReg + AccessSize * (CntReg - 1)].
 299   RegisterContext RegCtx(X86::RDX /* AddressReg */, X86::RAX /* ShadowReg */,
 300                          IsSmallMemAccess(AccessSize)
 301                              ? X86::RBX
 302                              : X86::NoRegister /* ScratchReg */);
 303   RegCtx.AddBusyReg(DstReg);
 304   RegCtx.AddBusyReg(SrcReg);
 305   RegCtx.AddBusyReg(CntReg);
 306
 307   InstrumentMemOperandPrologue(RegCtx, Ctx, Out);
 308
 309   // Test (%SrcReg)
 310   {
 311     const MCExpr *Disp = MCConstantExpr::create(0, Ctx);
 312     std::unique_ptr<X86Operand> Op(X86Operand::CreateMem(
 313         getPointerWidth(), 0, Disp, SrcReg, 0, AccessSize, SMLoc(), SMLoc()));
 314     InstrumentMemOperand(*Op, AccessSize, false /* IsWrite */, RegCtx, Ctx,
 315                          Out);
 316   }
 317
 318   // Test -1(%SrcReg, %CntReg, AccessSize)
 319   {
 320     const MCExpr *Disp = MCConstantExpr::create(-1, Ctx);
 321     std::unique_ptr<X86Operand> Op(X86Operand::CreateMem(
 322         getPointerWidth(), 0, Disp, SrcReg, CntReg, AccessSize, SMLoc(),
 323         SMLoc()));
 324     InstrumentMemOperand(*Op, AccessSize, false /* IsWrite */, RegCtx, Ctx,
 325                          Out);
 326   }
 327
 328   // Test (%DstReg)
 329   {
 330     const MCExpr *Disp = MCConstantExpr::create(0, Ctx);
 331     std::unique_ptr<X86Operand> Op(X86Operand::CreateMem(
 332         getPointerWidth(), 0, Disp, DstReg, 0, AccessSize, SMLoc(), SMLoc()));
 333     InstrumentMemOperand(*Op, AccessSize, true /* IsWrite */, RegCtx, Ctx, Out);
 334   }
 335
 336   // Test -1(%DstReg, %CntReg, AccessSize)
 337   {
 338     const MCExpr *Disp = MCConstantExpr::create(-1, Ctx);
 339     std::unique_ptr<X86Operand> Op(X86Operand::CreateMem(
 340         getPointerWidth(), 0, Disp, DstReg, CntReg, AccessSize, SMLoc(),
 341         SMLoc()));
 342     InstrumentMemOperand(*Op, AccessSize, true /* IsWrite */, RegCtx, Ctx, Out);
 343   }
 344
 345   InstrumentMemOperandEpilogue(RegCtx, Ctx, Out);
 346 }
 347
 348 void X86AddressSanitizer::InstrumentMOVS(const MCInst &Inst,
 349                                          OperandVector &Operands,
 350                                          MCContext &Ctx, const MCInstrInfo &MII,
 351                                          MCStreamer &Out) {
 352   // Access size in bytes.
 353   unsigned AccessSize = 0;
 354
 355   switch (Inst.getOpcode()) {
 356   case X86::MOVSB:
 357     AccessSize = 1;
 358     break;
 359   case X86::MOVSW:
 360     AccessSize = 2;
 361     break;
 362   case X86::MOVSL:
 363     AccessSize = 4;
 364     break;
 365   case X86::MOVSQ:
 366     AccessSize = 8;
 367     break;
 368   default:
 369     return;
 370   }
 371
 372   InstrumentMOVSImpl(AccessSize, Ctx, Out);
 373 }
 374
 375 void X86AddressSanitizer::InstrumentMOV(const MCInst &Inst,
 376                                         OperandVector &Operands, MCContext &Ctx,
 377                                         const MCInstrInfo &MII,
 378                                         MCStreamer &Out) {
 379   // Access size in bytes.
 380   unsigned AccessSize = 0;
 381
 382   switch (Inst.getOpcode()) {
 383   case X86::MOV8mi:
 384   case X86::MOV8mr:
 385   case X86::MOV8rm:
 386     AccessSize = 1;
 387     break;
 388   case X86::MOV16mi:
 389   case X86::MOV16mr:
 390   case X86::MOV16rm:
 391     AccessSize = 2;
 392     break;
 393   case X86::MOV32mi:
 394   case X86::MOV32mr:
 395   case X86::MOV32rm:
 396     AccessSize = 4;
 397     break;
 398   case X86::MOV64mi32:
 399   case X86::MOV64mr:
 400   case X86::MOV64rm:
 401     AccessSize = 8;
 402     break;
 403   case X86::MOVAPDmr:
 404   case X86::MOVAPSmr:
 405   case X86::MOVAPDrm:
 406   case X86::MOVAPSrm:
 407     AccessSize = 16;
 408     break;
 409   default:
 410     return;
 411   }
 412
 413   const bool IsWrite = MII.get(Inst.getOpcode()).mayStore();
 414
 415   for (unsigned Ix = 0; Ix < Operands.size(); ++Ix) {
 416     assert(Operands[Ix]);
 417     MCParsedAsmOperand &Op = *Operands[Ix];
 418     if (Op.isMem()) {
 419       X86Operand &MemOp = static_cast<X86Operand &>(Op);
 420       RegisterContext RegCtx(
 421           X86::RDI /* AddressReg */, X86::RAX /* ShadowReg */,
 422           IsSmallMemAccess(AccessSize) ? X86::RCX
 423                                        : X86::NoRegister /* ScratchReg */);
 424       RegCtx.AddBusyRegs(MemOp);
 425       InstrumentMemOperandPrologue(RegCtx, Ctx, Out);
 426       InstrumentMemOperand(MemOp, AccessSize, IsWrite, RegCtx, Ctx, Out);
 427       InstrumentMemOperandEpilogue(RegCtx, Ctx, Out);
 428     }
 429   }
 430 }
 431
 432 void X86AddressSanitizer::ComputeMemOperandAddress(X86Operand &Op,
 433                                                    unsigned Size,
 434                                                    unsigned Reg, MCContext &Ctx,
 435                                                    MCStreamer &Out) {
 436   int64_t Displacement = 0;
 437   if (IsStackReg(Op.getMemBaseReg()))
 438     Displacement -= OrigSPOffset;
 439   if (IsStackReg(Op.getMemIndexReg()))
 440     Displacement -= OrigSPOffset * Op.getMemScale();
 441
 442   assert(Displacement >= 0);
 443
 444   // Emit Op as is.
 445   if (Displacement == 0) {
 446     EmitLEA(Op, Size, Reg, Out);
 447     return;
 448   }
 449
 450   int64_t Residue;
 451   std::unique_ptr<X86Operand> NewOp =
 452       AddDisplacement(Op, Displacement, Ctx, &Residue);
 453   EmitLEA(*NewOp, Size, Reg, Out);
 454
 455   while (Residue != 0) {
 456     const MCConstantExpr *Disp =
 457         MCConstantExpr::create(ApplyDisplacementBounds(Residue), Ctx);
 458     std::unique_ptr<X86Operand> DispOp =
 459         X86Operand::CreateMem(getPointerWidth(), 0, Disp, Reg, 0, 1, SMLoc(),
 460                               SMLoc());
 461     EmitLEA(*DispOp, Size, Reg, Out);
 462     Residue -= Disp->getValue();
 463   }
 464 }
 465
 466 std::unique_ptr<X86Operand>
 467 X86AddressSanitizer::AddDisplacement(X86Operand &Op, int64_t Displacement,
 468                                      MCContext &Ctx, int64_t *Residue) {
 469   assert(Displacement >= 0);
 470
 471   if (Displacement == 0 ||
 472       (Op.getMemDisp() && Op.getMemDisp()->getKind() != MCExpr::Constant)) {
 473     *Residue = Displacement;
 474     return X86Operand::CreateMem(Op.getMemModeSize(), Op.getMemSegReg(),
 475                                  Op.getMemDisp(), Op.getMemBaseReg(),
 476                                  Op.getMemIndexReg(), Op.getMemScale(),
 477                                  SMLoc(), SMLoc());
 478   }
 479
 480   int64_t OrigDisplacement =
 481       static_cast<const MCConstantExpr *>(Op.getMemDisp())->getValue();
 482   CheckDisplacementBounds(OrigDisplacement);
 483   Displacement += OrigDisplacement;
 484
 485   int64_t NewDisplacement = ApplyDisplacementBounds(Displacement);
 486   CheckDisplacementBounds(NewDisplacement);
 487
 488   *Residue = Displacement - NewDisplacement;
 489   const MCExpr *Disp = MCConstantExpr::create(NewDisplacement, Ctx);
 490   return X86Operand::CreateMem(Op.getMemModeSize(), Op.getMemSegReg(), Disp,
 491                                Op.getMemBaseReg(), Op.getMemIndexReg(),
 492                                Op.getMemScale(), SMLoc(), SMLoc());
 493 }
 494
 495 class X86AddressSanitizer32 : public X86AddressSanitizer {
 496 public:
 497   static const long kShadowOffset = 0x20000000;
 498
 499   X86AddressSanitizer32(const MCSubtargetInfo *&STI)
 500       : X86AddressSanitizer(STI) {}
 501
 502   ~X86AddressSanitizer32() override {}
 503
 504   unsigned GetFrameReg(const MCContext &Ctx, MCStreamer &Out) {
 505     unsigned FrameReg = GetFrameRegGeneric(Ctx, Out);
 506     if (FrameReg == X86::NoRegister)
 507       return FrameReg;
 508     return getX86SubSuperRegister(FrameReg, 32);
 509   }
 510
 511   void SpillReg(MCStreamer &Out, unsigned Reg) {
 512     EmitInstruction(Out, MCInstBuilder(X86::PUSH32r).addReg(Reg));
 513     OrigSPOffset -= 4;
 514   }
 515
 516   void RestoreReg(MCStreamer &Out, unsigned Reg) {
 517     EmitInstruction(Out, MCInstBuilder(X86::POP32r).addReg(Reg));
 518     OrigSPOffset += 4;
 519   }
 520
 521   void StoreFlags(MCStreamer &Out) {
 522     EmitInstruction(Out, MCInstBuilder(X86::PUSHF32));
 523     OrigSPOffset -= 4;
 524   }
 525
 526   void RestoreFlags(MCStreamer &Out) {
 527     EmitInstruction(Out, MCInstBuilder(X86::POPF32));
 528     OrigSPOffset += 4;
 529   }
 530
 531   void InstrumentMemOperandPrologue(const RegisterContext &RegCtx,
 532                                     MCContext &Ctx,
 533                                     MCStreamer &Out) override {
 534     unsigned LocalFrameReg = RegCtx.ChooseFrameReg(32);
 535     assert(LocalFrameReg != X86::NoRegister);
 536
 537     const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
 538     unsigned FrameReg = GetFrameReg(Ctx, Out);
 539     if (MRI && FrameReg != X86::NoRegister) {
 540       SpillReg(Out, LocalFrameReg);
 541       if (FrameReg == X86::ESP) {
 542         Out.EmitCFIAdjustCfaOffset(4 /* byte size of the LocalFrameReg */);
 543         Out.EmitCFIRelOffset(
 544             MRI->getDwarfRegNum(LocalFrameReg, true /* IsEH */), 0);
 545       }
 546       EmitInstruction(
 547           Out,
 548           MCInstBuilder(X86::MOV32rr).addReg(LocalFrameReg).addReg(FrameReg));
 549       Out.EmitCFIRememberState();
 550       Out.EmitCFIDefCfaRegister(
 551           MRI->getDwarfRegNum(LocalFrameReg, true /* IsEH */));
 552     }
 553
 554     SpillReg(Out, RegCtx.AddressReg(32));
 555     SpillReg(Out, RegCtx.ShadowReg(32));
 556     if (RegCtx.ScratchReg(32) != X86::NoRegister)
 557       SpillReg(Out, RegCtx.ScratchReg(32));
 558     StoreFlags(Out);
 559   }
 560
 561   void InstrumentMemOperandEpilogue(const RegisterContext &RegCtx,
 562                                     MCContext &Ctx,
 563                                     MCStreamer &Out) override {
 564     unsigned LocalFrameReg = RegCtx.ChooseFrameReg(32);
 565     assert(LocalFrameReg != X86::NoRegister);
 566
 567     RestoreFlags(Out);
 568     if (RegCtx.ScratchReg(32) != X86::NoRegister)
 569       RestoreReg(Out, RegCtx.ScratchReg(32));
 570     RestoreReg(Out, RegCtx.ShadowReg(32));
 571     RestoreReg(Out, RegCtx.AddressReg(32));
 572
 573     unsigned FrameReg = GetFrameReg(Ctx, Out);
 574     if (Ctx.getRegisterInfo() && FrameReg != X86::NoRegister) {
 575       RestoreReg(Out, LocalFrameReg);
 576       Out.EmitCFIRestoreState();
 577       if (FrameReg == X86::ESP)
 578         Out.EmitCFIAdjustCfaOffset(-4 /* byte size of the LocalFrameReg */);
 579     }
 580   }
 581
 582   void InstrumentMemOperandSmall(X86Operand &Op, unsigned AccessSize,
 583                                  bool IsWrite,
 584                                  const RegisterContext &RegCtx,
 585                                  MCContext &Ctx,
 586                                  MCStreamer &Out) override;
 587   void InstrumentMemOperandLarge(X86Operand &Op, unsigned AccessSize,
 588                                  bool IsWrite,
 589                                  const RegisterContext &RegCtx,
 590                                  MCContext &Ctx,
 591                                  MCStreamer &Out) override;
 592   void InstrumentMOVSImpl(unsigned AccessSize, MCContext &Ctx,
 593                           MCStreamer &Out) override;
 594
 595 private:
 596   void EmitCallAsanReport(unsigned AccessSize, bool IsWrite, MCContext &Ctx,
 597                           MCStreamer &Out, const RegisterContext &RegCtx) {
 598     EmitInstruction(Out, MCInstBuilder(X86::CLD));
 599     EmitInstruction(Out, MCInstBuilder(X86::MMX_EMMS));
 600
 601     EmitInstruction(Out, MCInstBuilder(X86::AND64ri8)
 602                              .addReg(X86::ESP)
 603                              .addReg(X86::ESP)
 604                              .addImm(-16));
 605     EmitInstruction(
 606         Out, MCInstBuilder(X86::PUSH32r).addReg(RegCtx.AddressReg(32)));
 607
 608     MCSymbol *FnSym = Ctx.getOrCreateSymbol(llvm::Twine("__asan_report_") +
 609                                             (IsWrite ? "store" : "load") +
 610                                             llvm::Twine(AccessSize));
 611     const MCSymbolRefExpr *FnExpr =
 612         MCSymbolRefExpr::create(FnSym, MCSymbolRefExpr::VK_PLT, Ctx);
 613     EmitInstruction(Out, MCInstBuilder(X86::CALLpcrel32).addExpr(FnExpr));
 614   }
 615 };
 616
 617 void X86AddressSanitizer32::InstrumentMemOperandSmall(
 618     X86Operand &Op, unsigned AccessSize, bool IsWrite,
 619     const RegisterContext &RegCtx, MCContext &Ctx, MCStreamer &Out) {
 620   unsigned AddressRegI32 = RegCtx.AddressReg(32);
 621   unsigned ShadowRegI32 = RegCtx.ShadowReg(32);
 622   unsigned ShadowRegI8 = RegCtx.ShadowReg(8);
 623
 624   assert(RegCtx.ScratchReg(32) != X86::NoRegister);
 625   unsigned ScratchRegI32 = RegCtx.ScratchReg(32);
 626
 627   ComputeMemOperandAddress(Op, 32, AddressRegI32, Ctx, Out);
 628
 629   EmitInstruction(Out, MCInstBuilder(X86::MOV32rr).addReg(ShadowRegI32).addReg(
 630                            AddressRegI32));
 631   EmitInstruction(Out, MCInstBuilder(X86::SHR32ri)
 632                            .addReg(ShadowRegI32)
 633                            .addReg(ShadowRegI32)
 634                            .addImm(3));
 635
 636   {
 637     MCInst Inst;
 638     Inst.setOpcode(X86::MOV8rm);
 639     Inst.addOperand(MCOperand::createReg(ShadowRegI8));
 640     const MCExpr *Disp = MCConstantExpr::create(kShadowOffset, Ctx);
 641     std::unique_ptr<X86Operand> Op(
 642         X86Operand::CreateMem(getPointerWidth(), 0, Disp, ShadowRegI32, 0, 1,
 643                               SMLoc(), SMLoc()));
 644     Op->addMemOperands(Inst, 5);
 645     EmitInstruction(Out, Inst);
 646   }
 647
 648   EmitInstruction(
 649       Out, MCInstBuilder(X86::TEST8rr).addReg(ShadowRegI8).addReg(ShadowRegI8));
 650   MCSymbol *DoneSym = Ctx.createTempSymbol();
 651   const MCExpr *DoneExpr = MCSymbolRefExpr::create(DoneSym, Ctx);
 652   EmitInstruction(Out, MCInstBuilder(X86::JE_1).addExpr(DoneExpr));
 653
 654   EmitInstruction(Out, MCInstBuilder(X86::MOV32rr).addReg(ScratchRegI32).addReg(
 655                            AddressRegI32));
 656   EmitInstruction(Out, MCInstBuilder(X86::AND32ri)
 657                            .addReg(ScratchRegI32)
 658                            .addReg(ScratchRegI32)
 659                            .addImm(7));
 660
 661   switch (AccessSize) {
 662   default: llvm_unreachable("Incorrect access size");
 663   case 1:
 664     break;
 665   case 2: {
 666     const MCExpr *Disp = MCConstantExpr::create(1, Ctx);
 667     std::unique_ptr<X86Operand> Op(
 668         X86Operand::CreateMem(getPointerWidth(), 0, Disp, ScratchRegI32, 0, 1,
 669                               SMLoc(), SMLoc()));
 670     EmitLEA(*Op, 32, ScratchRegI32, Out);
 671     break;
 672   }
 673   case 4:
 674     EmitInstruction(Out, MCInstBuilder(X86::ADD32ri8)
 675                              .addReg(ScratchRegI32)
 676                              .addReg(ScratchRegI32)
 677                              .addImm(3));
 678     break;
 679   }
 680
 681   EmitInstruction(
 682       Out,
 683       MCInstBuilder(X86::MOVSX32rr8).addReg(ShadowRegI32).addReg(ShadowRegI8));
 684   EmitInstruction(Out, MCInstBuilder(X86::CMP32rr).addReg(ScratchRegI32).addReg(
 685                            ShadowRegI32));
 686   EmitInstruction(Out, MCInstBuilder(X86::JL_1).addExpr(DoneExpr));
 687
 688   EmitCallAsanReport(AccessSize, IsWrite, Ctx, Out, RegCtx);
 689   EmitLabel(Out, DoneSym);
 690 }
 691
 692 void X86AddressSanitizer32::InstrumentMemOperandLarge(
 693     X86Operand &Op, unsigned AccessSize, bool IsWrite,
 694     const RegisterContext &RegCtx, MCContext &Ctx, MCStreamer &Out) {
 695   unsigned AddressRegI32 = RegCtx.AddressReg(32);
 696   unsigned ShadowRegI32 = RegCtx.ShadowReg(32);
 697
 698   ComputeMemOperandAddress(Op, 32, AddressRegI32, Ctx, Out);
 699
 700   EmitInstruction(Out, MCInstBuilder(X86::MOV32rr).addReg(ShadowRegI32).addReg(
 701                            AddressRegI32));
 702   EmitInstruction(Out, MCInstBuilder(X86::SHR32ri)
 703                            .addReg(ShadowRegI32)
 704                            .addReg(ShadowRegI32)
 705                            .addImm(3));
 706   {
 707     MCInst Inst;
 708     switch (AccessSize) {
 709     default: llvm_unreachable("Incorrect access size");
 710     case 8:
 711       Inst.setOpcode(X86::CMP8mi);
 712       break;
 713     case 16:
 714       Inst.setOpcode(X86::CMP16mi);
 715       break;
 716     }
 717     const MCExpr *Disp = MCConstantExpr::create(kShadowOffset, Ctx);
 718     std::unique_ptr<X86Operand> Op(
 719         X86Operand::CreateMem(getPointerWidth(), 0, Disp, ShadowRegI32, 0, 1,
 720                               SMLoc(), SMLoc()));
 721     Op->addMemOperands(Inst, 5);
 722     Inst.addOperand(MCOperand::createImm(0));
 723     EmitInstruction(Out, Inst);
 724   }
 725   MCSymbol *DoneSym = Ctx.createTempSymbol();
 726   const MCExpr *DoneExpr = MCSymbolRefExpr::create(DoneSym, Ctx);
 727   EmitInstruction(Out, MCInstBuilder(X86::JE_1).addExpr(DoneExpr));
 728
 729   EmitCallAsanReport(AccessSize, IsWrite, Ctx, Out, RegCtx);
 730   EmitLabel(Out, DoneSym);
 731 }
 732
 733 void X86AddressSanitizer32::InstrumentMOVSImpl(unsigned AccessSize,
 734                                                MCContext &Ctx,
 735                                                MCStreamer &Out) {
 736   StoreFlags(Out);
 737
 738   // No need to test when ECX is equals to zero.
 739   MCSymbol *DoneSym = Ctx.createTempSymbol();
 740   const MCExpr *DoneExpr = MCSymbolRefExpr::create(DoneSym, Ctx);
 741   EmitInstruction(
 742       Out, MCInstBuilder(X86::TEST32rr).addReg(X86::ECX).addReg(X86::ECX));
 743   EmitInstruction(Out, MCInstBuilder(X86::JE_1).addExpr(DoneExpr));
 744
 745   // Instrument first and last elements in src and dst range.
 746   InstrumentMOVSBase(X86::EDI /* DstReg */, X86::ESI /* SrcReg */,
 747                      X86::ECX /* CntReg */, AccessSize, Ctx, Out);
 748
 749   EmitLabel(Out, DoneSym);
 750   RestoreFlags(Out);
 751 }
 752
 753 class X86AddressSanitizer64 : public X86AddressSanitizer {
 754 public:
 755   static const long kShadowOffset = 0x7fff8000;
 756
 757   X86AddressSanitizer64(const MCSubtargetInfo *&STI)
 758       : X86AddressSanitizer(STI) {}
 759
 760   ~X86AddressSanitizer64() override {}
 761
 762   unsigned GetFrameReg(const MCContext &Ctx, MCStreamer &Out) {
 763     unsigned FrameReg = GetFrameRegGeneric(Ctx, Out);
 764     if (FrameReg == X86::NoRegister)
 765       return FrameReg;
 766     return getX86SubSuperRegister(FrameReg, 64);
 767   }
 768
 769   void SpillReg(MCStreamer &Out, unsigned Reg) {
 770     EmitInstruction(Out, MCInstBuilder(X86::PUSH64r).addReg(Reg));
 771     OrigSPOffset -= 8;
 772   }
 773
 774   void RestoreReg(MCStreamer &Out, unsigned Reg) {
 775     EmitInstruction(Out, MCInstBuilder(X86::POP64r).addReg(Reg));
 776     OrigSPOffset += 8;
 777   }
 778
 779   void StoreFlags(MCStreamer &Out) {
 780     EmitInstruction(Out, MCInstBuilder(X86::PUSHF64));
 781     OrigSPOffset -= 8;
 782   }
 783
 784   void RestoreFlags(MCStreamer &Out) {
 785     EmitInstruction(Out, MCInstBuilder(X86::POPF64));
 786     OrigSPOffset += 8;
 787   }
 788
 789   void InstrumentMemOperandPrologue(const RegisterContext &RegCtx,
 790                                     MCContext &Ctx,
 791                                     MCStreamer &Out) override {
 792     unsigned LocalFrameReg = RegCtx.ChooseFrameReg(64);
 793     assert(LocalFrameReg != X86::NoRegister);
 794
 795     const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
 796     unsigned FrameReg = GetFrameReg(Ctx, Out);
 797     if (MRI && FrameReg != X86::NoRegister) {
 798       SpillReg(Out, X86::RBP);
 799       if (FrameReg == X86::RSP) {
 800         Out.EmitCFIAdjustCfaOffset(8 /* byte size of the LocalFrameReg */);
 801         Out.EmitCFIRelOffset(
 802             MRI->getDwarfRegNum(LocalFrameReg, true /* IsEH */), 0);
 803       }
 804       EmitInstruction(
 805           Out,
 806           MCInstBuilder(X86::MOV64rr).addReg(LocalFrameReg).addReg(FrameReg));
 807       Out.EmitCFIRememberState();
 808       Out.EmitCFIDefCfaRegister(
 809           MRI->getDwarfRegNum(LocalFrameReg, true /* IsEH */));
 810     }
 811
 812     EmitAdjustRSP(Ctx, Out, -128);
 813     SpillReg(Out, RegCtx.ShadowReg(64));
 814     SpillReg(Out, RegCtx.AddressReg(64));
 815     if (RegCtx.ScratchReg(64) != X86::NoRegister)
 816       SpillReg(Out, RegCtx.ScratchReg(64));
 817     StoreFlags(Out);
 818   }
 819
 820   void InstrumentMemOperandEpilogue(const RegisterContext &RegCtx,
 821                                     MCContext &Ctx,
 822                                     MCStreamer &Out) override {
 823     unsigned LocalFrameReg = RegCtx.ChooseFrameReg(64);
 824     assert(LocalFrameReg != X86::NoRegister);
 825
 826     RestoreFlags(Out);
 827     if (RegCtx.ScratchReg(64) != X86::NoRegister)
 828       RestoreReg(Out, RegCtx.ScratchReg(64));
 829     RestoreReg(Out, RegCtx.AddressReg(64));
 830     RestoreReg(Out, RegCtx.ShadowReg(64));
 831     EmitAdjustRSP(Ctx, Out, 128);
 832
 833     unsigned FrameReg = GetFrameReg(Ctx, Out);
 834     if (Ctx.getRegisterInfo() && FrameReg != X86::NoRegister) {
 835       RestoreReg(Out, LocalFrameReg);
 836       Out.EmitCFIRestoreState();
 837       if (FrameReg == X86::RSP)
 838         Out.EmitCFIAdjustCfaOffset(-8 /* byte size of the LocalFrameReg */);
 839     }
 840   }
 841
 842   void InstrumentMemOperandSmall(X86Operand &Op, unsigned AccessSize,
 843                                  bool IsWrite,
 844                                  const RegisterContext &RegCtx,
 845                                  MCContext &Ctx,
 846                                  MCStreamer &Out) override;
 847   void InstrumentMemOperandLarge(X86Operand &Op, unsigned AccessSize,
 848                                  bool IsWrite,
 849                                  const RegisterContext &RegCtx,
 850                                  MCContext &Ctx,
 851                                  MCStreamer &Out) override;
 852   void InstrumentMOVSImpl(unsigned AccessSize, MCContext &Ctx,
 853                           MCStreamer &Out) override;
 854
 855 private:
 856   void EmitAdjustRSP(MCContext &Ctx, MCStreamer &Out, long Offset) {
 857     const MCExpr *Disp = MCConstantExpr::create(Offset, Ctx);
 858     std::unique_ptr<X86Operand> Op(
 859         X86Operand::CreateMem(getPointerWidth(), 0, Disp, X86::RSP, 0, 1,
 860                               SMLoc(), SMLoc()));
 861     EmitLEA(*Op, 64, X86::RSP, Out);
 862     OrigSPOffset += Offset;
 863   }
 864
 865   void EmitCallAsanReport(unsigned AccessSize, bool IsWrite, MCContext &Ctx,
 866                           MCStreamer &Out, const RegisterContext &RegCtx) {
 867     EmitInstruction(Out, MCInstBuilder(X86::CLD));
 868     EmitInstruction(Out, MCInstBuilder(X86::MMX_EMMS));
 869
 870     EmitInstruction(Out, MCInstBuilder(X86::AND64ri8)
 871                              .addReg(X86::RSP)
 872                              .addReg(X86::RSP)
 873                              .addImm(-16));
 874
 875     if (RegCtx.AddressReg(64) != X86::RDI) {
 876       EmitInstruction(Out, MCInstBuilder(X86::MOV64rr).addReg(X86::RDI).addReg(
 877                                RegCtx.AddressReg(64)));
 878     }
 879     MCSymbol *FnSym = Ctx.getOrCreateSymbol(llvm::Twine("__asan_report_") +
 880                                             (IsWrite ? "store" : "load") +
 881                                             llvm::Twine(AccessSize));
 882     const MCSymbolRefExpr *FnExpr =
 883         MCSymbolRefExpr::create(FnSym, MCSymbolRefExpr::VK_PLT, Ctx);
 884     EmitInstruction(Out, MCInstBuilder(X86::CALL64pcrel32).addExpr(FnExpr));
 885   }
 886 };
 887
 888 void X86AddressSanitizer64::InstrumentMemOperandSmall(
 889     X86Operand &Op, unsigned AccessSize, bool IsWrite,
 890     const RegisterContext &RegCtx, MCContext &Ctx, MCStreamer &Out) {
 891   unsigned AddressRegI64 = RegCtx.AddressReg(64);
 892   unsigned AddressRegI32 = RegCtx.AddressReg(32);
 893   unsigned ShadowRegI64 = RegCtx.ShadowReg(64);
 894   unsigned ShadowRegI32 = RegCtx.ShadowReg(32);
 895   unsigned ShadowRegI8 = RegCtx.ShadowReg(8);
 896
 897   assert(RegCtx.ScratchReg(32) != X86::NoRegister);
 898   unsigned ScratchRegI32 = RegCtx.ScratchReg(32);
 899
 900   ComputeMemOperandAddress(Op, 64, AddressRegI64, Ctx, Out);
 901
 902   EmitInstruction(Out, MCInstBuilder(X86::MOV64rr).addReg(ShadowRegI64).addReg(
 903                            AddressRegI64));
 904   EmitInstruction(Out, MCInstBuilder(X86::SHR64ri)
 905                            .addReg(ShadowRegI64)
 906                            .addReg(ShadowRegI64)
 907                            .addImm(3));
 908   {
 909     MCInst Inst;
 910     Inst.setOpcode(X86::MOV8rm);
 911     Inst.addOperand(MCOperand::createReg(ShadowRegI8));
 912     const MCExpr *Disp = MCConstantExpr::create(kShadowOffset, Ctx);
 913     std::unique_ptr<X86Operand> Op(
 914         X86Operand::CreateMem(getPointerWidth(), 0, Disp, ShadowRegI64, 0, 1,
 915                               SMLoc(), SMLoc()));
 916     Op->addMemOperands(Inst, 5);
 917     EmitInstruction(Out, Inst);
 918   }
 919
 920   EmitInstruction(
 921       Out, MCInstBuilder(X86::TEST8rr).addReg(ShadowRegI8).addReg(ShadowRegI8));
 922   MCSymbol *DoneSym = Ctx.createTempSymbol();
 923   const MCExpr *DoneExpr = MCSymbolRefExpr::create(DoneSym, Ctx);
 924   EmitInstruction(Out, MCInstBuilder(X86::JE_1).addExpr(DoneExpr));
 925
 926   EmitInstruction(Out, MCInstBuilder(X86::MOV32rr).addReg(ScratchRegI32).addReg(
 927                            AddressRegI32));
 928   EmitInstruction(Out, MCInstBuilder(X86::AND32ri)
 929                            .addReg(ScratchRegI32)
 930                            .addReg(ScratchRegI32)
 931                            .addImm(7));
 932
 933   switch (AccessSize) {
 934   default: llvm_unreachable("Incorrect access size");
 935   case 1:
 936     break;
 937   case 2: {
 938     const MCExpr *Disp = MCConstantExpr::create(1, Ctx);
 939     std::unique_ptr<X86Operand> Op(
 940         X86Operand::CreateMem(getPointerWidth(), 0, Disp, ScratchRegI32, 0, 1,
 941                               SMLoc(), SMLoc()));
 942     EmitLEA(*Op, 32, ScratchRegI32, Out);
 943     break;
 944   }
 945   case 4:
 946     EmitInstruction(Out, MCInstBuilder(X86::ADD32ri8)
 947                              .addReg(ScratchRegI32)
 948                              .addReg(ScratchRegI32)
 949                              .addImm(3));
 950     break;
 951   }
 952
 953   EmitInstruction(
 954       Out,
 955       MCInstBuilder(X86::MOVSX32rr8).addReg(ShadowRegI32).addReg(ShadowRegI8));
 956   EmitInstruction(Out, MCInstBuilder(X86::CMP32rr).addReg(ScratchRegI32).addReg(
 957                            ShadowRegI32));
 958   EmitInstruction(Out, MCInstBuilder(X86::JL_1).addExpr(DoneExpr));
 959
 960   EmitCallAsanReport(AccessSize, IsWrite, Ctx, Out, RegCtx);
 961   EmitLabel(Out, DoneSym);
 962 }
 963
 964 void X86AddressSanitizer64::InstrumentMemOperandLarge(
 965     X86Operand &Op, unsigned AccessSize, bool IsWrite,
 966     const RegisterContext &RegCtx, MCContext &Ctx, MCStreamer &Out) {
 967   unsigned AddressRegI64 = RegCtx.AddressReg(64);
 968   unsigned ShadowRegI64 = RegCtx.ShadowReg(64);
 969
 970   ComputeMemOperandAddress(Op, 64, AddressRegI64, Ctx, Out);
 971
 972   EmitInstruction(Out, MCInstBuilder(X86::MOV64rr).addReg(ShadowRegI64).addReg(
 973                            AddressRegI64));
 974   EmitInstruction(Out, MCInstBuilder(X86::SHR64ri)
 975                            .addReg(ShadowRegI64)
 976                            .addReg(ShadowRegI64)
 977                            .addImm(3));
 978   {
 979     MCInst Inst;
 980     switch (AccessSize) {
 981     default: llvm_unreachable("Incorrect access size");
 982     case 8:
 983       Inst.setOpcode(X86::CMP8mi);
 984       break;
 985     case 16:
 986       Inst.setOpcode(X86::CMP16mi);
 987       break;
 988     }
 989     const MCExpr *Disp = MCConstantExpr::create(kShadowOffset, Ctx);
 990     std::unique_ptr<X86Operand> Op(
 991         X86Operand::CreateMem(getPointerWidth(), 0, Disp, ShadowRegI64, 0, 1,
 992                               SMLoc(), SMLoc()));
 993     Op->addMemOperands(Inst, 5);
 994     Inst.addOperand(MCOperand::createImm(0));
 995     EmitInstruction(Out, Inst);
 996   }
 997
 998   MCSymbol *DoneSym = Ctx.createTempSymbol();
 999   const MCExpr *DoneExpr = MCSymbolRefExpr::create(DoneSym, Ctx);
1000   EmitInstruction(Out, MCInstBuilder(X86::JE_1).addExpr(DoneExpr));
1001
1002   EmitCallAsanReport(AccessSize, IsWrite, Ctx, Out, RegCtx);
1003   EmitLabel(Out, DoneSym);
1004 }
1005
1006 void X86AddressSanitizer64::InstrumentMOVSImpl(unsigned AccessSize,
1007                                                MCContext &Ctx,
1008                                                MCStreamer &Out) {
1009   StoreFlags(Out);
1010
1011   // No need to test when RCX is equals to zero.
1012   MCSymbol *DoneSym = Ctx.createTempSymbol();
1013   const MCExpr *DoneExpr = MCSymbolRefExpr::create(DoneSym, Ctx);
1014   EmitInstruction(
1015       Out, MCInstBuilder(X86::TEST64rr).addReg(X86::RCX).addReg(X86::RCX));
1016   EmitInstruction(Out, MCInstBuilder(X86::JE_1).addExpr(DoneExpr));
1017
1018   // Instrument first and last elements in src and dst range.
1019   InstrumentMOVSBase(X86::RDI /* DstReg */, X86::RSI /* SrcReg */,
1020                      X86::RCX /* CntReg */, AccessSize, Ctx, Out);
1021
1022   EmitLabel(Out, DoneSym);
1023   RestoreFlags(Out);
1024 }
1025
1026 } // End anonymous namespace
1027
1028 X86AsmInstrumentation::X86AsmInstrumentation(const MCSubtargetInfo *&STI)
1029     : STI(STI), InitialFrameReg(0) {}
1030
1031 X86AsmInstrumentation::~X86AsmInstrumentation() {}
1032
1033 void X86AsmInstrumentation::InstrumentAndEmitInstruction(
1034     const MCInst &Inst, OperandVector &Operands, MCContext &Ctx,
1035     const MCInstrInfo &MII, MCStreamer &Out) {
1036   EmitInstruction(Out, Inst);
1037 }
1038
1039 void X86AsmInstrumentation::EmitInstruction(MCStreamer &Out,
1040                                             const MCInst &Inst) {
1041   Out.EmitInstruction(Inst, *STI);
1042 }
1043
1044 unsigned X86AsmInstrumentation::GetFrameRegGeneric(const MCContext &Ctx,
1045                                                    MCStreamer &Out) {
1046   if (!Out.getNumFrameInfos()) // No active dwarf frame
1047     return X86::NoRegister;
1048   const MCDwarfFrameInfo &Frame = Out.getDwarfFrameInfos().back();
1049   if (Frame.End) // Active dwarf frame is closed
1050     return X86::NoRegister;
1051   const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
1052   if (!MRI) // No register info
1053     return X86::NoRegister;
1054
1055   if (InitialFrameReg) {
1056     // FrameReg is set explicitly, we're instrumenting a MachineFunction.
1057     return InitialFrameReg;
1058   }
1059
1060   return MRI->getLLVMRegNum(Frame.CurrentCfaRegister, true /* IsEH */);
1061 }
1062
1063 X86AsmInstrumentation *
1064 CreateX86AsmInstrumentation(const MCTargetOptions &MCOptions,
1065                             const MCContext &Ctx, const MCSubtargetInfo *&STI) {
1066   Triple T(STI->getTargetTriple());
1067   const bool hasCompilerRTSupport = T.isOSLinux();
1068   if (ClAsanInstrumentAssembly && hasCompilerRTSupport &&
1069       MCOptions.SanitizeAddress) {
1070     if (STI->getFeatureBits()[X86::Mode32Bit] != 0)
1071       return new X86AddressSanitizer32(STI);
1072     if (STI->getFeatureBits()[X86::Mode64Bit] != 0)
1073       return new X86AddressSanitizer64(STI);
1074   }
1075   return new X86AsmInstrumentation(STI);
1076 }
1077
1078 } // end llvm namespace