RISCV: clean up target expression handling

The target specific expression handling was slightly regressed by
bbea64250f65480d787e1c5ff45c4de3ec2dcda8.  This restores the proper
sub-expression evaluation to allow for constant folding within the
expression.  We explicitly discard the layout and assembler when
evaluating the expression to avoid any symbolic computation and instead
using the `evaluateAsRelocatable` to canonicalise and constant fold
only.

We can also simplify the expression handling - none of the target
variants support symbolic difference.  This simplifies the logic for
that and adds additional tests to ensure that we do not accidentally
regress here in the future.

Reviewed By: maskray

Differential Revision: https://reviews.llvm.org/D104473

lib/Target/RISCV/MCTargetDesc/RISCVMCExpr.cpp

@@ -92,33 +92,16 @@ const MCFixup *RISCVMCExpr::getPCRelHiFixup(const MCFragment **DFOut) const {
 bool RISCVMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
                                             const MCAsmLayout *Layout,
                                             const MCFixup *Fixup) const {
-  bool IsSymbolicDifference = false;
+  // Explicitly drop the layout and assembler to prevent any symbolic folding in
-  if (const auto *MBE = dyn_cast<MCBinaryExpr>(getSubExpr())) {
+  // the expression handling.  This is required to preserve symbolic difference
-    if (isa<MCBinaryExpr>(MBE->getLHS()) && isa<MCConstantExpr>(MBE->getRHS()))
+  // expressions to emit the paired relocations.
-      MBE = cast<MCBinaryExpr>(MBE->getLHS());
+  if (!getSubExpr()->evaluateAsRelocatable(Res, nullptr, nullptr))
-    IsSymbolicDifference = isa<MCSymbolRefExpr>(MBE->getLHS()) &&
+    return false;
-                           isa<MCSymbolRefExpr>(MBE->getRHS());
-  }
 
-  // Some custom fixup types are not valid with symbol difference expressions
+  Res =
-  if (IsSymbolicDifference) {
+      MCValue::get(Res.getSymA(), Res.getSymB(), Res.getConstant(), getKind());
-    switch (getKind()) {
+  // Custom fixup types are not valid with symbol difference expressions.
-    default:
+  return Res.getSymB() ? getKind() == VK_RISCV_None : true;
-      break;
-    case VK_RISCV_LO:
-    case VK_RISCV_HI:
-    case VK_RISCV_PCREL_LO:
-    case VK_RISCV_PCREL_HI:
-    case VK_RISCV_GOT_HI:
-    case VK_RISCV_TPREL_LO:
-    case VK_RISCV_TPREL_HI:
-    case VK_RISCV_TPREL_ADD:
-    case VK_RISCV_TLS_GOT_HI:
-    case VK_RISCV_TLS_GD_HI:
-      return false;
-    }
-  }
-  return getSubExpr()->evaluateAsRelocatable(Res, Layout, Fixup);
 }
 
 void RISCVMCExpr::visitUsedExpr(MCStreamer &Streamer) const {

test/MC/RISCV/expressions.s

@@ -0,0 +1,29 @@
+# RUN: not llvm-mc -triple riscv32 -filetype obj %s -o /dev/null 2>&1 | FileCheck %s
+
+.Ltmp1:
+	.quad	tls
+
+	lui a0, %hi(tls+0-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	lw a0, %lo(tls+0-.Ltmp1)(t0)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	lui a0, %tprel_hi(tls+0-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	add a0, a0, tp, %tprel_add(tls+0-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	addi a0, a0, %tprel_lo(tls+0-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	auipc a0, %tls_ie_pcrel_hi(tls+0-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	auipc a0, %tls_gd_pcrel_hi(tls+0-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	auipc a0, %pcrel_hi(tls-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	auipc a0, %got_pcrel_hi(tls-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+	addi a0, a0, %pcrel_lo(tls-.Ltmp1)
+# CHECK: :[[#@LINE-1]]:2: error: expected relocatable expression
+
+#	tail tls+32
+#	tail tls-tls
+# _ :[[#@LINE-1]]:2: error: expected relocatable expression