Subzero. Buildable, non-functional TargetLoweringX8664.

src/IceInstX8664.cpp

Index: src/IceInstX8664.cpp
diff --git a/src/IceInstX8632.cpp b/src/IceInstX8664.cpp
similarity index 61%
copy from src/IceInstX8632.cpp
copy to src/IceInstX8664.cpp
index c6d6abf46b2a439395e3078e74a247c880687533..370918024aadfae5b37e54e7d057baf0d19a6103 100644
--- a/src/IceInstX8632.cpp
+++ b/src/IceInstX8664.cpp
@@ -1,4 +1,4 @@
-//===- subzero/src/IceInstX8632.cpp - X86-32 instruction implementation ---===//
+//===- subzero/src/IceInstX8664.cpp - X86-64 instruction implementation ---===//
 //
 //                        The Subzero Code Generator
 //
@@ -8,78 +8,68 @@
 //===----------------------------------------------------------------------===//
 ///
 /// \file
-/// This file defines X8632 specific data related to X8632 Instructions and
-/// Instruction traits. These are declared in the IceTargetLoweringX8632Traits.h
+/// This file defines X8664 specific data related to X8664 Instructions and
+/// Instruction traits. These are declared in the IceTargetLoweringX8664Traits.h
 /// header file.
 ///
-/// This file also defines X8632 operand specific methods (dump and emit.)
+/// This file also defines X8664 operand specific methods (dump and emit.)
 ///
 //===----------------------------------------------------------------------===//
-#include "IceInstX8632.h"
+#include "IceInstX8664.h"
 
-#include "IceAssemblerX8632.h"
+#include "IceAssemblerX8664.h"
 #include "IceCfg.h"
 #include "IceCfgNode.h"
-#include "IceConditionCodesX8632.h"
+#include "IceConditionCodesX8664.h"
 #include "IceInst.h"
-#include "IceRegistersX8632.h"
-#include "IceTargetLoweringX8632.h"
+#include "IceRegistersX8664.h"
+#include "IceTargetLoweringX8664.h"
 #include "IceOperand.h"
 
 namespace Ice {
 
 namespace X86Internal {
 
-const MachineTraits<TargetX8632>::InstBrAttributesType
-    MachineTraits<TargetX8632>::InstBrAttributes[] = {
+const MachineTraits<TargetX8664>::InstBrAttributesType
+    MachineTraits<TargetX8664>::InstBrAttributes[] = {
 #define X(tag, encode, opp, dump, emit)                                        \
-  { X8632::Traits::Cond::opp, dump, emit }                                     \
+  { X8664::Traits::Cond::opp, dump, emit }                                     \
   ,
-        ICEINSTX8632BR_TABLE
+        ICEINSTX8664BR_TABLE
 #undef X
 };
 
-const MachineTraits<TargetX8632>::InstCmppsAttributesType
-    MachineTraits<TargetX8632>::InstCmppsAttributes[] = {
+const MachineTraits<TargetX8664>::InstCmppsAttributesType
+    MachineTraits<TargetX8664>::InstCmppsAttributes[] = {
 #define X(tag, emit)                                                           \
   { emit }                                                                     \
   ,
-        ICEINSTX8632CMPPS_TABLE
+        ICEINSTX8664CMPPS_TABLE
 #undef X
 };
 
-const MachineTraits<TargetX8632>::TypeAttributesType
-    MachineTraits<TargetX8632>::TypeAttributes[] = {
+const MachineTraits<TargetX8664>::TypeAttributesType
+    MachineTraits<TargetX8664>::TypeAttributes[] = {
 #define X(tag, elementty, cvt, sdss, pack, width, fld)                         \
   { cvt, sdss, pack, width, fld }                                              \
   ,
-        ICETYPEX8632_TABLE
+        ICETYPEX8664_TABLE
 #undef X
 };
 
-const char *MachineTraits<TargetX8632>::InstSegmentRegNames[] = {
-#define X(val, name, prefix) name,
-    SEG_REGX8632_TABLE
-#undef X
-};
-
-uint8_t MachineTraits<TargetX8632>::InstSegmentPrefixes[] = {
-#define X(val, name, prefix) prefix,
-    SEG_REGX8632_TABLE
-#undef X
-};
-
-void MachineTraits<TargetX8632>::X86Operand::dump(const Cfg *,
+void MachineTraits<TargetX8664>::X86Operand::dump(const Cfg *,
                                                   Ostream &Str) const {
   if (BuildDefs::dump())
-    Str << "<OperandX8632>";
+    Str << "<OperandX8664>";
 }
 
-MachineTraits<TargetX8632>::X86OperandMem::X86OperandMem(
-    Cfg *Func, Type Ty, Variable *Base, Constant *Offset, Variable *Index,
-    uint16_t Shift, SegmentRegisters SegmentReg)
+MachineTraits<TargetX8664>::X86OperandMem::X86OperandMem(Cfg *Func, Type Ty,
+                                                         Variable *Base,
+                                                         Constant *Offset,
+                                                         Variable *Index,
+                                                         uint16_t Shift)
     : X86Operand(kMem, Ty), Base(Base), Offset(Offset), Index(Index),
-      Shift(Shift), SegmentReg(SegmentReg), Randomized(false) {
+      Shift(Shift) {
   assert(Shift <= 3);
   Vars = nullptr;
   NumVars = 0;
@@ -98,14 +88,10 @@ MachineTraits<TargetX8632>::X86OperandMem::X86OperandMem(
   }
 }
 
-void MachineTraits<TargetX8632>::X86OperandMem::emit(const Cfg *Func) const {
+void MachineTraits<TargetX8664>::X86OperandMem::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
-  if (SegmentReg != DefaultSegment) {
-    assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
-    Str << "%" << X8632::Traits::InstSegmentRegNames[SegmentReg] << ":";
-  }
   // Emit as Offset(Base,Index,1<<Shift).
   // Offset is emitted without the leading '$'.
   // Omit the (Base,Index,1<<Shift) part if Base==nullptr.
@@ -134,14 +120,10 @@ void MachineTraits<TargetX8632>::X86OperandMem::emit(const Cfg *Func) const {
   }
 }
 
-void MachineTraits<TargetX8632>::X86OperandMem::dump(const Cfg *Func,
+void MachineTraits<TargetX8664>::X86OperandMem::dump(const Cfg *Func,
                                                      Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
-  if (SegmentReg != DefaultSegment) {
-    assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
-    Str << X8632::Traits::InstSegmentRegNames[SegmentReg] << ":";
-  }
   bool Dumped = false;
   Str << "[";
   if (Base) {
@@ -186,17 +168,9 @@ void MachineTraits<TargetX8632>::X86OperandMem::dump(const Cfg *Func,
   Str << "]";
 }
 
-void MachineTraits<TargetX8632>::X86OperandMem::emitSegmentOverride(
-    MachineTraits<TargetX8632>::Assembler *Asm) const {
-  if (SegmentReg != DefaultSegment) {
-    assert(SegmentReg >= 0 && SegmentReg < SegReg_NUM);
-    Asm->emitSegmentOverride(X8632::Traits::InstSegmentPrefixes[SegmentReg]);
-  }
-}
-
-MachineTraits<TargetX8632>::Address
-MachineTraits<TargetX8632>::X86OperandMem::toAsmAddress(
-    MachineTraits<TargetX8632>::Assembler *Asm) const {
+MachineTraits<TargetX8664>::Address
+MachineTraits<TargetX8664>::X86OperandMem::toAsmAddress(
+    MachineTraits<TargetX8664>::Assembler *Asm) const {
   int32_t Disp = 0;
   AssemblerFixup *Fixup = nullptr;
   // Determine the offset (is it relocatable?)
@@ -214,40 +188,40 @@ MachineTraits<TargetX8632>::X86OperandMem::toAsmAddress(
 
   // Now convert to the various possible forms.
   if (getBase() && getIndex()) {
-    return X8632::Traits::Address(
-        RegX8632::getEncodedGPR(getBase()->getRegNum()),
-        RegX8632::getEncodedGPR(getIndex()->getRegNum()),
-        X8632::Traits::ScaleFactor(getShift()), Disp);
+    return X8664::Traits::Address(
+        RegX8664::getEncodedGPR(getBase()->getRegNum()),
+        RegX8664::getEncodedGPR(getIndex()->getRegNum()),
+        X8664::Traits::ScaleFactor(getShift()), Disp);
   } else if (getBase()) {
-    return X8632::Traits::Address(
-        RegX8632::getEncodedGPR(getBase()->getRegNum()), Disp);
+    return X8664::Traits::Address(
+        RegX8664::getEncodedGPR(getBase()->getRegNum()), Disp);
   } else if (getIndex()) {
-    return X8632::Traits::Address(
-        RegX8632::getEncodedGPR(getIndex()->getRegNum()),
-        X8632::Traits::ScaleFactor(getShift()), Disp);
+    return X8664::Traits::Address(
+        RegX8664::getEncodedGPR(getIndex()->getRegNum()),
+        X8664::Traits::ScaleFactor(getShift()), Disp);
   } else if (Fixup) {
-    return X8632::Traits::Address::Absolute(Disp, Fixup);
+    return X8664::Traits::Address::Absolute(Disp, Fixup);
   } else {
-    return X8632::Traits::Address::Absolute(Disp);
+    return X8664::Traits::Address::Absolute(Disp);
   }
 }
 
-MachineTraits<TargetX8632>::Address
-MachineTraits<TargetX8632>::VariableSplit::toAsmAddress(const Cfg *Func) const {
+MachineTraits<TargetX8664>::Address
+MachineTraits<TargetX8664>::VariableSplit::toAsmAddress(const Cfg *Func) const {
   assert(!Var->hasReg());
   const ::Ice::TargetLowering *Target = Func->getTarget();
   int32_t Offset =
       Var->getStackOffset() + Target->getStackAdjustment() + getOffset();
-  return X8632::Traits::Address(
-      RegX8632::getEncodedGPR(Target->getFrameOrStackReg()), Offset);
+  return X8664::Traits::Address(
+      RegX8664::getEncodedGPR(Target->getFrameOrStackReg()), Offset);
 }
 
-void MachineTraits<TargetX8632>::VariableSplit::emit(const Cfg *Func) const {
+void MachineTraits<TargetX8664>::VariableSplit::emit(const Cfg *Func) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Func->getContext()->getStrEmit();
   assert(!Var->hasReg());
-  // The following is copied/adapted from TargetX8632::emitVariable().
+  // The following is copied/adapted from TargetX8664::emitVariable().
   const ::Ice::TargetLowering *Target = Func->getTarget();
   const Type Ty = IceType_i32;
   int32_t Offset =
@@ -257,7 +231,7 @@ void MachineTraits<TargetX8632>::VariableSplit::emit(const Cfg *Func) const {
   Str << "(%" << Target->getRegName(Target->getFrameOrStackReg(), Ty) << ")";
 }
 
-void MachineTraits<TargetX8632>::VariableSplit::dump(const Cfg *Func,
+void MachineTraits<TargetX8664>::VariableSplit::dump(const Cfg *Func,
                                                      Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
@@ -280,4 +254,4 @@ void MachineTraits<TargetX8632>::VariableSplit::dump(const Cfg *Func,
 } // namespace X86Internal
 } // end of namespace Ice
 
-X86INSTS_DEFINE_STATIC_DATA(TargetX8632);
+X86INSTS_DEFINE_STATIC_DATA(TargetX8664);