Movatterモバイル変換

[0]ホーム
URL:

LLVM 20.0.0git
SlowDynamicAPInt.cpp
Go to the documentation of this file.
1//===- SlowDynamicAPInt.cpp - SlowDynamicAPInt Implementation -------------===//
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#include "llvm/ADT/SlowDynamicAPInt.h"
10#include "llvm/ADT/Hashing.h"
11#include "llvm/Support/Debug.h"
12#include "llvm/Support/raw_ostream.h"
13
14using namespacellvm;
15using namespacedetail;
16
17SlowDynamicAPInt::SlowDynamicAPInt(int64_t Val)
18 : Val(64, Val,/*isSigned=*/true) {}
19SlowDynamicAPInt::SlowDynamicAPInt() :SlowDynamicAPInt(0) {}
20SlowDynamicAPInt::SlowDynamicAPInt(constAPInt &Val) : Val(Val) {}
21SlowDynamicAPInt &SlowDynamicAPInt::operator=(int64_t Val) {
22return *this =SlowDynamicAPInt(Val);
23}
24SlowDynamicAPInt::operator int64_t() const{return Val.getSExtValue(); }
25
26hash_codedetail::hash_value(constSlowDynamicAPInt &X) {
27returnhash_value(X.Val);
28}
29
30/// ---------------------------------------------------------------------------
31/// Convenience operator overloads for int64_t.
32/// ---------------------------------------------------------------------------
33SlowDynamicAPInt &detail::operator+=(SlowDynamicAPInt &A, int64_tB) {
34returnA +=SlowDynamicAPInt(B);
35}
36SlowDynamicAPInt &detail::operator-=(SlowDynamicAPInt &A, int64_tB) {
37returnA -=SlowDynamicAPInt(B);
38}
39SlowDynamicAPInt &detail::operator*=(SlowDynamicAPInt &A, int64_tB) {
40returnA *=SlowDynamicAPInt(B);
41}
42SlowDynamicAPInt &detail::operator/=(SlowDynamicAPInt &A, int64_tB) {
43returnA /=SlowDynamicAPInt(B);
44}
45SlowDynamicAPInt &detail::operator%=(SlowDynamicAPInt &A, int64_tB) {
46returnA %=SlowDynamicAPInt(B);
47}
48
49booldetail::operator==(constSlowDynamicAPInt &A, int64_tB) {
50returnA ==SlowDynamicAPInt(B);
51}
52booldetail::operator!=(constSlowDynamicAPInt &A, int64_tB) {
53returnA !=SlowDynamicAPInt(B);
54}
55booldetail::operator>(constSlowDynamicAPInt &A, int64_tB) {
56returnA >SlowDynamicAPInt(B);
57}
58booldetail::operator<(constSlowDynamicAPInt &A, int64_tB) {
59returnA <SlowDynamicAPInt(B);
60}
61booldetail::operator<=(constSlowDynamicAPInt &A, int64_tB) {
62returnA <=SlowDynamicAPInt(B);
63}
64booldetail::operator>=(constSlowDynamicAPInt &A, int64_tB) {
65returnA >=SlowDynamicAPInt(B);
66}
67SlowDynamicAPIntdetail::operator+(constSlowDynamicAPInt &A, int64_tB) {
68returnA +SlowDynamicAPInt(B);
69}
70SlowDynamicAPIntdetail::operator-(constSlowDynamicAPInt &A, int64_tB) {
71returnA -SlowDynamicAPInt(B);
72}
73SlowDynamicAPIntdetail::operator*(constSlowDynamicAPInt &A, int64_tB) {
74returnA *SlowDynamicAPInt(B);
75}
76SlowDynamicAPIntdetail::operator/(constSlowDynamicAPInt &A, int64_tB) {
77returnA /SlowDynamicAPInt(B);
78}
79SlowDynamicAPIntdetail::operator%(constSlowDynamicAPInt &A, int64_tB) {
80returnA %SlowDynamicAPInt(B);
81}
82
83booldetail::operator==(int64_tA,constSlowDynamicAPInt &B) {
84returnSlowDynamicAPInt(A) ==B;
85}
86booldetail::operator!=(int64_tA,constSlowDynamicAPInt &B) {
87returnSlowDynamicAPInt(A) !=B;
88}
89booldetail::operator>(int64_tA,constSlowDynamicAPInt &B) {
90returnSlowDynamicAPInt(A) >B;
91}
92booldetail::operator<(int64_tA,constSlowDynamicAPInt &B) {
93returnSlowDynamicAPInt(A) <B;
94}
95booldetail::operator<=(int64_tA,constSlowDynamicAPInt &B) {
96returnSlowDynamicAPInt(A) <=B;
97}
98booldetail::operator>=(int64_tA,constSlowDynamicAPInt &B) {
99returnSlowDynamicAPInt(A) >=B;
100}
101SlowDynamicAPIntdetail::operator+(int64_tA,constSlowDynamicAPInt &B) {
102returnSlowDynamicAPInt(A) +B;
103}
104SlowDynamicAPIntdetail::operator-(int64_tA,constSlowDynamicAPInt &B) {
105returnSlowDynamicAPInt(A) -B;
106}
107SlowDynamicAPIntdetail::operator*(int64_tA,constSlowDynamicAPInt &B) {
108returnSlowDynamicAPInt(A) *B;
109}
110SlowDynamicAPIntdetail::operator/(int64_tA,constSlowDynamicAPInt &B) {
111returnSlowDynamicAPInt(A) /B;
112}
113SlowDynamicAPIntdetail::operator%(int64_tA,constSlowDynamicAPInt &B) {
114returnSlowDynamicAPInt(A) %B;
115}
116
117staticunsignedgetMaxWidth(constAPInt &A,constAPInt &B) {
118return std::max(A.getBitWidth(),B.getBitWidth());
119}
120
121/// ---------------------------------------------------------------------------
122/// Comparison operators.
123/// ---------------------------------------------------------------------------
124
125// TODO: consider instead making APInt::compare available and using that.
126boolSlowDynamicAPInt::operator==(constSlowDynamicAPInt &O) const{
127unsigned Width =getMaxWidth(Val, O.Val);
128return Val.sext(Width) == O.Val.sext(Width);
129}
130boolSlowDynamicAPInt::operator!=(constSlowDynamicAPInt &O) const{
131unsigned Width =getMaxWidth(Val, O.Val);
132return Val.sext(Width) != O.Val.sext(Width);
133}
134boolSlowDynamicAPInt::operator>(constSlowDynamicAPInt &O) const{
135unsigned Width =getMaxWidth(Val, O.Val);
136return Val.sext(Width).sgt(O.Val.sext(Width));
137}
138boolSlowDynamicAPInt::operator<(constSlowDynamicAPInt &O) const{
139unsigned Width =getMaxWidth(Val, O.Val);
140return Val.sext(Width).slt(O.Val.sext(Width));
141}
142boolSlowDynamicAPInt::operator<=(constSlowDynamicAPInt &O) const{
143unsigned Width =getMaxWidth(Val, O.Val);
144return Val.sext(Width).sle(O.Val.sext(Width));
145}
146boolSlowDynamicAPInt::operator>=(constSlowDynamicAPInt &O) const{
147unsigned Width =getMaxWidth(Val, O.Val);
148return Val.sext(Width).sge(O.Val.sext(Width));
149}
150
151/// ---------------------------------------------------------------------------
152/// Arithmetic operators.
153/// ---------------------------------------------------------------------------
154
155/// Bring a and b to have the same width and then call op(a, b, overflow).
156/// If the overflow bit becomes set, resize a and b to double the width and
157/// call op(a, b, overflow), returning its result. The operation with double
158/// widths should not also overflow.
159APIntrunOpWithExpandOnOverflow(
160constAPInt &A,constAPInt &B,
161function_ref<APInt(constAPInt &,constAPInt &,bool &Overflow)>Op) {
162bool Overflow;
163unsigned Width =getMaxWidth(A,B);
164APInt Ret =Op(A.sext(Width),B.sext(Width), Overflow);
165if (!Overflow)
166return Ret;
167
168 Width *= 2;
169 Ret =Op(A.sext(Width),B.sext(Width), Overflow);
170assert(!Overflow &&"double width should be sufficient to avoid overflow!");
171return Ret;
172}
173
174SlowDynamicAPIntSlowDynamicAPInt::operator+(constSlowDynamicAPInt &O) const{
175returnSlowDynamicAPInt(
176runOpWithExpandOnOverflow(Val, O.Val, std::mem_fn(&APInt::sadd_ov)));
177}
178SlowDynamicAPIntSlowDynamicAPInt::operator-(constSlowDynamicAPInt &O) const{
179returnSlowDynamicAPInt(
180runOpWithExpandOnOverflow(Val, O.Val, std::mem_fn(&APInt::ssub_ov)));
181}
182SlowDynamicAPIntSlowDynamicAPInt::operator*(constSlowDynamicAPInt &O) const{
183returnSlowDynamicAPInt(
184runOpWithExpandOnOverflow(Val, O.Val, std::mem_fn(&APInt::smul_ov)));
185}
186SlowDynamicAPIntSlowDynamicAPInt::operator/(constSlowDynamicAPInt &O) const{
187returnSlowDynamicAPInt(
188runOpWithExpandOnOverflow(Val, O.Val, std::mem_fn(&APInt::sdiv_ov)));
189}
190SlowDynamicAPIntdetail::abs(constSlowDynamicAPInt &X) {
191returnX >= 0 ?X : -X;
192}
193SlowDynamicAPIntdetail::ceilDiv(constSlowDynamicAPInt &LHS,
194constSlowDynamicAPInt &RHS) {
195if (RHS == -1)
196return -LHS;
197unsigned Width =getMaxWidth(LHS.Val,RHS.Val);
198returnSlowDynamicAPInt(APIntOps::RoundingSDiv(
199LHS.Val.sext(Width),RHS.Val.sext(Width),APInt::Rounding::UP));
200}
201SlowDynamicAPIntdetail::floorDiv(constSlowDynamicAPInt &LHS,
202constSlowDynamicAPInt &RHS) {
203if (RHS == -1)
204return -LHS;
205unsigned Width =getMaxWidth(LHS.Val,RHS.Val);
206returnSlowDynamicAPInt(APIntOps::RoundingSDiv(
207LHS.Val.sext(Width),RHS.Val.sext(Width),APInt::Rounding::DOWN));
208}
209// The RHS is always expected to be positive, and the result
210/// is always non-negative.
211SlowDynamicAPIntdetail::mod(constSlowDynamicAPInt &LHS,
212constSlowDynamicAPInt &RHS) {
213assert(RHS >= 1 &&"mod is only supported for positive divisors!");
214returnLHS %RHS < 0 ?LHS %RHS +RHS :LHS %RHS;
215}
216
217SlowDynamicAPIntdetail::gcd(constSlowDynamicAPInt &A,
218constSlowDynamicAPInt &B) {
219assert(A >= 0 &&B >= 0 &&"operands must be non-negative!");
220unsigned Width =getMaxWidth(A.Val,B.Val);
221returnSlowDynamicAPInt(
222APIntOps::GreatestCommonDivisor(A.Val.sext(Width),B.Val.sext(Width)));
223}
224
225/// Returns the least common multiple of A and B.
226SlowDynamicAPIntdetail::lcm(constSlowDynamicAPInt &A,
227constSlowDynamicAPInt &B) {
228SlowDynamicAPIntX =abs(A);
229SlowDynamicAPIntY =abs(B);
230return (X *Y) /gcd(X,Y);
231}
232
233/// This operation cannot overflow.
234SlowDynamicAPIntSlowDynamicAPInt::operator%(constSlowDynamicAPInt &O) const{
235unsigned Width = std::max(Val.getBitWidth(), O.Val.getBitWidth());
236returnSlowDynamicAPInt(Val.sext(Width).srem(O.Val.sext(Width)));
237}
238
239SlowDynamicAPIntSlowDynamicAPInt::operator-() const{
240if (Val.isMinSignedValue()) {
241 /// Overflow only occurs when the value is the minimum possible value.
242APInt Ret = Val.sext(2 * Val.getBitWidth());
243returnSlowDynamicAPInt(-Ret);
244 }
245returnSlowDynamicAPInt(-Val);
246}
247
248/// ---------------------------------------------------------------------------
249/// Assignment operators, preincrement, predecrement.
250/// ---------------------------------------------------------------------------
251SlowDynamicAPInt &SlowDynamicAPInt::operator+=(constSlowDynamicAPInt &O) {
252 *this = *this + O;
253return *this;
254}
255SlowDynamicAPInt &SlowDynamicAPInt::operator-=(constSlowDynamicAPInt &O) {
256 *this = *this - O;
257return *this;
258}
259SlowDynamicAPInt &SlowDynamicAPInt::operator*=(constSlowDynamicAPInt &O) {
260 *this = *this * O;
261return *this;
262}
263SlowDynamicAPInt &SlowDynamicAPInt::operator/=(constSlowDynamicAPInt &O) {
264 *this = *this / O;
265return *this;
266}
267SlowDynamicAPInt &SlowDynamicAPInt::operator%=(constSlowDynamicAPInt &O) {
268 *this = *this % O;
269return *this;
270}
271SlowDynamicAPInt &SlowDynamicAPInt::operator++() {
272 *this += 1;
273return *this;
274}
275
276SlowDynamicAPInt &SlowDynamicAPInt::operator--() {
277 *this -= 1;
278return *this;
279}
280
281/// ---------------------------------------------------------------------------
282/// Printing.
283/// ---------------------------------------------------------------------------
284voidSlowDynamicAPInt::print(raw_ostream &OS) const{OS << Val; }
285
286voidSlowDynamicAPInt::dump() const{print(dbgs()); }
true
basic Basic Alias true
Definition:BasicAliasAnalysis.cpp:1981
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
A
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
Debug.h
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
Hashing.h
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
OS
raw_pwrite_stream & OS
Definition:SampleProfWriter.cpp:51
runOpWithExpandOnOverflow
APInt runOpWithExpandOnOverflow(const APInt &A, const APInt &B, function_ref< APInt(const APInt &, const APInt &, bool &Overflow)> Op)
Bring a and b to have the same width and then call op(a, b, overflow).
Definition:SlowDynamicAPInt.cpp:159
getMaxWidth
static unsigned getMaxWidth(const APInt &A, const APInt &B)
Definition:SlowDynamicAPInt.cpp:117
SlowDynamicAPInt.h
RHS
Value * RHS
Definition:X86PartialReduction.cpp:74
LHS
Value * LHS
Definition:X86PartialReduction.cpp:73
llvm::APInt
Class for arbitrary precision integers.
Definition:APInt.h:78
llvm::APInt::isMinSignedValue
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition:APInt.h:423
llvm::APInt::Rounding::DOWN
@ DOWN
llvm::APInt::Rounding::UP
@ UP
llvm::APInt::sgt
bool sgt(const APInt &RHS) const
Signed greater than comparison.
Definition:APInt.h:1201
llvm::APInt::getBitWidth
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition:APInt.h:1468
llvm::APInt::sadd_ov
APInt sadd_ov(const APInt &RHS, bool &Overflow) const
Definition:APInt.cpp:1902
llvm::APInt::sle
bool sle(const APInt &RHS) const
Signed less or equal comparison.
Definition:APInt.h:1166
llvm::APInt::sdiv_ov
APInt sdiv_ov(const APInt &RHS, bool &Overflow) const
Definition:APInt.cpp:1928
llvm::APInt::srem
APInt srem(const APInt &RHS) const
Function for signed remainder operation.
Definition:APInt.cpp:1710
llvm::APInt::smul_ov
APInt smul_ov(const APInt &RHS, bool &Overflow) const
Definition:APInt.cpp:1934
llvm::APInt::sext
APInt sext(unsigned width) const
Sign extend to a new width.
Definition:APInt.cpp:959
llvm::APInt::slt
bool slt(const APInt &RHS) const
Signed less than comparison.
Definition:APInt.h:1130
llvm::APInt::sge
bool sge(const APInt &RHS) const
Signed greater or equal comparison.
Definition:APInt.h:1237
llvm::APInt::ssub_ov
APInt ssub_ov(const APInt &RHS, bool &Overflow) const
Definition:APInt.cpp:1915
llvm::DWARFExpression::Operation
This class represents an Operation in the Expression.
Definition:DWARFExpression.h:32
llvm::detail::SlowDynamicAPInt
A simple class providing dynamic arbitrary-precision arithmetic.
Definition:SlowDynamicAPInt.h:34
llvm::detail::SlowDynamicAPInt::print
void print(raw_ostream &OS) const
Definition:SlowDynamicAPInt.cpp:284
llvm::detail::SlowDynamicAPInt::SlowDynamicAPInt
SlowDynamicAPInt()
Definition:SlowDynamicAPInt.cpp:19
llvm::detail::SlowDynamicAPInt::operator%
SlowDynamicAPInt operator%(const SlowDynamicAPInt &O) const
This operation cannot overflow.
Definition:SlowDynamicAPInt.cpp:234
llvm::detail::SlowDynamicAPInt::operator*
SlowDynamicAPInt operator*(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:182
llvm::detail::SlowDynamicAPInt::operator+=
SlowDynamicAPInt & operator+=(const SlowDynamicAPInt &O)
Definition:SlowDynamicAPInt.cpp:251
llvm::detail::SlowDynamicAPInt::operator--
SlowDynamicAPInt & operator--()
Definition:SlowDynamicAPInt.cpp:276
llvm::detail::SlowDynamicAPInt::dump
LLVM_DUMP_METHOD void dump() const
Definition:SlowDynamicAPInt.cpp:286
llvm::detail::SlowDynamicAPInt::operator<=
bool operator<=(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:142
llvm::detail::SlowDynamicAPInt::operator-=
SlowDynamicAPInt & operator-=(const SlowDynamicAPInt &O)
Definition:SlowDynamicAPInt.cpp:255
llvm::detail::SlowDynamicAPInt::operator*=
SlowDynamicAPInt & operator*=(const SlowDynamicAPInt &O)
Definition:SlowDynamicAPInt.cpp:259
llvm::detail::SlowDynamicAPInt::operator=
SlowDynamicAPInt & operator=(int64_t Val)
Definition:SlowDynamicAPInt.cpp:21
llvm::detail::SlowDynamicAPInt::operator++
SlowDynamicAPInt & operator++()
Definition:SlowDynamicAPInt.cpp:271
llvm::detail::SlowDynamicAPInt::operator-
SlowDynamicAPInt operator-() const
Definition:SlowDynamicAPInt.cpp:239
llvm::detail::SlowDynamicAPInt::operator!=
bool operator!=(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:130
llvm::detail::SlowDynamicAPInt::operator>
bool operator>(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:134
llvm::detail::SlowDynamicAPInt::operator==
bool operator==(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:126
llvm::detail::SlowDynamicAPInt::operator/
SlowDynamicAPInt operator/(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:186
llvm::detail::SlowDynamicAPInt::operator/=
SlowDynamicAPInt & operator/=(const SlowDynamicAPInt &O)
Definition:SlowDynamicAPInt.cpp:263
llvm::detail::SlowDynamicAPInt::operator%=
SlowDynamicAPInt & operator%=(const SlowDynamicAPInt &O)
Definition:SlowDynamicAPInt.cpp:267
llvm::detail::SlowDynamicAPInt::operator<
bool operator<(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:138
llvm::detail::SlowDynamicAPInt::operator>=
bool operator>=(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:146
llvm::detail::SlowDynamicAPInt::operator+
SlowDynamicAPInt operator+(const SlowDynamicAPInt &O) const
Definition:SlowDynamicAPInt.cpp:174
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition:STLFunctionalExtras.h:37
llvm::hash_code
An opaque object representing a hash code.
Definition:Hashing.h:75
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition:raw_ostream.h:52
detail
Definition:ClauseT.h:112
llvm::APIntOps::RoundingSDiv
APInt RoundingSDiv(const APInt &A, const APInt &B, APInt::Rounding RM)
Return A sign-divided by B, rounded by the given rounding mode.
Definition:APInt.cpp:2754
llvm::APIntOps::GreatestCommonDivisor
APInt GreatestCommonDivisor(APInt A, APInt B)
Compute GCD of two unsigned APInt values.
Definition:APInt.cpp:771
llvm::detail::abs
SlowDynamicAPInt abs(const SlowDynamicAPInt &X)
Redeclarations of friend declarations above to make it discoverable by lookups.
Definition:SlowDynamicAPInt.cpp:190
llvm::detail::operator>=
bool operator>=(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:64
llvm::detail::ceilDiv
SlowDynamicAPInt ceilDiv(const SlowDynamicAPInt &LHS, const SlowDynamicAPInt &RHS)
Definition:SlowDynamicAPInt.cpp:193
llvm::detail::operator/
SlowDynamicAPInt operator/(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:76
llvm::detail::operator+
SlowDynamicAPInt operator+(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:67
llvm::detail::hash_value
hash_code hash_value(const IEEEFloat &Arg)
Definition:APFloat.cpp:3493
llvm::detail::operator-
SlowDynamicAPInt operator-(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:70
llvm::detail::operator!=
bool operator!=(const DenseSetImpl< ValueT, MapTy, ValueInfoT > &LHS, const DenseSetImpl< ValueT, MapTy, ValueInfoT > &RHS)
Inequality comparison for DenseSet.
Definition:DenseSet.h:265
llvm::detail::gcd
SlowDynamicAPInt gcd(const SlowDynamicAPInt &A, const SlowDynamicAPInt &B)
Definition:SlowDynamicAPInt.cpp:217
llvm::detail::floorDiv
SlowDynamicAPInt floorDiv(const SlowDynamicAPInt &LHS, const SlowDynamicAPInt &RHS)
Definition:SlowDynamicAPInt.cpp:201
llvm::detail::operator>
bool operator>(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:55
llvm::detail::operator+=
SlowDynamicAPInt & operator+=(SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:33
llvm::detail::operator%
SlowDynamicAPInt operator%(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:79
llvm::detail::operator*
SlowDynamicAPInt operator*(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:73
llvm::detail::operator<=
bool operator<=(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:61
llvm::detail::operator/=
SlowDynamicAPInt & operator/=(SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:42
llvm::detail::lcm
SlowDynamicAPInt lcm(const SlowDynamicAPInt &A, const SlowDynamicAPInt &B)
Returns the least common multiple of A and B.
Definition:SlowDynamicAPInt.cpp:226
llvm::detail::operator==
bool operator==(const DenseSetImpl< ValueT, MapTy, ValueInfoT > &LHS, const DenseSetImpl< ValueT, MapTy, ValueInfoT > &RHS)
Equality comparison for DenseSet.
Definition:DenseSet.h:249
llvm::detail::mod
SlowDynamicAPInt mod(const SlowDynamicAPInt &LHS, const SlowDynamicAPInt &RHS)
Returns the remainder of dividing LHS by RHS.
Definition:SlowDynamicAPInt.cpp:211
llvm::detail::operator*=
SlowDynamicAPInt & operator*=(SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:39
llvm::detail::operator<
bool operator<(const SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:58
llvm::detail::operator-=
SlowDynamicAPInt & operator-=(SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:36
llvm::detail::operator%=
SlowDynamicAPInt & operator%=(SlowDynamicAPInt &A, int64_t B)
Definition:SlowDynamicAPInt.cpp:45
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition:AddressRanges.h:18
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition:Debug.cpp:163
llvm::Op
DWARFExpression::Operation Op
Definition:DWARFExpression.cpp:22
raw_ostream.h
Generated on Fri Jul 18 2025 12:55:07 for LLVM by doxygen 1.9.6
[8]ページ先頭
©2009-2025 Movatter.jp