LLVM  4.0.0
LegalizerHelper.h
Go to the documentation of this file.
1 //== llvm/CodeGen/GlobalISel/LegalizerHelper.h ---------------- -*- 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 /// \file A pass to convert the target-illegal operations created by IR -> MIR
11 /// translation into ones the target expects to be able to select. This may
12 /// occur in multiple phases, for example G_ADD <2 x i8> -> G_ADD <2 x i16> ->
13 /// G_ADD <4 x i16>.
14 ///
15 /// The LegalizerHelper class is where most of the work happens, and is
16 /// designed to be callable from other passes that find themselves with an
17 /// illegal instruction.
18 //
19 //===----------------------------------------------------------------------===//
20 
21 #ifndef LLVM_CODEGEN_GLOBALISEL_MACHINELEGALIZEHELPER_H
22 #define LLVM_CODEGEN_GLOBALISEL_MACHINELEGALIZEHELPER_H
23 
27 
28 namespace llvm {
29 // Forward declarations.
30 class LegalizerInfo;
31 class Legalizer;
32 class MachineRegisterInfo;
33 
35 public:
37  /// Instruction was already legal and no change was made to the
38  /// MachineFunction.
40 
41  /// Instruction has been legalized and the MachineFunction changed.
43 
44  /// Some kind of error has occurred and we could not legalize this
45  /// instruction.
47  };
48 
50 
51  /// Replace \p MI by a sequence of legal instructions that can implement the
52  /// same operation. Note that this means \p MI may be deleted, so any iterator
53  /// steps should be performed before calling this function. \p Helper should
54  /// be initialized to the MachineFunction containing \p MI.
55  ///
56  /// Considered as an opaque blob, the legal code will use and define the same
57  /// registers as \p MI.
60 
63 
64  /// Legalize an instruction by emiting a runtime library call instead.
66 
67  /// Legalize an instruction by reducing the width of the underlying scalar
68  /// type.
69  LegalizeResult narrowScalar(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy);
70 
71  /// Legalize an instruction by performing the operation on a wider scalar type
72  /// (for example a 16-bit addition can be safely performed at 32-bits
73  /// precision, ignoring the unused bits).
74  LegalizeResult widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy);
75 
76  /// Legalize an instruction by splitting it into simpler parts, hopefully
77  /// understood by the target.
78  LegalizeResult lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty);
79 
80  /// Legalize a vector instruction by splitting into multiple components, each
81  /// acting on the same scalar type as the original but with fewer elements.
83  LLT NarrowTy);
84 
85  /// Legalize a vector instruction by increasing the number of vector elements
86  /// involved and ignoring the added elements later.
88  LLT WideTy);
89 
90 private:
91 
92  /// Helper function to split a wide generic register into bitwise blocks with
93  /// the given Type (which implies the number of blocks needed). The generic
94  /// registers created are appended to Ops, starting at bit 0 of Reg.
95  void extractParts(unsigned Reg, LLT Ty, int NumParts,
97 
98  MachineIRBuilder MIRBuilder;
100 };
101 
102 } // End namespace llvm.
103 
104 #endif
LegalizeResult legalizeInstr(MachineInstr &MI, const LegalizerInfo &LegalizerInfo)
LegalizerHelper(MachineFunction &MF)
LegalizeResult widenScalar(MachineInstr &MI, unsigned TypeIdx, LLT WideTy)
Legalize an instruction by performing the operation on a wider scalar type (for example a 16-bit addi...
Reg
All possible values of the reg field in the ModR/M byte.
Helper class to build MachineInstr.
Some kind of error has occurred and we could not legalize this instruction.
Instruction was already legal and no change was made to the MachineFunction.
LegalizeResult moreElementsVector(MachineInstr &MI, unsigned TypeIdx, LLT WideTy)
Legalize a vector instruction by increasing the number of vector elements involved and ignoring the a...
LegalizeResult libcall(MachineInstr &MI)
Legalize an instruction by emiting a runtime library call instead.
LegalizeResult lower(MachineInstr &MI, unsigned TypeIdx, LLT Ty)
Legalize an instruction by splitting it into simpler parts, hopefully understood by the target...
LegalizeResult fewerElementsVector(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy)
Legalize a vector instruction by splitting into multiple components, each acting on the same scalar t...
This file declares the MachineIRBuilder class.
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
Representation of each machine instruction.
Definition: MachineInstr.h:52
Instruction has been legalized and the MachineFunction changed.
LegalizeResult narrowScalar(MachineInstr &MI, unsigned TypeIdx, LLT NarrowTy)
Legalize an instruction by reducing the width of the underlying scalar type.
IRTranslator LLVM IR MI
LegalizeResult legalizeInstrStep(MachineInstr &MI, const LegalizerInfo &LegalizerInfo)
Replace MI by a sequence of legal instructions that can implement the same operation.