2009-08-31 08:06:59 +00:00
|
|
|
//===- MCExpr.h - Assembly Level Expressions --------------------*- C++ -*-===//
|
2009-06-29 20:40:36 +00:00
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
#ifndef LLVM_MC_MCEXPR_H
|
|
|
|
#define LLVM_MC_MCEXPR_H
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2010-12-07 00:27:36 +00:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2009-06-29 20:40:36 +00:00
|
|
|
#include "llvm/Support/Casting.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/DataTypes.h"
|
2009-06-29 20:40:36 +00:00
|
|
|
|
|
|
|
namespace llvm {
|
2010-03-11 02:28:59 +00:00
|
|
|
class MCAsmLayout;
|
2010-12-03 00:55:40 +00:00
|
|
|
class MCAssembler;
|
2009-06-29 20:40:36 +00:00
|
|
|
class MCContext;
|
2011-04-29 18:00:03 +00:00
|
|
|
class MCSection;
|
2010-12-07 00:27:36 +00:00
|
|
|
class MCSectionData;
|
2009-06-29 20:40:36 +00:00
|
|
|
class MCSymbol;
|
2009-06-30 01:49:52 +00:00
|
|
|
class MCValue;
|
2009-08-31 08:07:33 +00:00
|
|
|
class raw_ostream;
|
2009-09-16 01:26:31 +00:00
|
|
|
class StringRef;
|
2010-12-07 00:27:36 +00:00
|
|
|
typedef DenseMap<const MCSectionData*, uint64_t> SectionAddrMap;
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
/// MCExpr - Base class for the full range of assembler expressions which are
|
2009-08-31 08:07:22 +00:00
|
|
|
/// needed for parsing.
|
2009-08-31 08:06:59 +00:00
|
|
|
class MCExpr {
|
2009-06-29 20:40:36 +00:00
|
|
|
public:
|
2009-08-31 08:06:59 +00:00
|
|
|
enum ExprKind {
|
2009-07-01 15:14:50 +00:00
|
|
|
Binary, ///< Binary expressions.
|
|
|
|
Constant, ///< Constant expressions.
|
|
|
|
SymbolRef, ///< References to labels and assigned expressions.
|
2010-02-08 19:41:07 +00:00
|
|
|
Unary, ///< Unary expressions.
|
|
|
|
Target ///< Target specific expression.
|
2009-06-29 20:40:36 +00:00
|
|
|
};
|
2009-08-31 08:07:22 +00:00
|
|
|
|
2009-06-29 20:40:36 +00:00
|
|
|
private:
|
2009-08-31 08:06:59 +00:00
|
|
|
ExprKind Kind;
|
2009-08-31 08:07:22 +00:00
|
|
|
|
2012-08-29 06:28:46 +00:00
|
|
|
MCExpr(const MCExpr&) LLVM_DELETED_FUNCTION;
|
|
|
|
void operator=(const MCExpr&) LLVM_DELETED_FUNCTION;
|
2009-08-31 08:07:22 +00:00
|
|
|
|
2010-12-18 03:57:21 +00:00
|
|
|
bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler *Asm,
|
|
|
|
const MCAsmLayout *Layout,
|
2010-12-07 00:27:36 +00:00
|
|
|
const SectionAddrMap *Addrs) const;
|
2009-06-29 20:40:36 +00:00
|
|
|
protected:
|
2010-02-09 00:29:29 +00:00
|
|
|
explicit MCExpr(ExprKind _Kind) : Kind(_Kind) {}
|
2009-08-31 08:07:22 +00:00
|
|
|
|
2010-12-18 03:57:21 +00:00
|
|
|
bool EvaluateAsRelocatableImpl(MCValue &Res, const MCAssembler *Asm,
|
|
|
|
const MCAsmLayout *Layout,
|
2010-12-07 00:27:36 +00:00
|
|
|
const SectionAddrMap *Addrs,
|
2010-10-16 18:23:53 +00:00
|
|
|
bool InSet) const;
|
2009-06-29 20:40:36 +00:00
|
|
|
public:
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @name Accessors
|
|
|
|
/// @{
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
ExprKind getKind() const { return Kind; }
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:33 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Utility Methods
|
|
|
|
/// @{
|
|
|
|
|
2010-01-18 00:37:40 +00:00
|
|
|
void print(raw_ostream &OS) const;
|
2009-08-31 08:07:33 +00:00
|
|
|
void dump() const;
|
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Expression Evaluation
|
|
|
|
/// @{
|
|
|
|
|
2009-06-29 20:40:36 +00:00
|
|
|
/// EvaluateAsAbsolute - Try to evaluate the expression to an absolute value.
|
|
|
|
///
|
2009-06-30 01:49:52 +00:00
|
|
|
/// @param Res - The absolute value, if evaluation succeeds.
|
2010-03-11 02:28:59 +00:00
|
|
|
/// @param Layout - The assembler layout object to use for evaluating symbol
|
|
|
|
/// values. If not given, then only non-symbolic expressions will be
|
|
|
|
/// evaluated.
|
2009-06-29 20:40:36 +00:00
|
|
|
/// @result - True on success.
|
2012-08-23 16:54:08 +00:00
|
|
|
bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout,
|
|
|
|
const SectionAddrMap &Addrs) const;
|
2010-12-18 03:57:21 +00:00
|
|
|
bool EvaluateAsAbsolute(int64_t &Res) const;
|
|
|
|
bool EvaluateAsAbsolute(int64_t &Res, const MCAssembler &Asm) const;
|
|
|
|
bool EvaluateAsAbsolute(int64_t &Res, const MCAsmLayout &Layout) const;
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-06-30 01:49:52 +00:00
|
|
|
/// EvaluateAsRelocatable - Try to evaluate the expression to a relocatable
|
2009-07-01 15:14:50 +00:00
|
|
|
/// value, i.e. an expression of the fixed form (a - b + constant).
|
2009-06-30 01:49:52 +00:00
|
|
|
///
|
|
|
|
/// @param Res - The relocatable value, if evaluation succeeds.
|
2010-03-11 02:28:59 +00:00
|
|
|
/// @param Layout - The assembler layout object to use for evaluating values.
|
2009-06-30 01:49:52 +00:00
|
|
|
/// @result - True on success.
|
2010-12-22 16:11:57 +00:00
|
|
|
bool EvaluateAsRelocatable(MCValue &Res, const MCAsmLayout &Layout) const;
|
2009-06-30 01:49:52 +00:00
|
|
|
|
2011-04-29 18:00:03 +00:00
|
|
|
/// FindAssociatedSection - Find the "associated section" for this expression,
|
|
|
|
/// which is currently defined as the absolute section for constants, or
|
|
|
|
/// otherwise the section associated with the first defined symbol in the
|
|
|
|
/// expression.
|
|
|
|
const MCSection *FindAssociatedSection() const;
|
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @}
|
2009-06-29 20:40:36 +00:00
|
|
|
};
|
2010-03-12 21:00:45 +00:00
|
|
|
|
2010-01-18 00:37:40 +00:00
|
|
|
inline raw_ostream &operator<<(raw_ostream &OS, const MCExpr &E) {
|
|
|
|
E.print(OS);
|
|
|
|
return OS;
|
|
|
|
}
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
//// MCConstantExpr - Represent a constant integer expression.
|
|
|
|
class MCConstantExpr : public MCExpr {
|
2009-06-29 20:40:36 +00:00
|
|
|
int64_t Value;
|
|
|
|
|
2010-02-09 00:29:29 +00:00
|
|
|
explicit MCConstantExpr(int64_t _Value)
|
2009-08-31 08:06:59 +00:00
|
|
|
: MCExpr(MCExpr::Constant), Value(_Value) {}
|
2009-08-31 08:07:22 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
/// @name Construction
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
static const MCConstantExpr *Create(int64_t Value, MCContext &Ctx);
|
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Accessors
|
|
|
|
/// @{
|
|
|
|
|
2009-06-29 20:40:36 +00:00
|
|
|
int64_t getValue() const { return Value; }
|
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @}
|
|
|
|
|
|
|
|
static bool classof(const MCExpr *E) {
|
|
|
|
return E->getKind() == MCExpr::Constant;
|
2009-06-29 20:40:36 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
/// MCSymbolRefExpr - Represent a reference to a symbol from inside an
|
2009-07-01 15:14:50 +00:00
|
|
|
/// expression.
|
|
|
|
///
|
|
|
|
/// A symbol reference in an expression may be a use of a label, a use of an
|
|
|
|
/// assembler variable (defined constant), or constitute an implicit definition
|
|
|
|
/// of the symbol as external.
|
2009-08-31 08:06:59 +00:00
|
|
|
class MCSymbolRefExpr : public MCExpr {
|
2010-03-15 23:51:06 +00:00
|
|
|
public:
|
|
|
|
enum VariantKind {
|
|
|
|
VK_None,
|
|
|
|
VK_Invalid,
|
|
|
|
|
|
|
|
VK_GOT,
|
|
|
|
VK_GOTOFF,
|
|
|
|
VK_GOTPCREL,
|
|
|
|
VK_GOTTPOFF,
|
|
|
|
VK_INDNTPOFF,
|
|
|
|
VK_NTPOFF,
|
2010-10-28 14:22:44 +00:00
|
|
|
VK_GOTNTPOFF,
|
2010-03-15 23:51:06 +00:00
|
|
|
VK_PLT,
|
|
|
|
VK_TLSGD,
|
2010-10-28 15:02:40 +00:00
|
|
|
VK_TLSLD,
|
2010-10-28 14:37:09 +00:00
|
|
|
VK_TLSLDM,
|
2010-05-12 05:16:34 +00:00
|
|
|
VK_TPOFF,
|
2010-10-28 14:48:59 +00:00
|
|
|
VK_DTPOFF,
|
2010-11-14 22:22:59 +00:00
|
|
|
VK_TLVP, // Mach-O thread local variable relocation
|
2012-02-11 17:26:53 +00:00
|
|
|
VK_SECREL,
|
2010-11-10 03:26:07 +00:00
|
|
|
// FIXME: We'd really like to use the generic Kinds listed above for these.
|
2012-12-12 07:14:46 +00:00
|
|
|
VK_ARM_NONE,
|
2010-11-10 03:26:07 +00:00
|
|
|
VK_ARM_PLT, // ARM-style PLT references. i.e., (PLT) instead of @PLT
|
|
|
|
VK_ARM_TLSGD, // ditto for TLSGD, GOT, GOTOFF, TPOFF and GOTTPOFF
|
|
|
|
VK_ARM_GOT,
|
|
|
|
VK_ARM_GOTOFF,
|
|
|
|
VK_ARM_TPOFF,
|
|
|
|
VK_ARM_GOTTPOFF,
|
2012-01-26 09:25:43 +00:00
|
|
|
VK_ARM_TARGET1,
|
2012-11-09 20:20:12 +00:00
|
|
|
VK_ARM_TARGET2,
|
2012-12-12 07:14:46 +00:00
|
|
|
VK_ARM_PREL31,
|
2011-02-03 23:17:44 +00:00
|
|
|
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_LO, // symbol@l
|
2013-06-21 14:42:49 +00:00
|
|
|
VK_PPC_HI, // symbol@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_HA, // symbol@ha
|
2013-06-21 14:43:42 +00:00
|
|
|
VK_PPC_HIGHER, // symbol@higher
|
|
|
|
VK_PPC_HIGHERA, // symbol@highera
|
|
|
|
VK_PPC_HIGHEST, // symbol@highest
|
|
|
|
VK_PPC_HIGHESTA, // symbol@highesta
|
2013-06-25 16:49:50 +00:00
|
|
|
VK_PPC_GOT_LO, // symbol@got@l
|
|
|
|
VK_PPC_GOT_HI, // symbol@got@h
|
|
|
|
VK_PPC_GOT_HA, // symbol@got@ha
|
2013-06-20 22:39:42 +00:00
|
|
|
VK_PPC_TOCBASE, // symbol@tocbase
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_TOC, // symbol@toc
|
|
|
|
VK_PPC_TOC_LO, // symbol@toc@l
|
2013-06-21 14:43:10 +00:00
|
|
|
VK_PPC_TOC_HI, // symbol@toc@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_TOC_HA, // symbol@toc@ha
|
2013-07-01 23:33:29 +00:00
|
|
|
VK_PPC_DTPMOD, // symbol@dtpmod
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_TPREL, // symbol@tprel
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_TPREL_LO, // symbol@tprel@l
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_TPREL_HI, // symbol@tprel@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_TPREL_HA, // symbol@tprel@ha
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_TPREL_HIGHER, // symbol@tprel@higher
|
|
|
|
VK_PPC_TPREL_HIGHERA, // symbol@tprel@highera
|
|
|
|
VK_PPC_TPREL_HIGHEST, // symbol@tprel@highest
|
|
|
|
VK_PPC_TPREL_HIGHESTA, // symbol@tprel@highesta
|
|
|
|
VK_PPC_DTPREL, // symbol@dtprel
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_DTPREL_LO, // symbol@dtprel@l
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_DTPREL_HI, // symbol@dtprel@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_DTPREL_HA, // symbol@dtprel@ha
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_DTPREL_HIGHER, // symbol@dtprel@higher
|
|
|
|
VK_PPC_DTPREL_HIGHERA, // symbol@dtprel@highera
|
|
|
|
VK_PPC_DTPREL_HIGHEST, // symbol@dtprel@highest
|
|
|
|
VK_PPC_DTPREL_HIGHESTA,// symbol@dtprel@highesta
|
|
|
|
VK_PPC_GOT_TPREL, // symbol@got@tprel
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_GOT_TPREL_LO, // symbol@got@tprel@l
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_GOT_TPREL_HI, // symbol@got@tprel@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_GOT_TPREL_HA, // symbol@got@tprel@ha
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_GOT_DTPREL, // symbol@got@dtprel
|
|
|
|
VK_PPC_GOT_DTPREL_LO, // symbol@got@dtprel@l
|
|
|
|
VK_PPC_GOT_DTPREL_HI, // symbol@got@dtprel@h
|
|
|
|
VK_PPC_GOT_DTPREL_HA, // symbol@got@dtprel@ha
|
2012-12-04 16:18:08 +00:00
|
|
|
VK_PPC_TLS, // symbol@tls
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_GOT_TLSGD, // symbol@got@tlsgd
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_GOT_TLSGD_LO, // symbol@got@tlsgd@l
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_GOT_TLSGD_HI, // symbol@got@tlsgd@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_GOT_TLSGD_HA, // symbol@got@tlsgd@ha
|
This patch implements the general dynamic TLS model for 64-bit PowerPC.
Given a thread-local symbol x with global-dynamic access, the generated
code to obtain x's address is:
Instruction Relocation Symbol
addis ra,r2,x@got@tlsgd@ha R_PPC64_GOT_TLSGD16_HA x
addi r3,ra,x@got@tlsgd@l R_PPC64_GOT_TLSGD16_L x
bl __tls_get_addr(x@tlsgd) R_PPC64_TLSGD x
R_PPC64_REL24 __tls_get_addr
nop
<use address in r3>
The implementation borrows from the medium code model work for introducing
special forms of ADDIS and ADDI into the DAG representation. This is made
slightly more complicated by having to introduce a call to the external
function __tls_get_addr. Using the full call machinery is overkill and,
more importantly, makes it difficult to add a special relocation. So I've
introduced another opcode GET_TLS_ADDR to represent the function call, and
surrounded it with register copies to set up the parameter and return value.
Most of the code is pretty straightforward. I ran into one peculiarity
when I introduced a new PPC opcode BL8_NOP_ELF_TLSGD, which is just like
BL8_NOP_ELF except that it takes another parameter to represent the symbol
("x" above) that requires a relocation on the call. Something in the
TblGen machinery causes BL8_NOP_ELF and BL8_NOP_ELF_TLSGD to be treated
identically during the emit phase, so this second operand was never
visited to generate relocations. This is the reason for the slightly
messy workaround in PPCMCCodeEmitter.cpp:getDirectBrEncoding().
Two new tests are included to demonstrate correct external assembly and
correct generation of relocations using the integrated assembler.
Comments welcome!
Thanks,
Bill
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@169910 91177308-0d34-0410-b5e6-96231b3b80d8
2012-12-11 20:30:11 +00:00
|
|
|
VK_PPC_TLSGD, // symbol@tlsgd
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_GOT_TLSLD, // symbol@got@tlsld
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_GOT_TLSLD_LO, // symbol@got@tlsld@l
|
2013-06-21 14:44:15 +00:00
|
|
|
VK_PPC_GOT_TLSLD_HI, // symbol@got@tlsld@h
|
2013-06-21 14:42:20 +00:00
|
|
|
VK_PPC_GOT_TLSLD_HA, // symbol@got@tlsld@ha
|
2012-12-12 19:29:35 +00:00
|
|
|
VK_PPC_TLSLD, // symbol@tlsld
|
2011-10-25 18:13:20 +00:00
|
|
|
|
|
|
|
VK_Mips_GPREL,
|
|
|
|
VK_Mips_GOT_CALL,
|
2011-12-07 00:28:57 +00:00
|
|
|
VK_Mips_GOT16,
|
2011-10-25 18:13:20 +00:00
|
|
|
VK_Mips_GOT,
|
|
|
|
VK_Mips_ABS_HI,
|
|
|
|
VK_Mips_ABS_LO,
|
|
|
|
VK_Mips_TLSGD,
|
2011-12-14 18:26:41 +00:00
|
|
|
VK_Mips_TLSLDM,
|
|
|
|
VK_Mips_DTPREL_HI,
|
|
|
|
VK_Mips_DTPREL_LO,
|
2011-10-25 18:13:20 +00:00
|
|
|
VK_Mips_GOTTPREL,
|
|
|
|
VK_Mips_TPREL_HI,
|
|
|
|
VK_Mips_TPREL_LO,
|
|
|
|
VK_Mips_GPOFF_HI,
|
|
|
|
VK_Mips_GPOFF_LO,
|
|
|
|
VK_Mips_GOT_DISP,
|
|
|
|
VK_Mips_GOT_PAGE,
|
2012-07-21 02:15:19 +00:00
|
|
|
VK_Mips_GOT_OFST,
|
|
|
|
VK_Mips_HIGHER,
|
2012-11-21 19:50:22 +00:00
|
|
|
VK_Mips_HIGHEST,
|
|
|
|
VK_Mips_GOT_HI16,
|
|
|
|
VK_Mips_GOT_LO16,
|
|
|
|
VK_Mips_CALL_HI16,
|
2013-04-10 23:28:17 +00:00
|
|
|
VK_Mips_CALL_LO16,
|
|
|
|
|
|
|
|
VK_COFF_IMGREL32 // symbol@imgrel (image-relative)
|
2010-03-15 23:51:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
/// The symbol being referenced.
|
2009-08-31 08:07:22 +00:00
|
|
|
const MCSymbol *Symbol;
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2010-03-15 23:51:06 +00:00
|
|
|
/// The symbol reference modifier.
|
|
|
|
const VariantKind Kind;
|
|
|
|
|
|
|
|
explicit MCSymbolRefExpr(const MCSymbol *_Symbol, VariantKind _Kind)
|
2012-01-07 03:13:18 +00:00
|
|
|
: MCExpr(MCExpr::SymbolRef), Symbol(_Symbol), Kind(_Kind) {
|
|
|
|
assert(Symbol);
|
|
|
|
}
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
public:
|
|
|
|
/// @name Construction
|
|
|
|
/// @{
|
|
|
|
|
2010-03-15 23:51:06 +00:00
|
|
|
static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, MCContext &Ctx) {
|
|
|
|
return MCSymbolRefExpr::Create(Symbol, VK_None, Ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static const MCSymbolRefExpr *Create(const MCSymbol *Symbol, VariantKind Kind,
|
|
|
|
MCContext &Ctx);
|
|
|
|
static const MCSymbolRefExpr *Create(StringRef Name, VariantKind Kind,
|
|
|
|
MCContext &Ctx);
|
2011-02-03 23:17:44 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @}
|
|
|
|
/// @name Accessors
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
const MCSymbol &getSymbol() const { return *Symbol; }
|
|
|
|
|
2010-03-15 23:51:06 +00:00
|
|
|
VariantKind getKind() const { return Kind; }
|
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Static Utility Functions
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
static StringRef getVariantKindName(VariantKind Kind);
|
|
|
|
|
|
|
|
static VariantKind getVariantKindForName(StringRef Name);
|
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @}
|
|
|
|
|
|
|
|
static bool classof(const MCExpr *E) {
|
|
|
|
return E->getKind() == MCExpr::SymbolRef;
|
2009-06-29 20:40:36 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
/// MCUnaryExpr - Unary assembler expressions.
|
|
|
|
class MCUnaryExpr : public MCExpr {
|
2009-06-29 20:40:36 +00:00
|
|
|
public:
|
|
|
|
enum Opcode {
|
2009-07-01 15:14:50 +00:00
|
|
|
LNot, ///< Logical negation.
|
|
|
|
Minus, ///< Unary minus.
|
|
|
|
Not, ///< Bitwise negation.
|
|
|
|
Plus ///< Unary plus.
|
2009-06-29 20:40:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
Opcode Op;
|
2009-08-31 08:07:22 +00:00
|
|
|
const MCExpr *Expr;
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
MCUnaryExpr(Opcode _Op, const MCExpr *_Expr)
|
2009-08-31 08:06:59 +00:00
|
|
|
: MCExpr(MCExpr::Unary), Op(_Op), Expr(_Expr) {}
|
2009-08-31 08:07:22 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
/// @name Construction
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
static const MCUnaryExpr *Create(Opcode Op, const MCExpr *Expr,
|
|
|
|
MCContext &Ctx);
|
|
|
|
static const MCUnaryExpr *CreateLNot(const MCExpr *Expr, MCContext &Ctx) {
|
|
|
|
return Create(LNot, Expr, Ctx);
|
|
|
|
}
|
|
|
|
static const MCUnaryExpr *CreateMinus(const MCExpr *Expr, MCContext &Ctx) {
|
|
|
|
return Create(Minus, Expr, Ctx);
|
|
|
|
}
|
|
|
|
static const MCUnaryExpr *CreateNot(const MCExpr *Expr, MCContext &Ctx) {
|
|
|
|
return Create(Not, Expr, Ctx);
|
2009-06-29 20:40:36 +00:00
|
|
|
}
|
2009-08-31 08:07:22 +00:00
|
|
|
static const MCUnaryExpr *CreatePlus(const MCExpr *Expr, MCContext &Ctx) {
|
|
|
|
return Create(Plus, Expr, Ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Accessors
|
|
|
|
/// @{
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// getOpcode - Get the kind of this unary expression.
|
2009-06-29 20:40:36 +00:00
|
|
|
Opcode getOpcode() const { return Op; }
|
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// getSubExpr - Get the child of this unary expression.
|
|
|
|
const MCExpr *getSubExpr() const { return Expr; }
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// @}
|
|
|
|
|
|
|
|
static bool classof(const MCExpr *E) {
|
|
|
|
return E->getKind() == MCExpr::Unary;
|
2009-06-29 20:40:36 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-08-31 08:06:59 +00:00
|
|
|
/// MCBinaryExpr - Binary assembler expressions.
|
|
|
|
class MCBinaryExpr : public MCExpr {
|
2009-06-29 20:40:36 +00:00
|
|
|
public:
|
|
|
|
enum Opcode {
|
2009-07-01 15:14:50 +00:00
|
|
|
Add, ///< Addition.
|
|
|
|
And, ///< Bitwise and.
|
2010-02-08 23:58:47 +00:00
|
|
|
Div, ///< Signed division.
|
2009-07-01 15:14:50 +00:00
|
|
|
EQ, ///< Equality comparison.
|
2010-02-08 23:58:47 +00:00
|
|
|
GT, ///< Signed greater than comparison (result is either 0 or some
|
|
|
|
///< target-specific non-zero value)
|
|
|
|
GTE, ///< Signed greater than or equal comparison (result is either 0 or
|
|
|
|
///< some target-specific non-zero value).
|
2009-07-01 15:14:50 +00:00
|
|
|
LAnd, ///< Logical and.
|
|
|
|
LOr, ///< Logical or.
|
2010-02-08 23:58:47 +00:00
|
|
|
LT, ///< Signed less than comparison (result is either 0 or
|
|
|
|
///< some target-specific non-zero value).
|
|
|
|
LTE, ///< Signed less than or equal comparison (result is either 0 or
|
|
|
|
///< some target-specific non-zero value).
|
|
|
|
Mod, ///< Signed remainder.
|
2009-07-01 15:14:50 +00:00
|
|
|
Mul, ///< Multiplication.
|
|
|
|
NE, ///< Inequality comparison.
|
|
|
|
Or, ///< Bitwise or.
|
2010-02-08 23:58:47 +00:00
|
|
|
Shl, ///< Shift left.
|
|
|
|
Shr, ///< Shift right (arithmetic or logical, depending on target)
|
2009-07-01 15:14:50 +00:00
|
|
|
Sub, ///< Subtraction.
|
|
|
|
Xor ///< Bitwise exclusive or.
|
2009-06-29 20:40:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
private:
|
|
|
|
Opcode Op;
|
2009-08-31 08:07:22 +00:00
|
|
|
const MCExpr *LHS, *RHS;
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
MCBinaryExpr(Opcode _Op, const MCExpr *_LHS, const MCExpr *_RHS)
|
2009-08-31 08:06:59 +00:00
|
|
|
: MCExpr(MCExpr::Binary), Op(_Op), LHS(_LHS), RHS(_RHS) {}
|
2009-08-31 08:07:22 +00:00
|
|
|
|
|
|
|
public:
|
|
|
|
/// @name Construction
|
|
|
|
/// @{
|
|
|
|
|
|
|
|
static const MCBinaryExpr *Create(Opcode Op, const MCExpr *LHS,
|
|
|
|
const MCExpr *RHS, MCContext &Ctx);
|
|
|
|
static const MCBinaryExpr *CreateAdd(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Add, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateAnd(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(And, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateDiv(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Div, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateEQ(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(EQ, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateGT(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(GT, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateGTE(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(GTE, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateLAnd(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(LAnd, LHS, RHS, Ctx);
|
2009-06-29 20:40:36 +00:00
|
|
|
}
|
2009-08-31 08:07:22 +00:00
|
|
|
static const MCBinaryExpr *CreateLOr(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(LOr, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateLT(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(LT, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateLTE(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(LTE, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateMod(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Mod, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateMul(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Mul, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateNE(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(NE, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateOr(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Or, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateShl(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Shl, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateShr(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Shr, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateSub(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Sub, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
static const MCBinaryExpr *CreateXor(const MCExpr *LHS, const MCExpr *RHS,
|
|
|
|
MCContext &Ctx) {
|
|
|
|
return Create(Xor, LHS, RHS, Ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// @}
|
|
|
|
/// @name Accessors
|
|
|
|
/// @{
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
/// getOpcode - Get the kind of this binary expression.
|
2009-06-29 20:40:36 +00:00
|
|
|
Opcode getOpcode() const { return Op; }
|
|
|
|
|
2009-07-01 15:14:50 +00:00
|
|
|
/// getLHS - Get the left-hand side expression of the binary operator.
|
2009-08-31 08:07:22 +00:00
|
|
|
const MCExpr *getLHS() const { return LHS; }
|
2009-07-01 15:14:50 +00:00
|
|
|
|
|
|
|
/// getRHS - Get the right-hand side expression of the binary operator.
|
2009-08-31 08:07:22 +00:00
|
|
|
const MCExpr *getRHS() const { return RHS; }
|
|
|
|
|
|
|
|
/// @}
|
2009-06-29 20:40:36 +00:00
|
|
|
|
2009-08-31 08:07:22 +00:00
|
|
|
static bool classof(const MCExpr *E) {
|
|
|
|
return E->getKind() == MCExpr::Binary;
|
2009-06-29 20:40:36 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2010-02-08 19:41:07 +00:00
|
|
|
/// MCTargetExpr - This is an extension point for target-specific MCExpr
|
|
|
|
/// subclasses to implement.
|
|
|
|
///
|
|
|
|
/// NOTE: All subclasses are required to have trivial destructors because
|
|
|
|
/// MCExprs are bump pointer allocated and not destructed.
|
|
|
|
class MCTargetExpr : public MCExpr {
|
2012-09-26 06:36:36 +00:00
|
|
|
virtual void anchor();
|
2010-02-08 19:41:07 +00:00
|
|
|
protected:
|
|
|
|
MCTargetExpr() : MCExpr(Target) {}
|
2010-02-10 21:37:31 +00:00
|
|
|
virtual ~MCTargetExpr() {}
|
2010-02-08 19:41:07 +00:00
|
|
|
public:
|
2010-03-12 21:00:45 +00:00
|
|
|
|
2010-02-08 19:41:07 +00:00
|
|
|
virtual void PrintImpl(raw_ostream &OS) const = 0;
|
2010-03-11 02:28:59 +00:00
|
|
|
virtual bool EvaluateAsRelocatableImpl(MCValue &Res,
|
2010-03-12 21:00:45 +00:00
|
|
|
const MCAsmLayout *Layout) const = 0;
|
2011-01-13 07:58:56 +00:00
|
|
|
virtual void AddValueSymbols(MCAssembler *) const = 0;
|
2011-04-29 18:00:03 +00:00
|
|
|
virtual const MCSection *FindAssociatedSection() const = 0;
|
2010-02-08 19:41:07 +00:00
|
|
|
|
2013-01-31 12:12:40 +00:00
|
|
|
virtual void fixELFSymbolsInTLSFixups(MCAssembler &) const = 0;
|
|
|
|
|
2010-02-08 19:41:07 +00:00
|
|
|
static bool classof(const MCExpr *E) {
|
|
|
|
return E->getKind() == MCExpr::Target;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2009-06-29 20:40:36 +00:00
|
|
|
} // end namespace llvm
|
|
|
|
|
|
|
|
#endif
|