LLVM  3.7.0
ARMMCTargetDesc.h
Go to the documentation of this file.
1 //===-- ARMMCTargetDesc.h - ARM Target Descriptions -------------*- C++ -*-===//
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 provides ARM specific target descriptions.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_ARM_MCTARGETDESC_ARMMCTARGETDESC_H
15 #define LLVM_LIB_TARGET_ARM_MCTARGETDESC_ARMMCTARGETDESC_H
16 
17 #include "llvm/Support/DataTypes.h"
18 #include <string>
19 
20 namespace llvm {
21 class formatted_raw_ostream;
22 class MCAsmBackend;
23 class MCCodeEmitter;
24 class MCContext;
25 class MCInstrInfo;
26 class MCInstPrinter;
27 class MCObjectWriter;
28 class MCRegisterInfo;
29 class MCSubtargetInfo;
30 class MCStreamer;
31 class MCRelocationInfo;
32 class MCTargetStreamer;
33 class StringRef;
34 class Target;
35 class Triple;
36 class raw_ostream;
37 class raw_pwrite_stream;
38 
39 extern Target TheARMLETarget, TheThumbLETarget;
40 extern Target TheARMBETarget, TheThumbBETarget;
41 
42 namespace ARM_MC {
43 std::string ParseARMTriple(const Triple &TT, StringRef CPU);
44 
45 /// Create a ARM MCSubtargetInfo instance. This is exposed so Asm parser, etc.
46 /// do not need to go through TargetRegistry.
48  StringRef FS);
49 }
50 
54  MCInstPrinter *InstPrint,
55  bool isVerboseAsm);
57  const MCSubtargetInfo &STI);
58 
60  const MCRegisterInfo &MRI,
61  MCContext &Ctx);
62 
64  const MCRegisterInfo &MRI,
65  MCContext &Ctx);
66 
68  const Triple &TT, StringRef CPU,
69  bool IsLittleEndian);
70 
72  const Triple &TT, StringRef CPU);
73 
75  const Triple &TT, StringRef CPU);
76 
78  const MCRegisterInfo &MRI,
79  const Triple &TT, StringRef CPU);
80 
82  const MCRegisterInfo &MRI,
83  const Triple &TT, StringRef CPU);
84 
85 // Construct a PE/COFF machine code streamer which will generate a PE/COFF
86 // object file.
89  MCCodeEmitter *Emitter, bool RelaxAll);
90 
91 /// Construct an ELF Mach-O object writer.
93  bool IsLittleEndian);
94 
95 /// Construct an ARM Mach-O object writer.
97  uint32_t CPUType,
98  uint32_t CPUSubtype);
99 
100 /// Construct an ARM PE/COFF object writer.
102  bool Is64Bit);
103 
104 /// Construct ARM Mach-O relocation info.
106 } // End llvm namespace
107 
108 // Defines symbolic names for ARM registers. This defines a mapping from
109 // register name to register number.
110 //
111 #define GET_REGINFO_ENUM
112 #include "ARMGenRegisterInfo.inc"
113 
114 // Defines symbolic names for the ARM instructions.
115 //
116 #define GET_INSTRINFO_ENUM
117 #include "ARMGenInstrInfo.inc"
118 
119 #define GET_SUBTARGETINFO_ENUM
120 #include "ARMGenSubtargetInfo.inc"
121 
122 #endif
Target TheThumbLETarget
MCObjectWriter * createARMWinCOFFObjectWriter(raw_pwrite_stream &OS, bool Is64Bit)
Construct an ARM PE/COFF object writer.
formatted_raw_ostream - A raw_ostream that wraps another one and keeps track of line and column posit...
Target specific streamer interface.
Definition: MCStreamer.h:73
MCRelocationInfo * createARMMachORelocationInfo(MCContext &Ctx)
Construct ARM Mach-O relocation info.
MCObjectWriter * createARMMachObjectWriter(raw_pwrite_stream &OS, bool Is64Bit, uint32_t CPUType, uint32_t CPUSubtype)
Construct an ARM Mach-O object writer.
Defines the object file and target independent interfaces used by the assembler backend to write nati...
MCStreamer * createARMWinCOFFStreamer(MCContext &Context, MCAsmBackend &MAB, raw_pwrite_stream &OS, MCCodeEmitter *Emitter, bool RelaxAll)
Context object for machine code objects.
Definition: MCContext.h:48
MCAsmBackend * createARMLEAsmBackend(const Target &T, const MCRegisterInfo &MRI, const Triple &TT, StringRef CPU)
MCAsmBackend * createThumbBEAsmBackend(const Target &T, const MCRegisterInfo &MRI, const Triple &TT, StringRef CPU)
MCAsmBackend * createARMAsmBackend(const Target &T, const MCRegisterInfo &MRI, const Triple &TT, StringRef CPU, bool IsLittleEndian)
MCObjectWriter * createARMELFObjectWriter(raw_pwrite_stream &OS, uint8_t OSABI, bool IsLittleEndian)
Construct an ELF Mach-O object writer.
MCTargetStreamer * createARMTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint, bool isVerboseAsm)
MCRegisterInfo base class - We assume that the target defines a static array of MCRegisterDesc object...
MCTargetStreamer * createARMObjectTargetStreamer(MCStreamer &S, const MCSubtargetInfo &STI)
Streaming machine code generation interface.
Definition: MCStreamer.h:157
MCCodeEmitter - Generic instruction encoding interface.
Definition: MCCodeEmitter.h:23
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:24
Create MCExprs from relocations found in an object file.
MCSubtargetInfo * createARMMCSubtargetInfo(const Triple &TT, StringRef CPU, StringRef FS)
Create a ARM MCSubtargetInfo instance.
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
Target - Wrapper for Target specific information.
MCCodeEmitter * createARMLEMCCodeEmitter(const MCInstrInfo &MCII, const MCRegisterInfo &MRI, MCContext &Ctx)
This is an instance of a target assembly language printer that converts an MCInst to valid target ass...
Definition: MCInstPrinter.h:38
Target TheThumbBETarget
Target TheARMLETarget
MCSubtargetInfo - Generic base class for all target subtargets.
Target TheARMBETarget
An abstract base class for streams implementations that also support a pwrite operation.
Definition: raw_ostream.h:321
MCTargetStreamer * createARMNullTargetStreamer(MCStreamer &S)
cl::opt< bool > RelaxAll("mc-relax-all", cl::desc("When used with filetype=obj, ""relax all fixups in the emitted object file"))
MCAsmBackend * createThumbLEAsmBackend(const Target &T, const MCRegisterInfo &MRI, const Triple &TT, StringRef CPU)
MCAsmBackend * createARMBEAsmBackend(const Target &T, const MCRegisterInfo &MRI, const Triple &TT, StringRef CPU)
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:34
std::string ParseARMTriple(const Triple &TT, StringRef CPU)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
MCCodeEmitter * createARMBEMCCodeEmitter(const MCInstrInfo &MCII, const MCRegisterInfo &MRI, MCContext &Ctx)