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