LLVM  16.0.0git
FixedPointBuilder.h
Go to the documentation of this file.
1 //===- llvm/FixedPointBuilder.h - Builder for fixed-point ops ---*- 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 defines the FixedPointBuilder class, which is used as a convenient
10 // way to lower fixed-point arithmetic operations to LLVM IR.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_IR_FIXEDPOINTBUILDER_H
15 #define LLVM_IR_FIXEDPOINTBUILDER_H
16 
17 #include "llvm/ADT/APFixedPoint.h"
18 #include "llvm/IR/Constant.h"
19 #include "llvm/IR/Constants.h"
20 #include "llvm/IR/IRBuilder.h"
21 #include "llvm/IR/InstrTypes.h"
22 #include "llvm/IR/Instruction.h"
23 #include "llvm/IR/IntrinsicInst.h"
24 #include "llvm/IR/Intrinsics.h"
25 #include "llvm/IR/Type.h"
26 #include "llvm/IR/Value.h"
27 
28 #include <cmath>
29 
30 namespace llvm {
31 
32 template <class IRBuilderTy> class FixedPointBuilder {
33  IRBuilderTy &B;
34 
35  Value *Convert(Value *Src, const FixedPointSemantics &SrcSema,
36  const FixedPointSemantics &DstSema, bool DstIsInteger) {
37  unsigned SrcWidth = SrcSema.getWidth();
38  unsigned DstWidth = DstSema.getWidth();
39  unsigned SrcScale = SrcSema.getScale();
40  unsigned DstScale = DstSema.getScale();
41  bool SrcIsSigned = SrcSema.isSigned();
42  bool DstIsSigned = DstSema.isSigned();
43 
44  Type *DstIntTy = B.getIntNTy(DstWidth);
45 
46  Value *Result = Src;
47  unsigned ResultWidth = SrcWidth;
48 
49  // Downscale.
50  if (DstScale < SrcScale) {
51  // When converting to integers, we round towards zero. For negative
52  // numbers, right shifting rounds towards negative infinity. In this case,
53  // we can just round up before shifting.
54  if (DstIsInteger && SrcIsSigned) {
55  Value *Zero = Constant::getNullValue(Result->getType());
56  Value *IsNegative = B.CreateICmpSLT(Result, Zero);
57  Value *LowBits = ConstantInt::get(
58  B.getContext(), APInt::getLowBitsSet(ResultWidth, SrcScale));
59  Value *Rounded = B.CreateAdd(Result, LowBits);
60  Result = B.CreateSelect(IsNegative, Rounded, Result);
61  }
62 
63  Result = SrcIsSigned
64  ? B.CreateAShr(Result, SrcScale - DstScale, "downscale")
65  : B.CreateLShr(Result, SrcScale - DstScale, "downscale");
66  }
67 
68  if (!DstSema.isSaturated()) {
69  // Resize.
70  Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
71 
72  // Upscale.
73  if (DstScale > SrcScale)
74  Result = B.CreateShl(Result, DstScale - SrcScale, "upscale");
75  } else {
76  // Adjust the number of fractional bits.
77  if (DstScale > SrcScale) {
78  // Compare to DstWidth to prevent resizing twice.
79  ResultWidth = std::max(SrcWidth + DstScale - SrcScale, DstWidth);
80  Type *UpscaledTy = B.getIntNTy(ResultWidth);
81  Result = B.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize");
82  Result = B.CreateShl(Result, DstScale - SrcScale, "upscale");
83  }
84 
85  // Handle saturation.
86  bool LessIntBits = DstSema.getIntegralBits() < SrcSema.getIntegralBits();
87  if (LessIntBits) {
88  Value *Max = ConstantInt::get(
89  B.getContext(),
90  APFixedPoint::getMax(DstSema).getValue().extOrTrunc(ResultWidth));
91  Value *TooHigh = SrcIsSigned ? B.CreateICmpSGT(Result, Max)
92  : B.CreateICmpUGT(Result, Max);
93  Result = B.CreateSelect(TooHigh, Max, Result, "satmax");
94  }
95  // Cannot overflow min to dest type if src is unsigned since all fixed
96  // point types can cover the unsigned min of 0.
97  if (SrcIsSigned && (LessIntBits || !DstIsSigned)) {
98  Value *Min = ConstantInt::get(
99  B.getContext(),
100  APFixedPoint::getMin(DstSema).getValue().extOrTrunc(ResultWidth));
101  Value *TooLow = B.CreateICmpSLT(Result, Min);
102  Result = B.CreateSelect(TooLow, Min, Result, "satmin");
103  }
104 
105  // Resize the integer part to get the final destination size.
106  if (ResultWidth != DstWidth)
107  Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
108  }
109  return Result;
110  }
111 
112  /// Get the common semantic for two semantics, with the added imposition that
113  /// saturated padded types retain the padding bit.
115  getCommonBinopSemantic(const FixedPointSemantics &LHSSema,
116  const FixedPointSemantics &RHSSema) {
117  auto C = LHSSema.getCommonSemantics(RHSSema);
118  bool BothPadded =
119  LHSSema.hasUnsignedPadding() && RHSSema.hasUnsignedPadding();
120  return FixedPointSemantics(
121  C.getWidth() + (unsigned)(BothPadded && C.isSaturated()), C.getScale(),
122  C.isSigned(), C.isSaturated(), BothPadded);
123  }
124 
125  /// Given a floating point type and a fixed-point semantic, return a floating
126  /// point type which can accommodate the fixed-point semantic. This is either
127  /// \p Ty, or a floating point type with a larger exponent than Ty.
128  Type *getAccommodatingFloatType(Type *Ty, const FixedPointSemantics &Sema) {
129  const fltSemantics *FloatSema = &Ty->getFltSemantics();
130  while (!Sema.fitsInFloatSemantics(*FloatSema))
131  FloatSema = APFixedPoint::promoteFloatSemantics(FloatSema);
132  return Type::getFloatingPointTy(Ty->getContext(), *FloatSema);
133  }
134 
135 public:
136  FixedPointBuilder(IRBuilderTy &Builder) : B(Builder) {}
137 
138  /// Convert an integer value representing a fixed-point number from one
139  /// fixed-point semantic to another fixed-point semantic.
140  /// \p Src - The source value
141  /// \p SrcSema - The fixed-point semantic of the source value
142  /// \p DstSema - The resulting fixed-point semantic
144  const FixedPointSemantics &DstSema) {
145  return Convert(Src, SrcSema, DstSema, false);
146  }
147 
148  /// Convert an integer value representing a fixed-point number to an integer
149  /// with the given bit width and signedness.
150  /// \p Src - The source value
151  /// \p SrcSema - The fixed-point semantic of the source value
152  /// \p DstWidth - The bit width of the result value
153  /// \p DstIsSigned - The signedness of the result value
155  unsigned DstWidth, bool DstIsSigned) {
156  return Convert(
157  Src, SrcSema,
158  FixedPointSemantics::GetIntegerSemantics(DstWidth, DstIsSigned), true);
159  }
160 
161  /// Convert an integer value with the given signedness to an integer value
162  /// representing the given fixed-point semantic.
163  /// \p Src - The source value
164  /// \p SrcIsSigned - The signedness of the source value
165  /// \p DstSema - The resulting fixed-point semantic
166  Value *CreateIntegerToFixed(Value *Src, unsigned SrcIsSigned,
167  const FixedPointSemantics &DstSema) {
168  return Convert(Src,
170  Src->getType()->getScalarSizeInBits(), SrcIsSigned),
171  DstSema, false);
172  }
173 
175  Type *DstTy) {
176  Value *Result;
177  Type *OpTy = getAccommodatingFloatType(DstTy, SrcSema);
178  // Convert the raw fixed-point value directly to floating point. If the
179  // value is too large to fit, it will be rounded, not truncated.
180  Result = SrcSema.isSigned() ? B.CreateSIToFP(Src, OpTy)
181  : B.CreateUIToFP(Src, OpTy);
182  // Rescale the integral-in-floating point by the scaling factor. This is
183  // lossless, except for overflow to infinity which is unlikely.
184  Result = B.CreateFMul(Result,
185  ConstantFP::get(OpTy, std::pow(2, -(int)SrcSema.getScale())));
186  if (OpTy != DstTy)
187  Result = B.CreateFPTrunc(Result, DstTy);
188  return Result;
189  }
190 
192  bool UseSigned = DstSema.isSigned() || DstSema.hasUnsignedPadding();
193  Value *Result = Src;
194  Type *OpTy = getAccommodatingFloatType(Src->getType(), DstSema);
195  if (OpTy != Src->getType())
196  Result = B.CreateFPExt(Result, OpTy);
197  // Rescale the floating point value so that its significant bits (for the
198  // purposes of the conversion) are in the integral range.
199  Result = B.CreateFMul(Result,
200  ConstantFP::get(OpTy, std::pow(2, DstSema.getScale())));
201 
202  Type *ResultTy = B.getIntNTy(DstSema.getWidth());
203  if (DstSema.isSaturated()) {
204  Intrinsic::ID IID =
205  UseSigned ? Intrinsic::fptosi_sat : Intrinsic::fptoui_sat;
206  Result = B.CreateIntrinsic(IID, {ResultTy, OpTy}, {Result});
207  } else {
208  Result = UseSigned ? B.CreateFPToSI(Result, ResultTy)
209  : B.CreateFPToUI(Result, ResultTy);
210  }
211 
212  // When saturating unsigned-with-padding using signed operations, we may
213  // get negative values. Emit an extra clamp to zero.
214  if (DstSema.isSaturated() && DstSema.hasUnsignedPadding()) {
215  Constant *Zero = Constant::getNullValue(Result->getType());
216  Result =
217  B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin");
218  }
219 
220  return Result;
221  }
222 
223  /// Add two fixed-point values and return the result in their common semantic.
224  /// \p LHS - The left hand side
225  /// \p LHSSema - The semantic of the left hand side
226  /// \p RHS - The right hand side
227  /// \p RHSSema - The semantic of the right hand side
229  Value *RHS, const FixedPointSemantics &RHSSema) {
230  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
231  bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
232 
233  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
234  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
235 
236  Value *Result;
237  if (CommonSema.isSaturated()) {
238  Intrinsic::ID IID = UseSigned ? Intrinsic::sadd_sat : Intrinsic::uadd_sat;
239  Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS);
240  } else {
241  Result = B.CreateAdd(WideLHS, WideRHS);
242  }
243 
244  return CreateFixedToFixed(Result, CommonSema,
245  LHSSema.getCommonSemantics(RHSSema));
246  }
247 
248  /// Subtract two fixed-point values and return the result in their common
249  /// semantic.
250  /// \p LHS - The left hand side
251  /// \p LHSSema - The semantic of the left hand side
252  /// \p RHS - The right hand side
253  /// \p RHSSema - The semantic of the right hand side
255  Value *RHS, const FixedPointSemantics &RHSSema) {
256  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
257  bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
258 
259  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
260  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
261 
262  Value *Result;
263  if (CommonSema.isSaturated()) {
264  Intrinsic::ID IID = UseSigned ? Intrinsic::ssub_sat : Intrinsic::usub_sat;
265  Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS);
266  } else {
267  Result = B.CreateSub(WideLHS, WideRHS);
268  }
269 
270  // Subtraction can end up below 0 for padded unsigned operations, so emit
271  // an extra clamp in that case.
272  if (CommonSema.isSaturated() && CommonSema.hasUnsignedPadding()) {
273  Constant *Zero = Constant::getNullValue(Result->getType());
274  Result =
275  B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin");
276  }
277 
278  return CreateFixedToFixed(Result, CommonSema,
279  LHSSema.getCommonSemantics(RHSSema));
280  }
281 
282  /// Multiply two fixed-point values and return the result in their common
283  /// semantic.
284  /// \p LHS - The left hand side
285  /// \p LHSSema - The semantic of the left hand side
286  /// \p RHS - The right hand side
287  /// \p RHSSema - The semantic of the right hand side
289  Value *RHS, const FixedPointSemantics &RHSSema) {
290  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
291  bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
292 
293  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
294  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
295 
296  Intrinsic::ID IID;
297  if (CommonSema.isSaturated()) {
298  IID = UseSigned ? Intrinsic::smul_fix_sat : Intrinsic::umul_fix_sat;
299  } else {
300  IID = UseSigned ? Intrinsic::smul_fix : Intrinsic::umul_fix;
301  }
302  Value *Result = B.CreateIntrinsic(
303  IID, {WideLHS->getType()},
304  {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())});
305 
306  return CreateFixedToFixed(Result, CommonSema,
307  LHSSema.getCommonSemantics(RHSSema));
308  }
309 
310  /// Divide two fixed-point values and return the result in their common
311  /// semantic.
312  /// \p LHS - The left hand side
313  /// \p LHSSema - The semantic of the left hand side
314  /// \p RHS - The right hand side
315  /// \p RHSSema - The semantic of the right hand side
317  Value *RHS, const FixedPointSemantics &RHSSema) {
318  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
319  bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
320 
321  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
322  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
323 
324  Intrinsic::ID IID;
325  if (CommonSema.isSaturated()) {
326  IID = UseSigned ? Intrinsic::sdiv_fix_sat : Intrinsic::udiv_fix_sat;
327  } else {
328  IID = UseSigned ? Intrinsic::sdiv_fix : Intrinsic::udiv_fix;
329  }
330  Value *Result = B.CreateIntrinsic(
331  IID, {WideLHS->getType()},
332  {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())});
333 
334  return CreateFixedToFixed(Result, CommonSema,
335  LHSSema.getCommonSemantics(RHSSema));
336  }
337 
338  /// Left shift a fixed-point value by an unsigned integer value. The integer
339  /// value can be any bit width.
340  /// \p LHS - The left hand side
341  /// \p LHSSema - The semantic of the left hand side
342  /// \p RHS - The right hand side
344  bool UseSigned = LHSSema.isSigned() || LHSSema.hasUnsignedPadding();
345 
346  RHS = B.CreateIntCast(RHS, LHS->getType(), /*IsSigned=*/false);
347 
348  Value *Result;
349  if (LHSSema.isSaturated()) {
350  Intrinsic::ID IID = UseSigned ? Intrinsic::sshl_sat : Intrinsic::ushl_sat;
351  Result = B.CreateBinaryIntrinsic(IID, LHS, RHS);
352  } else {
353  Result = B.CreateShl(LHS, RHS);
354  }
355 
356  return Result;
357  }
358 
359  /// Right shift a fixed-point value by an unsigned integer value. The integer
360  /// value can be any bit width.
361  /// \p LHS - The left hand side
362  /// \p LHSSema - The semantic of the left hand side
363  /// \p RHS - The right hand side
365  RHS = B.CreateIntCast(RHS, LHS->getType(), false);
366 
367  return LHSSema.isSigned() ? B.CreateAShr(LHS, RHS) : B.CreateLShr(LHS, RHS);
368  }
369 
370  /// Compare two fixed-point values for equality.
371  /// \p LHS - The left hand side
372  /// \p LHSSema - The semantic of the left hand side
373  /// \p RHS - The right hand side
374  /// \p RHSSema - The semantic of the right hand side
376  Value *RHS, const FixedPointSemantics &RHSSema) {
377  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
378 
379  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
380  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
381 
382  return B.CreateICmpEQ(WideLHS, WideRHS);
383  }
384 
385  /// Compare two fixed-point values for inequality.
386  /// \p LHS - The left hand side
387  /// \p LHSSema - The semantic of the left hand side
388  /// \p RHS - The right hand side
389  /// \p RHSSema - The semantic of the right hand side
391  Value *RHS, const FixedPointSemantics &RHSSema) {
392  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
393 
394  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
395  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
396 
397  return B.CreateICmpNE(WideLHS, WideRHS);
398  }
399 
400  /// Compare two fixed-point values as LHS < RHS.
401  /// \p LHS - The left hand side
402  /// \p LHSSema - The semantic of the left hand side
403  /// \p RHS - The right hand side
404  /// \p RHSSema - The semantic of the right hand side
406  Value *RHS, const FixedPointSemantics &RHSSema) {
407  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
408 
409  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
410  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
411 
412  return CommonSema.isSigned() ? B.CreateICmpSLT(WideLHS, WideRHS)
413  : B.CreateICmpULT(WideLHS, WideRHS);
414  }
415 
416  /// Compare two fixed-point values as LHS <= RHS.
417  /// \p LHS - The left hand side
418  /// \p LHSSema - The semantic of the left hand side
419  /// \p RHS - The right hand side
420  /// \p RHSSema - The semantic of the right hand side
422  Value *RHS, const FixedPointSemantics &RHSSema) {
423  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
424 
425  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
426  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
427 
428  return CommonSema.isSigned() ? B.CreateICmpSLE(WideLHS, WideRHS)
429  : B.CreateICmpULE(WideLHS, WideRHS);
430  }
431 
432  /// Compare two fixed-point values as LHS > RHS.
433  /// \p LHS - The left hand side
434  /// \p LHSSema - The semantic of the left hand side
435  /// \p RHS - The right hand side
436  /// \p RHSSema - The semantic of the right hand side
438  Value *RHS, const FixedPointSemantics &RHSSema) {
439  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
440 
441  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
442  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
443 
444  return CommonSema.isSigned() ? B.CreateICmpSGT(WideLHS, WideRHS)
445  : B.CreateICmpUGT(WideLHS, WideRHS);
446  }
447 
448  /// Compare two fixed-point values as LHS >= RHS.
449  /// \p LHS - The left hand side
450  /// \p LHSSema - The semantic of the left hand side
451  /// \p RHS - The right hand side
452  /// \p RHSSema - The semantic of the right hand side
454  Value *RHS, const FixedPointSemantics &RHSSema) {
455  auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
456 
457  Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
458  Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
459 
460  return CommonSema.isSigned() ? B.CreateICmpSGE(WideLHS, WideRHS)
461  : B.CreateICmpUGE(WideLHS, WideRHS);
462  }
463 };
464 
465 } // end namespace llvm
466 
467 #endif // LLVM_IR_FIXEDPOINTBUILDER_H
llvm::APFixedPoint::getValue
APSInt getValue() const
Definition: APFixedPoint.h:167
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::FixedPointBuilder::CreateMul
Value * CreateMul(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Multiply two fixed-point values and return the result in their common semantic.
Definition: FixedPointBuilder.h:288
IntrinsicInst.h
llvm::FixedPointBuilder::FixedPointBuilder
FixedPointBuilder(IRBuilderTy &Builder)
Definition: FixedPointBuilder.h:136
llvm::FixedPointBuilder::CreateNE
Value * CreateNE(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Compare two fixed-point values for inequality.
Definition: FixedPointBuilder.h:390
llvm::FixedPointSemantics::getScale
unsigned getScale() const
Definition: APFixedPoint.h:62
llvm::FixedPointSemantics::getIntegralBits
unsigned getIntegralBits() const
Return the number of integral bits represented by these semantics.
Definition: APFixedPoint.h:79
llvm::Type::getFltSemantics
const fltSemantics & getFltSemantics() const
Definition: Type.cpp:67
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::FixedPointBuilder::CreateEQ
Value * CreateEQ(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Compare two fixed-point values for equality.
Definition: FixedPointBuilder.h:375
llvm::FixedPointBuilder::CreateGE
Value * CreateGE(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Compare two fixed-point values as LHS >= RHS.
Definition: FixedPointBuilder.h:453
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::FixedPointSemantics::getCommonSemantics
FixedPointSemantics getCommonSemantics(const FixedPointSemantics &Other) const
Return the FixedPointSemantics that allows for calculating the full precision semantic that can preci...
Definition: APFixedPoint.cpp:155
llvm::FixedPointBuilder::CreateDiv
Value * CreateDiv(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Divide two fixed-point values and return the result in their common semantic.
Definition: FixedPointBuilder.h:316
llvm::FixedPointBuilder::CreateAdd
Value * CreateAdd(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Add two fixed-point values and return the result in their common semantic.
Definition: FixedPointBuilder.h:228
llvm::FixedPointSemantics::hasUnsignedPadding
bool hasUnsignedPadding() const
Definition: APFixedPoint.h:69
Instruction.h
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
Constants.h
llvm::FixedPointBuilder::CreateShr
Value * CreateShr(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS)
Right shift a fixed-point value by an unsigned integer value.
Definition: FixedPointBuilder.h:364
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
InstrTypes.h
llvm::FixedPointBuilder::CreateIntegerToFixed
Value * CreateIntegerToFixed(Value *Src, unsigned SrcIsSigned, const FixedPointSemantics &DstSema)
Convert an integer value with the given signedness to an integer value representing the given fixed-p...
Definition: FixedPointBuilder.h:166
llvm::FixedPointBuilder::CreateLE
Value * CreateLE(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Compare two fixed-point values as LHS <= RHS.
Definition: FixedPointBuilder.h:421
llvm::FixedPointSemantics
The fixed point semantics work similarly to fltSemantics.
Definition: APFixedPoint.h:34
llvm::APFixedPoint::getMax
static APFixedPoint getMax(const FixedPointSemantics &Sema)
Definition: APFixedPoint.cpp:119
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:879
llvm::APFixedPoint::getMin
static APFixedPoint getMin(const FixedPointSemantics &Sema)
Definition: APFixedPoint.cpp:127
llvm::FixedPointSemantics::isSaturated
bool isSaturated() const
Definition: APFixedPoint.h:68
Type.h
llvm::FixedPointBuilder::CreateFloatingToFixed
Value * CreateFloatingToFixed(Value *Src, const FixedPointSemantics &DstSema)
Definition: FixedPointBuilder.h:191
llvm::FixedPointSemantics::isSigned
bool isSigned() const
Definition: APFixedPoint.h:67
llvm::FixedPointSemantics::getWidth
unsigned getWidth() const
Definition: APFixedPoint.h:61
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::FixedPointSemantics::GetIntegerSemantics
static FixedPointSemantics GetIntegerSemantics(unsigned Width, bool IsSigned)
Return the FixedPointSemantics for an integer type.
Definition: APFixedPoint.h:103
IRBuilder.h
B
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional ldr LCPI1_0 ldr ldr tst movne lsr ldr LCPI1_1 and r0 bx lr it saves an instruction and a register It might be profitable to cse MOVi16 if there are lots of bit immediates with the same bottom half Robert Muth started working on an alternate jump table implementation that does not put the tables in line in the text This is more like the llvm default jump table implementation This might be useful sometime Several revisions of patches are on the mailing beginning while CMP sets them like a subtract Therefore to be able to use CMN for comparisons other than the Z we ll need additional logic to reverse the conditionals associated with the comparison Perhaps a pseudo instruction for the with a post codegen pass to clean up and handle the condition codes See PR5694 for testcase Given the following on int B
Definition: README.txt:592
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::FixedPointBuilder::CreateFixedToInteger
Value * CreateFixedToInteger(Value *Src, const FixedPointSemantics &SrcSema, unsigned DstWidth, bool DstIsSigned)
Convert an integer value representing a fixed-point number to an integer with the given bit width and...
Definition: FixedPointBuilder.h:154
llvm::FixedPointBuilder
Definition: FixedPointBuilder.h:32
llvm::FixedPointSemantics::fitsInFloatSemantics
bool fitsInFloatSemantics(const fltSemantics &FloatSema) const
Returns true if this fixed-point semantic with its value bits interpreted as an integer can fit in th...
Definition: APFixedPoint.cpp:132
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::FixedPointBuilder::CreateFixedToFixed
Value * CreateFixedToFixed(Value *Src, const FixedPointSemantics &SrcSema, const FixedPointSemantics &DstSema)
Convert an integer value representing a fixed-point number from one fixed-point semantic to another f...
Definition: FixedPointBuilder.h:143
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
APFixedPoint.h
llvm::APSInt::extOrTrunc
APSInt extOrTrunc(uint32_t width) const
Definition: APSInt.h:105
llvm::FixedPointBuilder::CreateGT
Value * CreateGT(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Compare two fixed-point values as LHS > RHS.
Definition: FixedPointBuilder.h:437
Constant.h
llvm::Constant::getNullValue
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:350
llvm::ConstantFP::get
static Constant * get(Type *Ty, double V)
This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in...
Definition: Constants.cpp:926
llvm::fltSemantics
Definition: APFloat.cpp:71
llvm::FixedPointBuilder::CreateSub
Value * CreateSub(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Subtract two fixed-point values and return the result in their common semantic.
Definition: FixedPointBuilder.h:254
llvm::APFixedPoint::promoteFloatSemantics
static const fltSemantics * promoteFloatSemantics(const fltSemantics *S)
Given a floating point semantic, return the next floating point semantic with a larger exponent and l...
Definition: APFixedPoint.cpp:475
llvm::FixedPointBuilder::CreateShl
Value * CreateShl(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS)
Left shift a fixed-point value by an unsigned integer value.
Definition: FixedPointBuilder.h:343
llvm::APInt::getLowBitsSet
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Constructs an APInt value that has the bottom loBitsSet bits set.
Definition: APInt.h:289
llvm::FixedPointBuilder::CreateFixedToFloating
Value * CreateFixedToFloating(Value *Src, const FixedPointSemantics &SrcSema, Type *DstTy)
Definition: FixedPointBuilder.h:174
Value.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::Type::getFloatingPointTy
static Type * getFloatingPointTy(LLVMContext &C, const fltSemantics &S)
Definition: Type.cpp:84
llvm::FixedPointBuilder::CreateLT
Value * CreateLT(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS, const FixedPointSemantics &RHSSema)
Compare two fixed-point values as LHS < RHS.
Definition: FixedPointBuilder.h:405
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:39