mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 02:52:53 +02:00
e2b0519ed8
This patch adds support for AArch64 (ARM's 64-bit architecture) to
LLVM in the "experimental" category. Currently, it won't be built
unless requested explicitly.
This initial commit should have support for:
+ Assembly of all scalar (i.e. non-NEON, non-Crypto) instructions
(except the late addition CRC instructions).
+ CodeGen features required for C++03 and C99.
+ Compilation for the "small" memory model: code+static data <
4GB.
+ Absolute and position-independent code.
+ GNU-style (i.e. "__thread") TLS.
+ Debugging information.
The principal omission, currently, is performance tuning.
This patch excludes the NEON support also reviewed due to an outbreak of
batshit insanity in our legal department. That will be committed soon bringing
the changes to precisely what has been approved.
Further reviews would be gratefully received.
llvm-svn: 174054
141 lines
4.6 KiB
C++
141 lines
4.6 KiB
C++
//===-- AArch64MCInstLower.cpp - Convert AArch64 MachineInstr to an MCInst -==//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file contains code to lower AArch64 MachineInstrs to their corresponding
|
|
// MCInst records.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "AArch64AsmPrinter.h"
|
|
#include "AArch64TargetMachine.h"
|
|
#include "MCTargetDesc/AArch64BaseInfo.h"
|
|
#include "MCTargetDesc/AArch64MCExpr.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/CodeGen/AsmPrinter.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/MC/MCAsmInfo.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCExpr.h"
|
|
#include "llvm/MC/MCInst.h"
|
|
#include "llvm/Target/Mangler.h"
|
|
|
|
using namespace llvm;
|
|
|
|
MCOperand
|
|
AArch64AsmPrinter::lowerSymbolOperand(const MachineOperand &MO,
|
|
const MCSymbol *Sym) const {
|
|
const MCExpr *Expr = 0;
|
|
|
|
Expr = MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_None, OutContext);
|
|
|
|
switch (MO.getTargetFlags()) {
|
|
case AArch64II::MO_GOT:
|
|
Expr = AArch64MCExpr::CreateGOT(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_GOT_LO12:
|
|
Expr = AArch64MCExpr::CreateGOTLo12(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_LO12:
|
|
Expr = AArch64MCExpr::CreateLo12(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_DTPREL_G1:
|
|
Expr = AArch64MCExpr::CreateDTPREL_G1(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_DTPREL_G0_NC:
|
|
Expr = AArch64MCExpr::CreateDTPREL_G0_NC(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_GOTTPREL:
|
|
Expr = AArch64MCExpr::CreateGOTTPREL(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_GOTTPREL_LO12:
|
|
Expr = AArch64MCExpr::CreateGOTTPRELLo12(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_TLSDESC:
|
|
Expr = AArch64MCExpr::CreateTLSDesc(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_TLSDESC_LO12:
|
|
Expr = AArch64MCExpr::CreateTLSDescLo12(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_TPREL_G1:
|
|
Expr = AArch64MCExpr::CreateTPREL_G1(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_TPREL_G0_NC:
|
|
Expr = AArch64MCExpr::CreateTPREL_G0_NC(Expr, OutContext);
|
|
break;
|
|
case AArch64II::MO_NO_FLAG:
|
|
// Expr is already correct
|
|
break;
|
|
default:
|
|
llvm_unreachable("Unexpected MachineOperand flag");
|
|
}
|
|
|
|
if (!MO.isJTI() && MO.getOffset())
|
|
Expr = MCBinaryExpr::CreateAdd(Expr,
|
|
MCConstantExpr::Create(MO.getOffset(),
|
|
OutContext),
|
|
OutContext);
|
|
|
|
return MCOperand::CreateExpr(Expr);
|
|
}
|
|
|
|
bool AArch64AsmPrinter::lowerOperand(const MachineOperand &MO,
|
|
MCOperand &MCOp) const {
|
|
switch (MO.getType()) {
|
|
default: llvm_unreachable("unknown operand type");
|
|
case MachineOperand::MO_Register:
|
|
if (MO.isImplicit())
|
|
return false;
|
|
assert(!MO.getSubReg() && "Subregs should be eliminated!");
|
|
MCOp = MCOperand::CreateReg(MO.getReg());
|
|
break;
|
|
case MachineOperand::MO_Immediate:
|
|
MCOp = MCOperand::CreateImm(MO.getImm());
|
|
break;
|
|
case MachineOperand::MO_BlockAddress:
|
|
MCOp = lowerSymbolOperand(MO, GetBlockAddressSymbol(MO.getBlockAddress()));
|
|
break;
|
|
case MachineOperand::MO_ExternalSymbol:
|
|
MCOp = lowerSymbolOperand(MO, GetExternalSymbolSymbol(MO.getSymbolName()));
|
|
break;
|
|
case MachineOperand::MO_GlobalAddress:
|
|
MCOp = lowerSymbolOperand(MO, Mang->getSymbol(MO.getGlobal()));
|
|
break;
|
|
case MachineOperand::MO_MachineBasicBlock:
|
|
MCOp = MCOperand::CreateExpr(MCSymbolRefExpr::Create(
|
|
MO.getMBB()->getSymbol(), OutContext));
|
|
break;
|
|
case MachineOperand::MO_JumpTableIndex:
|
|
MCOp = lowerSymbolOperand(MO, GetJTISymbol(MO.getIndex()));
|
|
break;
|
|
case MachineOperand::MO_ConstantPoolIndex:
|
|
MCOp = lowerSymbolOperand(MO, GetCPISymbol(MO.getIndex()));
|
|
break;
|
|
case MachineOperand::MO_RegisterMask:
|
|
// Ignore call clobbers
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void llvm::LowerAArch64MachineInstrToMCInst(const MachineInstr *MI,
|
|
MCInst &OutMI,
|
|
AArch64AsmPrinter &AP) {
|
|
OutMI.setOpcode(MI->getOpcode());
|
|
|
|
for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
|
|
const MachineOperand &MO = MI->getOperand(i);
|
|
|
|
MCOperand MCOp;
|
|
if (AP.lowerOperand(MO, MCOp))
|
|
OutMI.addOperand(MCOp);
|
|
}
|
|
}
|