[SubZero] Handle relocatable constants for MIPS

src/IceInstMIPS32.h

Index: src/IceInstMIPS32.h
diff --git a/src/IceInstMIPS32.h b/src/IceInstMIPS32.h
index e3f1e82459eb7dc6d86ad848b0c224768aeba3c7..72ca3b65425de3579ef676ab2ac63c496e550b90 100644
--- a/src/IceInstMIPS32.h
+++ b/src/IceInstMIPS32.h
@@ -983,14 +983,21 @@ class InstMIPS32Imm16 : public InstMIPS32 {
 
 public:
   static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, Operand *Source,
-                                 uint32_t Imm) {
+                                 uint32_t Imm, RelocOp Reloc = RO_No) {
     return new (Func->allocate<InstMIPS32Imm16>())
-        InstMIPS32Imm16(Func, Dest, Source, Imm);
+        InstMIPS32Imm16(Func, Dest, Source, Imm, Reloc);
   }
 
-  static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, uint32_t Imm) {
+  static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, uint32_t Imm,
+                                 RelocOp Reloc = RO_No) {
     return new (Func->allocate<InstMIPS32Imm16>())
-        InstMIPS32Imm16(Func, Dest, Imm);
+        InstMIPS32Imm16(Func, Dest, Imm, Reloc);
+  }
+
+  static InstMIPS32Imm16 *create(Cfg *Func, Variable *Dest, Operand *Src0,
+                                 Operand *Src1, RelocOp Reloc) {
+    return new (Func->allocate<InstMIPS32Imm16>())
+        InstMIPS32Imm16(Func, Dest, Src0, Src1, Reloc);
   }
 
   void emit(const Cfg *Func) const override {
@@ -1004,10 +1011,18 @@ public:
       getSrc(0)->emit(Func);
     }
     Str << ", ";
-    if (Signed)
-      Str << (int32_t)Imm;
-    else
-      Str << Imm;
+    if (Reloc != RO_No) {

[Jim Stichnoth, 2016/10/16 14:44:43]

All other things equal, I think this style of code:

  if (C) A; else B;

is easier to read than:

  if (!C) B; else A;

So I would either use "if (Reloc == RO_No)" and swap the if/else blocks, or
something like "if (isReloc(Reloc))" - though I wish I could think of a better
name than isReloc - and provide an inline bool definition of isReloc() near the
top of the file.

Same comment below.

[jaydeep.patil, 2016/10/17 04:05:02]

Done.

+      auto *CR = llvm::dyn_cast<ConstantRelocatable>(getSrc(1));
+      emitRelocOp(Str, Reloc);
+      Str << "(";
+      CR->emitWithoutPrefix(Func->getTarget());
+      Str << ")";
+    } else {
+      if (Signed)
+        Str << (int32_t)Imm;
+      else
+        Str << Imm;
+    }
   }
 
   void emitIAS(const Cfg *Func) const override {
@@ -1022,27 +1037,45 @@ public:
     Str << " ";
     dumpDest(Func);
     Str << ", ";
-    dumpSources(Func);
-    Str << ", ";
-    if (Signed)
-      Str << (int32_t)Imm;
-    else
-      Str << Imm;
+    if (Reloc != RO_No) {
+      getSrc(0)->dump(Func);
+      Str << ",";
+      emitRelocOp(Str, Reloc);
+      Str << "(";
+      getSrc(1)->dump(Func);
+      Str << ")";
+    } else {
+      dumpSources(Func);
+      Str << ", ";
+      if (Signed)
+        Str << (int32_t)Imm;
+      else
+        Str << Imm;
+    }
   }
 
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
-  InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Source, uint32_t Imm)
-      : InstMIPS32(Func, K, 1, Dest), Imm(Imm) {
+  InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Source, uint32_t Imm,
+                  RelocOp Reloc = RO_No)
+      : InstMIPS32(Func, K, 1, Dest), Reloc(Reloc), Imm(Imm) {
     addSource(Source);
   }
 
-  InstMIPS32Imm16(Cfg *Func, Variable *Dest, uint32_t Imm)
-      : InstMIPS32(Func, K, 0, Dest), Imm(Imm) {}
+  InstMIPS32Imm16(Cfg *Func, Variable *Dest, uint32_t Imm,
+                  RelocOp Reloc = RO_No)
+      : InstMIPS32(Func, K, 0, Dest), Reloc(Reloc), Imm(Imm) {}
 
-  static const char *Opcode;
+  InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Src0, Operand *Src1,
+                  RelocOp Reloc)
+      : InstMIPS32(Func, K, 1, Dest), Reloc(Reloc), Imm(0) {
+    addSource(Src0);
+    addSource(Src1);
+  }
 
+  static const char *Opcode;
+  const RelocOp Reloc = RO_No;

[Jim Stichnoth, 2016/10/16 14:44:43]

I think there should not be an initializer here, since all ctors explicitly
initialize Reloc based on a ctor arg.

(And then if a new ctor is ever added, and it forgets to provide an
initialization of Reloc, the compiler should warn.)

[jaydeep.patil, 2016/10/17 04:05:02]

Done.

   const uint32_t Imm;
 };