Auto-sandboxing: Switch to automatic scratch register invalidation

lib/MC/MCNaClExpander.cpp

 //===- MCNaClExpander.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the MCNaClExpander class. This is a base
 // class that encapsulates the expansion logic for MCInsts, and holds
 // state such as available scratch registers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCNaClExpander.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 
 namespace llvm {
 
 void MCNaClExpander::Error(const MCInst &Inst, const char msg[]) {
   Ctx.FatalError(Inst.getLoc(), msg);
 }
 
-void MCNaClExpander::pushScratchReg(unsigned Reg) {
+bool MCNaClExpander::addScratchReg(unsigned Reg) {
+  if (!isValidScratchRegister(Reg))
+    return true;
   ScratchRegs.push_back(Reg);
+  return false;
 }
 
-unsigned MCNaClExpander::popScratchReg() {
-  assert(!ScratchRegs.empty() &&
-         "Trying to pop an empty scratch register stack");
+void MCNaClExpander::invalidateScratchRegs(const MCInst &Inst) {
+  // TODO(dschuff): There are arch-specific special cases where this fails,
+  // e.g. xchg/cmpxchg
+  const MCInstrDesc &Desc = InstInfo->get(Inst.getOpcode());
+  for (auto I = ScratchRegs.begin(), E = ScratchRegs.end(); I != E; ++I) {
+    if (Desc.hasDefOfPhysReg(Inst, *I, *RegInfo))
+      I = ScratchRegs.erase(I);
+  }
+}
 
-  unsigned Reg = ScratchRegs.back();
-  ScratchRegs.pop_back();
-  return Reg;
+void MCNaClExpander::clearScratchRegs() {
+  ScratchRegs.clear();
 }
 
 unsigned MCNaClExpander::getScratchReg(int index) {
-  int len = numScratchRegs();
-  return ScratchRegs[len - index - 1];
+  assert(index >= 0 && static_cast<unsigned>(index) < numScratchRegs());
+  return ScratchRegs[numScratchRegs()  - index - 1];
 }
 
 unsigned MCNaClExpander::numScratchRegs() const { return ScratchRegs.size(); }
 
 bool MCNaClExpander::isPseudo(const MCInst &Inst) const {
   return InstInfo->get(Inst.getOpcode()).isPseudo();
 }
 
 bool MCNaClExpander::mayAffectControlFlow(const MCInst &Inst) const {
   return InstInfo->get(Inst.getOpcode()).mayAffectControlFlow(Inst, *RegInfo);
@@ skipping 42 matching lines @@
 void MCNaClExpander::replaceDefinitions(MCInst &Inst, unsigned RegOld,
                                         unsigned RegNew) const {
   const MCInstrDesc &Desc = InstInfo->get(Inst.getOpcode());
   for (int i = 0; i < Desc.NumDefs; ++i) {
     MCOperand &Op = Inst.getOperand(i);
     if (Op.isReg() && Op.getReg() == RegOld)
       Op.setReg(RegNew);
   }
 }
 }