Subzero. Enables moar complex relocation offsets.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares the Operand class and its target-independent subclasses.
 ///
 /// The main classes are Variable, which represents an LLVM variable that is
 /// either register- or stack-allocated, and the Constant hierarchy, which
 /// represents integer, floating-point, and/or symbolic constants.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEOPERAND_H
 #define SUBZERO_SRC_ICEOPERAND_H
 
 #include "IceCfg.h"
 #include "IceDefs.h"
 #include "IceGlobalContext.h"
 #include "IceTypes.h"
 
 #include "llvm/Support/Format.h"
 
+#include <limits>

[Jim Stichnoth, 2016/02/02 20:57:49]

I don't think this is actually necessary, is it?

[John, 2016/02/03 15:50:41]

well, numeric_limits appear in this file. leaving it.

+
 namespace Ice {
 
 class Operand {
   Operand() = delete;
   Operand(const Operand &) = delete;
   Operand &operator=(const Operand &) = delete;
 
 public:
   static constexpr size_t MaxTargetKinds = 10;
   enum OperandKind {
@@ skipping 201 matching lines @@
 bool ConstantInteger32::shouldBeRandomizedOrPooled(const GlobalContext *Ctx);
 
 template <>
 inline void ConstantInteger64::dump(const Cfg *, Ostream &Str) const {
   if (!BuildDefs::dump())
     return;
   assert(getType() == IceType_i64);
   Str << static_cast<int64_t>(getValue());
 }
 
+/// RelocOffset allows symbolic references in ConstantRelocatables' offsets,
+/// e.g., 8 + LabelOffset, where label offset is the location (code or data)
+/// of a Label that is only determinable during ELF emission.
+class RelocOffset final {
+  RelocOffset(const RelocOffset &) = delete;
+  RelocOffset &operator=(const RelocOffset &) = delete;
+
+public:
+  static RelocOffset *create(GlobalContext *Ctx) {
+    return new (Ctx->allocate<RelocOffset>()) RelocOffset();
+  }
+
+  static RelocOffset *create(GlobalContext *Ctx, RelocOffsetT Value) {
+    return new (Ctx->allocate<RelocOffset>()) RelocOffset(Value);
+  }
+
+  bool hasOffset() const { return HasOffset; }
+
+  RelocOffsetT getOffset() const {
+    assert(HasOffset);
+    return Offset;
+  }
+
+  void setOffset(const RelocOffsetT Value) {
+    assert(!HasOffset);
+    Offset = Value;
+    HasOffset = true;
+  }
+
+private:
+  RelocOffset() = default;
+  explicit RelocOffset(RelocOffsetT Offset) { setOffset(Offset); }
+
+  bool HasOffset = false;
+  RelocOffsetT Offset;
+};
+
 /// RelocatableTuple bundles the parameters that are used to construct an
 /// ConstantRelocatable. It is done this way so that ConstantRelocatable can fit
 /// into the global constant pool template mechanism.
 class RelocatableTuple {
   RelocatableTuple() = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
-  RelocatableTuple(const RelocOffsetT Offset, const IceString &Name,
+  RelocatableTuple(const RelocOffsetArray &OffsetExpr, const IceString &Name,
                    bool SuppressMangling)
-      : Offset(Offset), Name(Name), SuppressMangling(SuppressMangling) {}
+      : OffsetExpr(OffsetExpr), Name(Name), SuppressMangling(SuppressMangling) {
+  }
+
+  RelocatableTuple(const RelocOffsetArray &OffsetExpr, const IceString &Name,
+                   const IceString &EmitString, bool SuppressMangling)
+      : OffsetExpr(OffsetExpr), Name(Name), EmitString(EmitString),
+        SuppressMangling(SuppressMangling) {}
+
   RelocatableTuple(const RelocatableTuple &) = default;
 
-  const RelocOffsetT Offset;
+  const RelocOffsetArray OffsetExpr;
   const IceString Name;
-  bool SuppressMangling;
+  const IceString EmitString;
+  const bool SuppressMangling;
 };
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 /// ConstantRelocatable represents a symbolic constant combined with a fixed
 /// offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable() = delete;
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple) {
-    return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
-        Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling);
+    return new (Ctx->allocate<ConstantRelocatable>())
+        ConstantRelocatable(Ty, Tuple.OffsetExpr, Tuple.Name, Tuple.EmitString,
+                            Tuple.SuppressMangling);
   }
 
-  RelocOffsetT getOffset() const { return Offset; }
+  RelocOffsetT getOffset() const {
+    RelocOffsetT Offset = 0;
+    for (const auto *const OffsetReloc : OffsetExpr) {
+      Offset += OffsetReloc->getOffset();
+    }
+    return Offset;
+  }
+
+  const IceString &getEmitString() const { return EmitString; }
+
   const IceString &getName() const { return Name; }
-  void setSuppressMangling(bool Value) { SuppressMangling = Value; }
   bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   void emitWithoutPrefix(const TargetLowering *Target,
                          const char *Suffix = "") const;
   using Constant::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
-  ConstantRelocatable(Type Ty, RelocOffsetT Offset, const IceString &Name,
+  ConstantRelocatable(Type Ty, const RelocOffsetArray &OffsetExpr,
+                      const IceString &Name, const IceString &EmitString,
                       bool SuppressMangling)
-      : Constant(kConstRelocatable, Ty), Offset(Offset), Name(Name),
-        SuppressMangling(SuppressMangling) {}
-  const RelocOffsetT Offset; /// fixed offset to add
-  const IceString Name;      /// optional for debug/dump
-  bool SuppressMangling;
+      : Constant(kConstRelocatable, Ty), OffsetExpr(OffsetExpr), Name(Name),
+        EmitString(EmitString), SuppressMangling(SuppressMangling) {}
+
+  const RelocOffsetArray OffsetExpr; /// fixed offset to add
+  const IceString Name;              /// optional for debug/dump
+  const IceString EmitString;        /// optional for textual output

[Jim Stichnoth, 2016/02/02 20:57:49]

I would change "output" to "asm" or "emission"

[John, 2016/02/03 15:50:41]

Done.

+  const bool SuppressMangling;
 };
 
 /// ConstantUndef represents an unspecified bit pattern. Although it is legal to
 /// lower ConstantUndef to any value, backends should try to make code
 /// generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef() = delete;
   ConstantUndef(const ConstantUndef &) = delete;
   ConstantUndef &operator=(const ConstantUndef &) = delete;
 
@@ skipping 428 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H