Add a MCObjectFormat class so that code common to all targets that use a

single object format can be shared.

This also adds support for

mov zed+(bar-foo), %eax

on ELF and COFF targets.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@116675 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 58 insertions, 15 deletions

diff --git a/include/llvm/MC/MCExpr.h b/include/llvm/MC/MCExpr.h
index 06f9cd3..f85650f 100644
--- a/include/llvm/MC/MCExpr.h
+++ b/include/llvm/MC/MCExpr.h
@@ -43,6 +43,8 @@ private:
 protected:
   explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {}
 
+  bool EvaluateAsRelocatableImpl(MCValue &Res, const MCAsmLayout *Layout,
+                                 bool InSet) const;
 public:
   /// @name Accessors
   /// @{
diff --git a/include/llvm/MC/MCObjectFormat.h b/include/llvm/MC/MCObjectFormat.h
new file mode 100644
index 0000000..80b7295
--- /dev/null
+++ b/include/llvm/MC/MCObjectFormat.h
@@ -0,0 +1,52 @@
+//===-- llvm/MC/MCObjectFormat.h - Object Format Info -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_MC_MCOBJECTFORMAT_H
+#define LLVM_MC_MCOBJECTFORMAT_H
+
+namespace llvm {
+class MCSymbol;
+
+class MCObjectFormat {
+public:
+  /// isAbsolute - Check if A - B is an absolute value
+  ///
+  /// \param InSet - True if this expression is in a set. For example:
+  ///   a:
+  ///   ...
+  ///   b:
+  ///   tmp = a - b
+  ///       .long tmp
+  /// \param A - LHS
+  /// \param B - RHS
+  virtual bool isAbsolute(bool InSet, const MCSymbol &A,
+                          const MCSymbol &B) const = 0;
+};
+
+class MCELFObjectFormat : public MCObjectFormat {
+public:
+  virtual bool isAbsolute(bool InSet, const MCSymbol &A,
+                          const MCSymbol &B) const;
+};
+
+class MCMachOObjectFormat : public MCObjectFormat {
+public:
+  virtual bool isAbsolute(bool InSet, const MCSymbol &A,
+                          const MCSymbol &B) const;
+};
+
+class MCCOFFObjectFormat : public MCObjectFormat {
+public:
+  virtual bool isAbsolute(bool InSet, const MCSymbol &A,
+                          const MCSymbol &B) const;
+};
+
+}  // End llvm namespace
+
+#endif
diff --git a/include/llvm/Target/TargetAsmBackend.h b/include/llvm/Target/TargetAsmBackend.h
index b0a7af6..b424dea 100644
--- a/include/llvm/Target/TargetAsmBackend.h
+++ b/include/llvm/Target/TargetAsmBackend.h
@@ -16,6 +16,7 @@ namespace llvm {
 class MCDataFragment;
 class MCFixup;
 class MCInst;
+class MCObjectFormat;
 class MCObjectWriter;
 class MCSection;
 template<typename T>
@@ -33,7 +34,6 @@ protected: // Can only create subclasses.
   /// TheTarget - The Target that this machine was created for.
   const Target &TheTarget;
 
-  unsigned HasAbsolutizedSet : 1;
   unsigned HasReliableSymbolDifference : 1;
   unsigned HasScatteredSymbols : 1;
 
@@ -42,23 +42,12 @@ public:
 
   const Target &getTarget() const { return TheTarget; }
 
+  virtual const MCObjectFormat &getObjectFormat() const = 0;
+
   /// createObjectWriter - Create a new MCObjectWriter instance for use by the
   /// assembler backend to emit the final object file.
   virtual MCObjectWriter *createObjectWriter(raw_ostream &OS) const = 0;
 
-  /// hasAbsolutizedSet - Check whether this target "absolutizes"
-  /// assignments. That is, given code like:
-  ///   a:
-  ///   ...
-  ///   b:
-  ///   tmp = a - b
-  ///       .long tmp
-  /// will the value of 'tmp' be a relocatable expression, or the assembly time
-  /// value of L0 - L1. This distinction is only relevant for platforms that
-  /// support scattered symbols, since in the absence of scattered symbols (a -
-  /// b) cannot change after assembly.
-  bool hasAbsolutizedSet() const { return HasAbsolutizedSet; }
-
   /// hasReliableSymbolDifference - Check whether this target implements
   /// accurate relocations for differences between symbols. If not, differences
   /// between symbols will always be relocatable expressions and any references
@@ -68,7 +57,7 @@ public:
   /// This should always be true (since it results in fewer relocations with no
   /// loss of functionality), but is currently supported as a way to maintain
   /// exact object compatibility with Darwin 'as' (on non-x86_64). It should
-  /// eventually should be eliminated. See also \see hasAbsolutizedSet.
+  /// eventually should be eliminated.
   bool hasReliableSymbolDifference() const {
     return HasReliableSymbolDifference;
   }