Line data    Source code

       1             : //===-- AVRMCInstLower.cpp - Convert AVR MachineInstr to an MCInst --------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file contains code to lower AVR MachineInstrs to their corresponding
      11             : // MCInst records.
      12             : //
      13             : //===----------------------------------------------------------------------===//
      14             : 
      15             : #include "AVRMCInstLower.h"
      16             : 
      17             : #include "AVRInstrInfo.h"
      18             : #include "MCTargetDesc/AVRMCExpr.h"
      19             : 
      20             : #include "llvm/CodeGen/AsmPrinter.h"
      21             : #include "llvm/IR/Mangler.h"
      22             : #include "llvm/MC/MCInst.h"
      23             : #include "llvm/Support/ErrorHandling.h"
      24             : 
      25             : namespace llvm {
      26             : 
      27         268 : MCOperand AVRMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
      28             :                                              MCSymbol *Sym) const {
      29         268 :   unsigned char TF = MO.getTargetFlags();
      30         268 :   const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Ctx);
      31             : 
      32             :   bool IsNegated = false;
      33         268 :   if (TF & AVRII::MO_NEG) { IsNegated = true; }
      34             : 
      35         268 :   if (!MO.isJTI() && MO.getOffset()) {
      36         104 :     Expr = MCBinaryExpr::createAdd(
      37         104 :         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
      38             :   }
      39             : 
      40         268 :   bool IsFunction = MO.isGlobal() && isa<Function>(MO.getGlobal());
      41             : 
      42         268 :   if (TF & AVRII::MO_LO) {
      43           5 :     if (IsFunction) {
      44             :       // N.B. Should we use _GS fixups here to cope with >128k progmem?
      45           1 :       Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_PM_LO8, Expr, IsNegated, Ctx);
      46             :     } else {
      47           4 :       Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_LO8, Expr, IsNegated, Ctx);
      48             :     }
      49         263 :   } else if (TF & AVRII::MO_HI) {
      50           5 :     if (IsFunction) {
      51             :       // N.B. Should we use _GS fixups here to cope with >128k progmem?
      52           1 :       Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_PM_HI8, Expr, IsNegated, Ctx);
      53             :     } else {
      54           4 :       Expr = AVRMCExpr::create(AVRMCExpr::VK_AVR_HI8, Expr, IsNegated, Ctx);
      55             :     }
      56         258 :   } else if (TF != 0) {
      57           0 :     llvm_unreachable("Unknown target flag on symbol operand");
      58             :   }
      59             : 
      60         268 :   return MCOperand::createExpr(Expr);
      61             : }
      62             : 
      63        5239 : void AVRMCInstLower::lowerInstruction(const MachineInstr &MI, MCInst &OutMI) const {
      64        5239 :   OutMI.setOpcode(MI.getOpcode());
      65             : 
      66       20716 :   for (MachineOperand const &MO : MI.operands()) {
      67             :     MCOperand MCOp;
      68             : 
      69       15477 :     switch (MO.getType()) {
      70           0 :     default:
      71           0 :       MI.print(errs());
      72           0 :       llvm_unreachable("unknown operand type");
      73             :     case MachineOperand::MO_Register:
      74             :       // Ignore all implicit register operands.
      75       12885 :       if (MO.isImplicit())
      76        4988 :         continue;
      77        8032 :       MCOp = MCOperand::createReg(MO.getReg());
      78        8032 :       break;
      79        2008 :     case MachineOperand::MO_Immediate:
      80        2008 :       MCOp = MCOperand::createImm(MO.getImm());
      81        2008 :       break;
      82         186 :     case MachineOperand::MO_GlobalAddress:
      83         186 :       MCOp = lowerSymbolOperand(MO, Printer.getSymbol(MO.getGlobal()));
      84         186 :       break;
      85          82 :     case MachineOperand::MO_ExternalSymbol:
      86             :       MCOp = lowerSymbolOperand(
      87         164 :           MO, Printer.GetExternalSymbolSymbol(MO.getSymbolName()));
      88          82 :       break;
      89         181 :     case MachineOperand::MO_MachineBasicBlock:
      90             :       MCOp = MCOperand::createExpr(
      91         181 :           MCSymbolRefExpr::create(MO.getMBB()->getSymbol(), Ctx));
      92         181 :       break;
      93             :     case MachineOperand::MO_RegisterMask:
      94             :       continue;
      95           0 :     case MachineOperand::MO_BlockAddress:
      96             :       MCOp = lowerSymbolOperand(
      97           0 :           MO, Printer.GetBlockAddressSymbol(MO.getBlockAddress()));
      98           0 :       break;
      99           0 :     case MachineOperand::MO_JumpTableIndex:
     100           0 :       MCOp = lowerSymbolOperand(MO, Printer.GetJTISymbol(MO.getIndex()));
     101           0 :       break;
     102           0 :     case MachineOperand::MO_ConstantPoolIndex:
     103           0 :       MCOp = lowerSymbolOperand(MO, Printer.GetCPISymbol(MO.getIndex()));
     104           0 :       break;
     105             :     }
     106             : 
     107             :     OutMI.addOperand(MCOp);
     108             :   }
     109        5239 : }
     110             : 
     111             : } // end of namespace llvm
     112             :