1//===- LLVM.h - Import and forward declare core LLVM types ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file forward declares and imports various common LLVM datatypes that
10// MLIR wants to use unqualified.
11//
12// Note that most of these are forward declared and then imported into the MLIR
13// namespace with using decls, rather than being #included. This is because we
14// want clients to explicitly #include the files they need.
15//
16//===----------------------------------------------------------------------===//
17
18#ifndef MLIR_SUPPORT_LLVM_H
19#define MLIR_SUPPORT_LLVM_H
20
21// We include this header because it cannot be practically forward
22// declared, and are effectively language features.
23#include "llvm/Support/Casting.h"
24
25// We include this header because large portions of mlir would have to include
26// it anyway.
27#include "llvm/Support/LogicalResult.h"
28
29// Workaround for clang-5 (PR41549)
30#if defined(__clang_major__)
31#if __clang_major__ <= 5
32#include "llvm/ADT/DenseMapInfo.h"
33#include "llvm/ADT/SmallVector.h"
34#endif
35#endif
36
37// Forward declarations.
38namespace llvm {
39// String types
40template <unsigned N>
41class SmallString;
42class StringRef;
43class StringLiteral;
44class Twine;
45
46// Containers.
47template <typename T>
48class ArrayRef;
49class BitVector;
50namespace detail {
51template <typename KeyT, typename ValueT>
52struct DenseMapPair;
53} // namespace detail
54template <typename KeyT, typename ValueT, typename KeyInfoT, typename BucketT>
55class DenseMap;
56template <typename T, typename Enable>
57struct DenseMapInfo;
58template <typename ValueT, typename ValueInfoT>
59class DenseSet;
60class MallocAllocator;
61template <typename T>
62class MutableArrayRef;
63template <typename... PT>
64class PointerUnion;
65template <typename T, typename Vector, typename Set, unsigned N>
66class SetVector;
67template <typename T, unsigned N>
68class SmallPtrSet;
69template <typename T>
70class SmallPtrSetImpl;
71template <typename T, unsigned N>
72class SmallVector;
73template <typename T>
74class SmallVectorImpl;
75template <typename AllocatorTy>
76class StringSet;
77template <typename T, typename R>
78class StringSwitch;
79template <typename T>
80class TinyPtrVector;
81template <typename T, typename ResultT>
82class TypeSwitch;
83
84// Other common classes.
85class APInt;
86class DynamicAPInt;
87class APSInt;
88class APFloat;
89template <typename Fn>
90class function_ref;
91template <typename IteratorT>
92class iterator_range;
93class raw_ostream;
94class SMLoc;
95class SMRange;
96} // namespace llvm
97
98namespace mlir {
99// Casting operators.
100using llvm::cast;
101using llvm::cast_if_present;
102using llvm::cast_or_null;
103using llvm::dyn_cast;
104using llvm::dyn_cast_if_present;
105using llvm::dyn_cast_or_null;
106using llvm::isa;
107using llvm::isa_and_nonnull;
108using llvm::isa_and_present;
109
110// String types
111using llvm::SmallString;
112using llvm::StringLiteral;
113using llvm::StringRef;
114using llvm::Twine;
115
116// Container Related types
117//
118// Containers.
119using llvm::ArrayRef;
120using llvm::BitVector;
121template <typename T, typename Enable = void>
122using DenseMapInfo = llvm::DenseMapInfo<T, Enable>;
123template <typename KeyT, typename ValueT,
124 typename KeyInfoT = DenseMapInfo<KeyT>,
125 typename BucketT = llvm::detail::DenseMapPair<KeyT, ValueT>>
126using DenseMap = llvm::DenseMap<KeyT, ValueT, KeyInfoT, BucketT>;
127template <typename ValueT, typename ValueInfoT = DenseMapInfo<ValueT>>
128using DenseSet = llvm::DenseSet<ValueT, ValueInfoT>;
129template <typename T, typename Vector = llvm::SmallVector<T, 0>,
130 typename Set = DenseSet<T>, unsigned N = 0>
131using SetVector = llvm::SetVector<T, Vector, Set, N>;
132template <typename AllocatorTy = llvm::MallocAllocator>
133using StringSet = llvm::StringSet<AllocatorTy>;
134using llvm::MutableArrayRef;
135using llvm::PointerUnion;
136using llvm::SmallPtrSet;
137using llvm::SmallPtrSetImpl;
138using llvm::SmallVector;
139using llvm::SmallVectorImpl;
140template <typename T, typename R = T>
141using StringSwitch = llvm::StringSwitch<T, R>;
142using llvm::TinyPtrVector;
143template <typename T, typename ResultT = void>
144using TypeSwitch = llvm::TypeSwitch<T, ResultT>;
145
146// Other common classes.
147using llvm::APFloat;
148using llvm::APInt;
149using llvm::APSInt;
150using llvm::DynamicAPInt;
151template <typename Fn>
152using function_ref = llvm::function_ref<Fn>;
153using llvm::iterator_range;
154using llvm::raw_ostream;
155using llvm::SMLoc;
156using llvm::SMRange;
157
158// LogicalResult.
159using llvm::failed;
160using llvm::failure;
161using llvm::FailureOr;
162using llvm::LogicalResult;
163using llvm::ParseResult;
164using llvm::succeeded;
165using llvm::success;
166} // namespace mlir
167
168#endif // MLIR_SUPPORT_LLVM_H
169

source code of mlir/include/mlir/Support/LLVM.h