Subzero: Switch to AT&T asm syntax. I give up.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 89 matching lines @@
 
 CondX86::BrCond getIcmp32Mapping(InstIcmp::ICond Cond) {
   size_t Index = static_cast<size_t>(Cond);
   assert(Index < TableIcmp32Size);
   return TableIcmp32[Index].Mapping;
 }
 
 const struct TableTypeX8632Attributes_ {
   Type InVectorElementType;
 } TableTypeX8632Attributes[] = {
-#define X(tag, elementty, cvt, sdss, pack, width)                              \
+#define X(tag, elementty, cvt, sdss, pack, width, fld)                         \
   { elementty }                                                                \
   ,
     ICETYPEX8632_TABLE
 #undef X
   };
 const size_t TableTypeX8632AttributesSize =
     llvm::array_lengthof(TableTypeX8632Attributes);
 
 // Return the type which the elements of the vector have in the X86
 // representation of the vector.
@@ skipping 117 matching lines @@
       "Inconsistency between ICMPX8632_TABLE and ICEINSTICMP_TABLE");
 ICEINSTICMP_TABLE;
 #undef X
 } // end of namespace dummy2
 
 // Validate the enum values in ICETYPEX8632_TABLE.
 namespace dummy3 {
 // Define a temporary set of enum values based on low-level table
 // entries.
 enum _tmp_enum {
-#define X(tag, elementty, cvt, sdss, pack, width) _tmp_##tag,
+#define X(tag, elementty, cvt, sdss, pack, width, fld) _tmp_##tag,
   ICETYPEX8632_TABLE
 #undef X
       _num
 };
 // Define a set of constants based on high-level table entries.
 #define X(tag, size, align, elts, elty, str)                                   \
   static const int _table1_##tag = tag;
 ICETYPE_TABLE;
 #undef X
 // Define a set of constants based on low-level table entries, and
 // ensure the table entry keys are consistent.
-#define X(tag, elementty, cvt, sdss, pack, width)                              \
+#define X(tag, elementty, cvt, sdss, pack, width, fld)                         \
   static const int _table2_##tag = _tmp_##tag;                                 \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
 ICETYPEX8632_TABLE;
 #undef X
 // Repeat the static asserts with respect to the high-level table
 // entries in case the high-level table has extra entries.
 #define X(tag, size, align, elts, elty, str)                                   \
   static_assert(_table1_##tag == _table2_##tag,                                \
                 "Inconsistency between ICETYPEX8632_TABLE and ICETYPE_TABLE");
@@ skipping 231 matching lines @@
   case IceType_i16:
     return RegNames16[RegNum];
   default:
     return RegNames[RegNum];
   }
 }
 
 void TargetX8632::emitVariable(const Variable *Var) const {
   Ostream &Str = Ctx->getStrEmit();
   if (Var->hasReg()) {
-    Str << getRegName(Var->getRegNum(), Var->getType());
+    Str << "%" << getRegName(Var->getRegNum(), Var->getType());
     return;
   }
-  Str << InstX8632::getWidthString(Var->getType());
-  Str << " [" << getRegName(getFrameOrStackReg(), IceType_i32);
+  const Type Ty = IceType_i32;
   int32_t Offset = Var->getStackOffset();
   if (!hasFramePointer())
     Offset += getStackAdjustment();
-  if (Offset) {
-    if (Offset > 0)
-      Str << "+";
+  if (Offset)
     Str << Offset;
-  }
-  Str << "]";
+  Str << "(%" << getRegName(getFrameOrStackReg(), Ty) << ")";
 }
 
 x86::Address TargetX8632::stackVarToAsmOperand(const Variable *Var) const {
   assert(!Var->hasReg());
   int32_t Offset = Var->getStackOffset();
   if (!hasFramePointer())
     Offset += getStackAdjustment();
   return x86::Address(RegX8632::getEncodedGPR(getFrameOrStackReg()), Offset);
 }
 
@@ skipping 4055 matching lines @@
           }
         }
       }
     }
     AvailableRegisters |= FreedRegisters;
   }
 }
 
 template <> void ConstantInteger32::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
-  Str << (int32_t)getValue();
+  Str << "$" << (int32_t)getValue();
 }
 
 template <> void ConstantInteger64::emit(GlobalContext *) const {
   llvm_unreachable("Not expecting to emit 64-bit integers");
 }
 
 template <> void ConstantFloat::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
   // It would be better to prefix with ".L$" instead of "L$", but
   // llvm-mc doesn't parse "dword ptr [.L$foo]".

[jvoung (off chromium), 2014/10/31 22:12:18]

adjust comment about "dword ptr" ?

[Jim Stichnoth, 2014/11/01 13:44:17]

Even better, adjusted the code to use .L$ prefix.

-  Str << "dword ptr [L$" << IceType_f32 << "$" << getPoolEntryID() << "]";
+  Str << "L$" << IceType_f32 << "$" << getPoolEntryID();
 }
 
 template <> void ConstantDouble::emit(GlobalContext *Ctx) const {
   Ostream &Str = Ctx->getStrEmit();
-  Str << "qword ptr [L$" << IceType_f64 << "$" << getPoolEntryID() << "]";
+  Str << "L$" << IceType_f64 << "$" << getPoolEntryID();
 }
 
 void ConstantUndef::emit(GlobalContext *) const {
   llvm_unreachable("undef value encountered by emitter.");
 }
 
 TargetGlobalInitX8632::TargetGlobalInitX8632(GlobalContext *Ctx)
     : TargetGlobalInitLowering(Ctx) {}
 
 void TargetGlobalInitX8632::lower(const VariableDeclaration &Var) {
@@ skipping 83 matching lines @@
   } else if (IsConstant || IsExternal)
     Str << "\t.zero\t" << Size << "\n";
   // Size is part of .comm.
 
   if (IsConstant || HasNonzeroInitializer || IsExternal)
     Str << "\t.size\t" << MangledName << ", " << Size << "\n";
   // Size is part of .comm.
 }
 
 } // end of namespace Ice