[AVR] Emit 'eicall' for devices with large program memory

[benshi001]

Summary

Fixes https://github.com/llvm/llvm-project/issues/58856

[benshi001]

llvm/test/CodeGen/AVR/issue-58856-eicall.ll

22

This form is incompatible with avr-gcc, avr-gcc emits lo8(gs(sym)) and hi8(gs(sym)). However this is another issue, at least clang+llvm generates correct relocable and executable ELFs.

[aykevl]

Looks good to me.

The inline assembly is perhaps a bit confusing. What I would do is split this function into two functions: one returns @func as a function pointer, and the other with a single function pointer parameter that is called. Feel free to do that or leave as is.

llvm/lib/Target/AVR/AVRISelDAGToDAG.cpp

template <> bool AVRDAGToDAGISel::select<AVRISD::CALL>(SDNode *N) {
   // Map all operands into the new node.
   for (unsigned i = 2, e = LastOpNum + 1; i != e; ++i) {
     Ops.push_back(N->getOperand(i));
   }
 
   Ops.push_back(Chain);
   Ops.push_back(Chain.getValue(1));
 
-  SDNode *ResNode =
-      CurDAG->getMachineNode(AVR::ICALL, DL, MVT::Other, MVT::Glue, Ops);
+  SDNode *ResNode = CurDAG->getMachineNode(
+      Subtarget->hasEIJMPCALL() ? AVR::EICALL : AVR::ICALL, DL, MVT::Other,
+      MVT::Glue, Ops);
 
   ReplaceUses(SDValue(N, 0), SDValue(ResNode, 0));
   ReplaceUses(SDValue(N, 1), SDValue(ResNode, 1));
   CurDAG->RemoveDeadNode(N);
 
   return true;
 }
 

llvm/lib/Target/AVR/AVRMCInstLower.h

 //===-- AVRMCInstLower.h - Lower MachineInstr to MCInst ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_AVR_MCINST_LOWER_H
 #define LLVM_AVR_MCINST_LOWER_H
 
+#include "AVRSubtarget.h"
 #include "llvm/Support/Compiler.h"
 
 namespace llvm {
 
 class AsmPrinter;
 class MachineInstr;
 class MachineOperand;
 class MCContext;
 class MCInst;
 class MCOperand;
 class MCSymbol;
 
 /// Lowers `MachineInstr` objects into `MCInst` objects.
 class AVRMCInstLower {
 public:
   AVRMCInstLower(MCContext &Ctx, AsmPrinter &Printer)
       : Ctx(Ctx), Printer(Printer) {}
 
   /// Lowers a `MachineInstr` into a `MCInst`.
   void lowerInstruction(const MachineInstr &MI, MCInst &OutMI) const;
-  MCOperand lowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym) const;
+  MCOperand lowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym,
+                               const AVRSubtarget &Subtarget) const;
 
 private:
   MCContext &Ctx;
   AsmPrinter &Printer;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_AVR_MCINST_LOWER_H

llvm/lib/Target/AVR/AVRMCInstLower.cpp

 //===-- AVRMCInstLower.cpp - Convert AVR MachineInstr to an MCInst --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains code to lower AVR MachineInstrs to their corresponding
 // MCInst records.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AVRMCInstLower.h"
-
 #include "AVRInstrInfo.h"
 #include "MCTargetDesc/AVRMCExpr.h"
 
 #include "llvm/CodeGen/AsmPrinter.h"
 #include "llvm/IR/Mangler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 
-MCOperand AVRMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
-                                             MCSymbol *Sym) const {
+MCOperand
+AVRMCInstLower::lowerSymbolOperand(const MachineOperand &MO, MCSymbol *Sym,
+                                   const AVRSubtarget &Subtarget) const {
   unsigned char TF = MO.getTargetFlags();
   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Ctx);
 
   bool IsNegated = false;
   if (TF & AVRII::MO_NEG) {
     IsNegated = true;
   }
 
   if (!MO.isJTI() && MO.getOffset()) {
     Expr = MCBinaryExpr::createAdd(
         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
   }
 
   bool IsFunction = MO.isGlobal() && isa<Function>(MO.getGlobal());
 
   if (TF & AVRII::MO_LO) {
     if (IsFunction) {
-      // N.B. Should we use _GS fixups here to cope with >128k progmem?
-      Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_PM_LO8, Expr, IsNegated, Ctx);
+      Expr =
+          AVRMCExpr::create(Subtarget.hasEIJMPCALL() ? AVRMCExpr::VK_AVR_LO8_GS
+                                                     : AVRMCExpr::VK_AVR_PM_LO8,
+                            Expr, IsNegated, Ctx);
     } else {
       Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_LO8, Expr, IsNegated, Ctx);
     }
   } else if (TF & AVRII::MO_HI) {
     if (IsFunction) {
-      // N.B. Should we use _GS fixups here to cope with >128k progmem?
-      Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_PM_HI8, Expr, IsNegated, Ctx);
+      Expr =
+          AVRMCExpr::create(Subtarget.hasEIJMPCALL() ? AVRMCExpr::VK_AVR_HI8_GS
+                                                     : AVRMCExpr::VK_AVR_PM_HI8,
+                            Expr, IsNegated, Ctx);
     } else {
       Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_HI8, Expr, IsNegated, Ctx);
     }
   } else if (TF != 0) {
     llvm_unreachable("Unknown target flag on symbol operand");
   }
 
   return MCOperand::createExpr(Expr);
 }
 
 void AVRMCInstLower::lowerInstruction(const MachineInstr &MI,
                                       MCInst &OutMI) const {
+  auto &Subtarget = MI.getParent()->getParent()->getSubtarget<AVRSubtarget>();
   OutMI.setOpcode(MI.getOpcode());
 
   for (MachineOperand const &MO : MI.operands()) {
     MCOperand MCOp;
 
     switch (MO.getType()) {
     default:
       MI.print(errs());
       llvm_unreachable("unknown operand type");
     case MachineOperand::MO_Register:
       // Ignore all implicit register operands.
       if (MO.isImplicit())
         continue;
       MCOp = MCOperand::createReg(MO.getReg());
       break;
     case MachineOperand::MO_Immediate:
       MCOp = MCOperand::createImm(MO.getImm());
       break;
     case MachineOperand::MO_GlobalAddress:
-      MCOp = lowerSymbolOperand(MO, Printer.getSymbol(MO.getGlobal()));
+      MCOp =
+          lowerSymbolOperand(MO, Printer.getSymbol(MO.getGlobal()), Subtarget);
       break;
     case MachineOperand::MO_ExternalSymbol:
       MCOp = lowerSymbolOperand(
-          MO, Printer.GetExternalSymbolSymbol(MO.getSymbolName()));
+          MO, Printer.GetExternalSymbolSymbol(MO.getSymbolName()), Subtarget);
       break;
     case MachineOperand::MO_MachineBasicBlock:
       MCOp = MCOperand::createExpr(
           MCSymbolRefExpr::create(MO.getMBB()->getSymbol(), Ctx));
       break;
     case MachineOperand::MO_RegisterMask:
       continue;
     case MachineOperand::MO_BlockAddress:
       MCOp = lowerSymbolOperand(
-          MO, Printer.GetBlockAddressSymbol(MO.getBlockAddress()));
+          MO, Printer.GetBlockAddressSymbol(MO.getBlockAddress()), Subtarget);
       break;
     case MachineOperand::MO_JumpTableIndex:
-      MCOp = lowerSymbolOperand(MO, Printer.GetJTISymbol(MO.getIndex()));
+      MCOp = lowerSymbolOperand(MO, Printer.GetJTISymbol(MO.getIndex()),
+                                Subtarget);
       break;
     case MachineOperand::MO_ConstantPoolIndex:
-      MCOp = lowerSymbolOperand(MO, Printer.GetCPISymbol(MO.getIndex()));
+      MCOp = lowerSymbolOperand(MO, Printer.GetCPISymbol(MO.getIndex()),
+                                Subtarget);
       break;
     }
 
     OutMI.addOperand(MCOp);
   }
 }
 
 } // end of namespace llvm

llvm/test/CodeGen/AVR/issue-58856-eicall.ll

+; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
+; RUN: llc < %s -mtriple=avr -mattr=-eijmpcall | FileCheck %s --check-prefix=ICALL
+; RUN: llc < %s -mtriple=avr -mattr=+eijmpcall | FileCheck %s --check-prefix=EICALL
+
+; This test verifies the bug https://github.com/llvm/llvm-project/issues/58856
+
+declare dso_local i16 @func()
+
+define i16 @foo() {
+; ICALL-LABEL: foo:
+; ICALL:       ; %bb.0:
+; ICALL-NEXT:    ldi r30, pm_lo8(func)
+; ICALL-NEXT:    ldi r31, pm_hi8(func)
+; ICALL-NEXT:    ;APP
+; ICALL-NEXT:    ;NO_APP
+; ICALL-NEXT:    icall
+; ICALL-NEXT:    ret
+;
+; EICALL-LABEL: foo:
+; EICALL:       ; %bb.0:
+; EICALL-NEXT:    ldi r30, lo8_gs(func)
+; EICALL-NEXT:    ldi r31, hi8_gs(func)
+; EICALL-NEXT:    ;APP
+; EICALL-NEXT:    ;NO_APP
+; EICALL-NEXT:    eicall
+; EICALL-NEXT:    ret
+  %1 = tail call addrspace(0) ptr addrspace(1) asm "", "=r,0"(ptr addrspace(1) @func)
+  %2 = tail call i16 %1()
+  ret i16 %2
+}