[Xtensa] Implement lowering constant FP and blockaddress.

andreisfr · andreisfr · commit 6f375b3c1bfc · 2024-01-18T09:41:36.000+03:00
diff --git a/llvm/lib/Target/Xtensa/XtensaAsmPrinter.cpp b/llvm/lib/Target/Xtensa/XtensaAsmPrinter.cpp
@@ -14,6 +14,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "XtensaAsmPrinter.h"
+#include "XtensaConstantPoolValue.h"
 #include "TargetInfo/XtensaTargetInfo.h"
 #include "XtensaMCInstLower.h"
 #include "llvm/ADT/StringExtras.h"
@@ -30,13 +31,103 @@
 
 using namespace llvm;
 
+static MCSymbolRefExpr::VariantKind
+getModifierVariantKind(XtensaCP::XtensaCPModifier Modifier) {
+  switch (Modifier) {
+  case XtensaCP::no_modifier:
+    return MCSymbolRefExpr::VK_None;
+  case XtensaCP::TPOFF:
+    return MCSymbolRefExpr::VK_TPOFF;
+  }
+  report_fatal_error("Invalid XtensaCPModifier!");
+}
+
 void XtensaAsmPrinter::emitInstruction(const MachineInstr *MI) {
   XtensaMCInstLower Lower(MF->getContext(), *this);
   MCInst LoweredMI;
   Lower.lower(MI, LoweredMI);
   EmitToStreamer(*OutStreamer, LoweredMI);
 }
 
+void XtensaAsmPrinter::emitMachineConstantPoolValue(
+    MachineConstantPoolValue *MCPV) {
+  XtensaConstantPoolValue *ACPV = static_cast<XtensaConstantPoolValue *>(MCPV);
+
+  MCSymbol *MCSym;
+  if (ACPV->isBlockAddress()) {
+    const BlockAddress *BA =
+        cast<XtensaConstantPoolConstant>(ACPV)->getBlockAddress();
+    MCSym = GetBlockAddressSymbol(BA);
+  } else {
+    report_fatal_error(
+        "This constant type is not supported yet in constantpool");
+  }
+
+  MCSymbol *LblSym = GetCPISymbol(ACPV->getLabelId());
+  // TODO find a better way to check whether we emit data to .s file
+  if (OutStreamer->hasRawTextSupport()) {
+    std::string SymName("\t.literal ");
+    SymName += LblSym->getName();
+    SymName += ", ";
+    SymName += MCSym->getName();
+
+    StringRef Modifier = ACPV->getModifierText();
+    SymName += Modifier;
+
+    OutStreamer->emitRawText(StringRef(SymName));
+  } else {
+    MCSymbolRefExpr::VariantKind VK =
+        getModifierVariantKind(ACPV->getModifier());
+
+    if (ACPV->getModifier() != XtensaCP::no_modifier) {
+      std::string SymName(MCSym->getName());
+      MCSym = GetExternalSymbolSymbol(StringRef(SymName));
+    }
+
+    const MCExpr *Expr = MCSymbolRefExpr::create(MCSym, VK, OutContext);
+    uint64_t Size = getDataLayout().getTypeAllocSize(ACPV->getType());
+    OutStreamer->emitCodeAlignment(
+        Align(4), OutStreamer->getContext().getSubtargetInfo());
+    OutStreamer->emitLabel(LblSym);
+    OutStreamer->emitValue(Expr, Size);
+  }
+}
+
+void XtensaAsmPrinter::emitMachineConstantPoolEntry(
+    const MachineConstantPoolEntry &CPE, int i) {
+  if (CPE.isMachineConstantPoolEntry()) {
+    XtensaConstantPoolValue *ACPV =
+        static_cast<XtensaConstantPoolValue *>(CPE.Val.MachineCPVal);
+    ACPV->setLabelId(i);
+    emitMachineConstantPoolValue(CPE.Val.MachineCPVal);
+  } else {
+    MCSymbol *LblSym = GetCPISymbol(i);
+    // TODO find a better way to check whether we emit data to .s file
+    if (OutStreamer->hasRawTextSupport()) {
+      std::string str("\t.literal ");
+      str += LblSym->getName();
+      str += ", ";
+      const Constant *C = CPE.Val.ConstVal;
+
+      if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
+        str += toString(CFP->getValueAPF().bitcastToAPInt(), 10, true);
+      } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
+        str += toString(CI->getValue(), 10, true);
+      } else {
+        report_fatal_error(
+            "This constant type is not supported yet in constantpool");
+      }
+
+      OutStreamer->emitRawText(StringRef(str));
+    } else {
+      OutStreamer->emitCodeAlignment(
+          Align(4), OutStreamer->getContext().getSubtargetInfo());
+      OutStreamer->emitLabel(LblSym);
+      emitGlobalConstant(getDataLayout(), CPE.Val.ConstVal);
+    }
+  }
+}
+
 /// EmitConstantPool - Print to the current output stream assembly
 /// representations of the constants in the constant pool MCP. This is
 /// used to print out constants which have been "spilled to memory" by
@@ -82,32 +173,7 @@ void XtensaAsmPrinter::emitConstantPool() {
       }
     }
 
-    if (CPE.isMachineConstantPoolEntry()) {
-      report_fatal_error("This constantpool type is not supported yet");
-    } else {
-      MCSymbol *LblSym = GetCPISymbol(i);
-      // TODO find a better way to check whether we emit data to .s file
-      if (OutStreamer->hasRawTextSupport()) {
-        std::string str("\t.literal ");
-        str += LblSym->getName();
-        str += ", ";
-        const Constant *C = CPE.Val.ConstVal;
-
-        if (const auto *CFP = dyn_cast<ConstantFP>(C)) {
-          str += toString(CFP->getValueAPF().bitcastToAPInt(), 10, true);
-        } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
-          str += toString(CI->getValue(), 10, true);
-        } else {
-          report_fatal_error(
-              "This constant type is not supported yet in constantpool");
-        }
-
-        OutStreamer->emitRawText(StringRef(str));
-      } else {
-        OutStreamer->emitLabel(LblSym);
-        emitGlobalConstant(getDataLayout(), CPE.Val.ConstVal);
-      }
-    }
+    emitMachineConstantPoolEntry(CPE, i);
   }
 }
 
diff --git a/llvm/lib/Target/Xtensa/XtensaAsmPrinter.h b/llvm/lib/Target/Xtensa/XtensaAsmPrinter.h
@@ -17,6 +17,7 @@
 
 #include "XtensaTargetMachine.h"
 #include "llvm/CodeGen/AsmPrinter.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
@@ -37,6 +38,8 @@ class LLVM_LIBRARY_VISIBILITY XtensaAsmPrinter : public AsmPrinter {
   StringRef getPassName() const override { return "Xtensa Assembly Printer"; }
   void emitInstruction(const MachineInstr *MI) override;
   void emitConstantPool() override;
+  void emitMachineConstantPoolEntry(const MachineConstantPoolEntry &CPE, int i);
+  void emitMachineConstantPoolValue(MachineConstantPoolValue *MCPV) override;
 };
 } // end namespace llvm
 
diff --git a/llvm/lib/Target/Xtensa/XtensaISelLowering.cpp b/llvm/lib/Target/Xtensa/XtensaISelLowering.cpp
@@ -13,6 +13,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "XtensaConstantPoolValue.h"
 #include "XtensaISelLowering.h"
 #include "XtensaSubtarget.h"
 #include "XtensaTargetMachine.h"
@@ -49,6 +50,8 @@ XtensaTargetLowering::XtensaTargetLowering(const TargetMachine &tm,
 
   setOperationAction(ISD::Constant, MVT::i32, Custom);
   setOperationAction(ISD::Constant, MVT::i64, Expand);
+  setOperationAction(ISD::ConstantFP, MVT::f32, Custom);
+  setOperationAction(ISD::ConstantFP, MVT::f64, Expand);
 
   // No sign extend instructions for i1
   for (MVT VT : MVT::integer_valuetypes()) {
@@ -58,11 +61,17 @@ XtensaTargetLowering::XtensaTargetLowering(const TargetMachine &tm,
   }
 
   setOperationAction(ISD::ConstantPool, PtrVT, Custom);
+  setOperationAction(ISD::BlockAddress, PtrVT, Custom);
 
   // Compute derived properties from the register classes
   computeRegisterProperties(STI.getRegisterInfo());
 }
 
+bool XtensaTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
+                                        bool ForCodeSize) const {
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // Calling conventions
 //===----------------------------------------------------------------------===//
@@ -343,6 +352,31 @@ SDValue XtensaTargetLowering::LowerImmediate(SDValue Op,
   return Op;
 }
 
+SDValue XtensaTargetLowering::LowerImmediateFP(SDValue Op, SelectionDAG & DAG)
+    const {
+  if (Op.getValueType() != MVT::f32)
+    return Op;
+  const ConstantFPSDNode *CN = cast<ConstantFPSDNode>(Op);
+  SDLoc DL(CN);
+  APFloat apval = CN->getValueAPF();
+  int64_t value = llvm::bit_cast<uint32_t>(apval.convertToFloat());
+  Type *Ty = Type::getInt32Ty(*DAG.getContext());
+  Constant *CV = ConstantInt::get(Ty, value);
+  SDValue CP = DAG.getConstantPool(CV, MVT::i32);
+  return DAG.getNode(ISD::BITCAST, DL, MVT::f32, CP);
+}
+
+SDValue XtensaTargetLowering::LowerBlockAddress(BlockAddressSDNode *Node,
+                                                SelectionDAG &DAG) const {
+  const BlockAddress *BA = Node->getBlockAddress();
+  EVT PtrVT = getPointerTy(DAG.getDataLayout());
+  XtensaConstantPoolValue *CPV =
+      XtensaConstantPoolConstant::Create(BA, 0, XtensaCP::CPBlockAddress);
+  SDValue CPAddr = DAG.getTargetConstantPool(CPV, PtrVT, Align(4));
+  SDValue CPWrap = getAddrPCRel(CPAddr, DAG);
+  return CPWrap;
+}
+
 SDValue XtensaTargetLowering::getAddrPCRel(SDValue Op,
                                            SelectionDAG &DAG) const {
   SDLoc DL(Op);
@@ -354,11 +388,13 @@ SDValue XtensaTargetLowering::LowerConstantPool(ConstantPoolSDNode *CP,
                                                 SelectionDAG &DAG) const {
   EVT PtrVT = getPointerTy(DAG.getDataLayout());
   SDValue Result;
-  if (!CP->isMachineConstantPoolEntry()) {
+
+  if (CP->isMachineConstantPoolEntry()) {
+    Result =
+        DAG.getTargetConstantPool(CP->getMachineCPVal(), PtrVT, CP->getAlign());
+  } else {
     Result = DAG.getTargetConstantPool(CP->getConstVal(), PtrVT, CP->getAlign(),
                                        CP->getOffset());
-  } else {
-    report_fatal_error("This constantpool type is not supported yet");
   }
 
   return getAddrPCRel(Result, DAG);
@@ -369,6 +405,10 @@ SDValue XtensaTargetLowering::LowerOperation(SDValue Op,
   switch (Op.getOpcode()) {
   case ISD::Constant:
     return LowerImmediate(Op, DAG);
+  case ISD::ConstantFP:
+    return LowerImmediateFP(Op, DAG);
+  case ISD::BlockAddress:
+    return LowerBlockAddress(cast<BlockAddressSDNode>(Op), DAG);
   case ISD::ConstantPool:
     return LowerConstantPool(cast<ConstantPoolSDNode>(Op), DAG);
   default:
diff --git a/llvm/lib/Target/Xtensa/XtensaISelLowering.h b/llvm/lib/Target/Xtensa/XtensaISelLowering.h
@@ -38,6 +38,8 @@ class XtensaTargetLowering : public TargetLowering {
   explicit XtensaTargetLowering(const TargetMachine &TM,
                                 const XtensaSubtarget &STI);
 
+  bool isFPImmLegal(const APFloat &Imm, EVT VT,
+                    bool ForCodeSize) const override;
   const char *getTargetNodeName(unsigned Opcode) const override;
   SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const override;
   SDValue LowerFormalArguments(SDValue Chain, CallingConv::ID CallConv,
@@ -60,6 +62,8 @@ class XtensaTargetLowering : public TargetLowering {
   const XtensaSubtarget &Subtarget;
 
   SDValue LowerImmediate(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerImmediateFP(SDValue Op, SelectionDAG &DAG) const;
+  SDValue LowerBlockAddress(BlockAddressSDNode *Node, SelectionDAG &DAG) const;
   SDValue LowerConstantPool(ConstantPoolSDNode *CP, SelectionDAG &DAG) const;
 
   SDValue getAddrPCRel(SDValue Op, SelectionDAG &DAG) const;
diff --git a/llvm/lib/Target/Xtensa/XtensaMCInstLower.cpp b/llvm/lib/Target/Xtensa/XtensaMCInstLower.cpp
@@ -42,6 +42,13 @@ XtensaMCInstLower::LowerSymbolOperand(const MachineOperand &MO,
   XtensaMCExpr::VariantKind Kind = XtensaMCExpr::VK_Xtensa_None;
 
   switch (MOTy) {
+  case MachineOperand::MO_MachineBasicBlock:
+    Symbol = MO.getMBB()->getSymbol();
+    break;
+  case MachineOperand::MO_BlockAddress:
+    Symbol = Printer.GetBlockAddressSymbol(MO.getBlockAddress());
+    Offset += MO.getOffset();
+    break;
   case MachineOperand::MO_ConstantPoolIndex:
     Symbol = GetConstantPoolIndexSymbol(MO);
     Offset += MO.getOffset();
@@ -79,6 +86,8 @@ MCOperand XtensaMCInstLower::lowerOperand(const MachineOperand &MO,
     return MCOperand::createImm(MO.getImm() + Offset);
   case MachineOperand::MO_RegisterMask:
     break;
+  case MachineOperand::MO_MachineBasicBlock:
+  case MachineOperand::MO_BlockAddress:
   case MachineOperand::MO_ConstantPoolIndex:
     return LowerSymbolOperand(MO, MOTy, Offset);
   default:
diff --git a/llvm/test/CodeGen/Xtensa/constantpool.ll b/llvm/test/CodeGen/Xtensa/constantpool.ll
@@ -26,3 +26,55 @@ define dso_local i64 @const_int64() #0 {
   %2 = load i64, ptr %1, align 8
   ret i64 %2
 }
+
+define dso_local float @const_fp() #0 {
+; CHECK: .literal_position
+; CHECK-NEXT: .literal .LCPI2_0, 1092721050
+; CHECK-LABEL: const_fp:
+; CHECK: l32r a2, .LCPI2_0
+  %1 = alloca float, align 4
+  store float 0x4024333340000000, ptr %1, align 4
+  %2 = load float, ptr %1, align 4
+  ret float %2
+}
+
+define dso_local i64 @const_double() #0 {
+; CHECK: .literal_position
+; CHECK-NEXT: .literal .LCPI3_0, 1070945621
+; CHECK-NEXT: .literal .LCPI3_1, 1371607770
+; CHECK-LABEL: const_double:
+; CHECK: l32r a3, .LCPI3_0
+; CHECK: l32r a2, .LCPI3_1
+  %1 = alloca double, align 8
+  %2 = alloca double, align 8
+  store double 0x3FD5555551C112DA, ptr %2, align 8
+  %3 = load double, ptr %2, align 8
+  store double %3, ptr %1, align 8
+  %4 = load i64, ptr %1, align 8
+  ret i64 %4
+}
+
+; Test placement of the block address in constantpool
+
+define dso_local i32 @const_blockaddress(i32 noundef %0) #0 {
+; CHECK: .literal_position
+; CHECK-NEXT: .literal .LCPI4_0, .Ltmp0
+; CHECK-LABEL: const_blockaddress:
+; CHECK:       l32r a8, .LCPI4_0
+; CHECK:       jx a8
+; CHECK-NEXT:  .Ltmp0:
+  %2 = alloca i32, align 4
+  %3 = alloca ptr, align 4
+  store i32 %0, ptr %2, align 4
+  store ptr blockaddress(@const_blockaddress, %5), ptr %3, align 4
+  %4 = load ptr, ptr %3, align 4
+  br label %7
+
+5:                                                ; preds = %7
+  %6 = load i32, ptr %2, align 4
+  ret i32 %6
+
+7:                                                ; preds = %1
+  %8 = phi ptr [ %4, %1 ]
+  indirectbr ptr %8, [label %5]
+}
