Restoring authorship annotation for <shadchin@yandex-team.ru>. Commit 2 of 2.

1 files changed, 476 insertions, 476 deletions

diff --git a/contrib/libs/llvm12/include/llvm/IR/FixedPointBuilder.h b/contrib/libs/llvm12/include/llvm/IR/FixedPointBuilder.h
index f457cd8817..1c4b0332d1 100644
--- a/contrib/libs/llvm12/include/llvm/IR/FixedPointBuilder.h
+++ b/contrib/libs/llvm12/include/llvm/IR/FixedPointBuilder.h
@@ -1,476 +1,476 @@
-#pragma once 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic push 
-#pragma GCC diagnostic ignored "-Wunused-parameter" 
-#endif 
- 
-//===- llvm/FixedPointBuilder.h - Builder for fixed-point ops ---*- C++ -*-===// 
-// 
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 
-// See https://llvm.org/LICENSE.txt for license information. 
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 
-// 
-//===----------------------------------------------------------------------===// 
-// 
-// This file defines the FixedPointBuilder class, which is used as a convenient 
-// way to lower fixed-point arithmetic operations to LLVM IR. 
-// 
-//===----------------------------------------------------------------------===// 
- 
-#ifndef LLVM_IR_FIXEDPOINTBUILDER_H 
-#define LLVM_IR_FIXEDPOINTBUILDER_H 
- 
-#include "llvm/ADT/APFixedPoint.h" 
-#include "llvm/IR/Constant.h" 
-#include "llvm/IR/Constants.h" 
-#include "llvm/IR/IRBuilder.h" 
-#include "llvm/IR/InstrTypes.h" 
-#include "llvm/IR/Instruction.h" 
-#include "llvm/IR/IntrinsicInst.h" 
-#include "llvm/IR/Intrinsics.h" 
-#include "llvm/IR/Type.h" 
-#include "llvm/IR/Value.h" 
- 
-namespace llvm { 
- 
-template <class IRBuilderTy> class FixedPointBuilder { 
-  IRBuilderTy &B; 
- 
-  Value *Convert(Value *Src, const FixedPointSemantics &SrcSema, 
-                 const FixedPointSemantics &DstSema, bool DstIsInteger) { 
-    unsigned SrcWidth = SrcSema.getWidth(); 
-    unsigned DstWidth = DstSema.getWidth(); 
-    unsigned SrcScale = SrcSema.getScale(); 
-    unsigned DstScale = DstSema.getScale(); 
-    bool SrcIsSigned = SrcSema.isSigned(); 
-    bool DstIsSigned = DstSema.isSigned(); 
- 
-    Type *DstIntTy = B.getIntNTy(DstWidth); 
- 
-    Value *Result = Src; 
-    unsigned ResultWidth = SrcWidth; 
- 
-    // Downscale. 
-    if (DstScale < SrcScale) { 
-      // When converting to integers, we round towards zero. For negative 
-      // numbers, right shifting rounds towards negative infinity. In this case, 
-      // we can just round up before shifting. 
-      if (DstIsInteger && SrcIsSigned) { 
-        Value *Zero = Constant::getNullValue(Result->getType()); 
-        Value *IsNegative = B.CreateICmpSLT(Result, Zero); 
-        Value *LowBits = ConstantInt::get( 
-            B.getContext(), APInt::getLowBitsSet(ResultWidth, SrcScale)); 
-        Value *Rounded = B.CreateAdd(Result, LowBits); 
-        Result = B.CreateSelect(IsNegative, Rounded, Result); 
-      } 
- 
-      Result = SrcIsSigned 
-                   ? B.CreateAShr(Result, SrcScale - DstScale, "downscale") 
-                   : B.CreateLShr(Result, SrcScale - DstScale, "downscale"); 
-    } 
- 
-    if (!DstSema.isSaturated()) { 
-      // Resize. 
-      Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize"); 
- 
-      // Upscale. 
-      if (DstScale > SrcScale) 
-        Result = B.CreateShl(Result, DstScale - SrcScale, "upscale"); 
-    } else { 
-      // Adjust the number of fractional bits. 
-      if (DstScale > SrcScale) { 
-        // Compare to DstWidth to prevent resizing twice. 
-        ResultWidth = std::max(SrcWidth + DstScale - SrcScale, DstWidth); 
-        Type *UpscaledTy = B.getIntNTy(ResultWidth); 
-        Result = B.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize"); 
-        Result = B.CreateShl(Result, DstScale - SrcScale, "upscale"); 
-      } 
- 
-      // Handle saturation. 
-      bool LessIntBits = DstSema.getIntegralBits() < SrcSema.getIntegralBits(); 
-      if (LessIntBits) { 
-        Value *Max = ConstantInt::get( 
-            B.getContext(), 
-            APFixedPoint::getMax(DstSema).getValue().extOrTrunc(ResultWidth)); 
-        Value *TooHigh = SrcIsSigned ? B.CreateICmpSGT(Result, Max) 
-                                     : B.CreateICmpUGT(Result, Max); 
-        Result = B.CreateSelect(TooHigh, Max, Result, "satmax"); 
-      } 
-      // Cannot overflow min to dest type if src is unsigned since all fixed 
-      // point types can cover the unsigned min of 0. 
-      if (SrcIsSigned && (LessIntBits || !DstIsSigned)) { 
-        Value *Min = ConstantInt::get( 
-            B.getContext(), 
-            APFixedPoint::getMin(DstSema).getValue().extOrTrunc(ResultWidth)); 
-        Value *TooLow = B.CreateICmpSLT(Result, Min); 
-        Result = B.CreateSelect(TooLow, Min, Result, "satmin"); 
-      } 
- 
-      // Resize the integer part to get the final destination size. 
-      if (ResultWidth != DstWidth) 
-        Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize"); 
-    } 
-    return Result; 
-  } 
- 
-  /// Get the common semantic for two semantics, with the added imposition that 
-  /// saturated padded types retain the padding bit. 
-  FixedPointSemantics 
-  getCommonBinopSemantic(const FixedPointSemantics &LHSSema, 
-                         const FixedPointSemantics &RHSSema) { 
-    auto C = LHSSema.getCommonSemantics(RHSSema); 
-    bool BothPadded = 
-        LHSSema.hasUnsignedPadding() && RHSSema.hasUnsignedPadding(); 
-    return FixedPointSemantics( 
-        C.getWidth() + (unsigned)(BothPadded && C.isSaturated()), C.getScale(), 
-        C.isSigned(), C.isSaturated(), BothPadded); 
-  } 
- 
-  /// Given a floating point type and a fixed-point semantic, return a floating 
-  /// point type which can accommodate the fixed-point semantic. This is either 
-  /// \p Ty, or a floating point type with a larger exponent than Ty. 
-  Type *getAccommodatingFloatType(Type *Ty, const FixedPointSemantics &Sema) { 
-    const fltSemantics *FloatSema = &Ty->getFltSemantics(); 
-    while (!Sema.fitsInFloatSemantics(*FloatSema)) 
-      FloatSema = APFixedPoint::promoteFloatSemantics(FloatSema); 
-    return Type::getFloatingPointTy(Ty->getContext(), *FloatSema); 
-  } 
- 
-public: 
-  FixedPointBuilder(IRBuilderTy &Builder) : B(Builder) {} 
- 
-  /// Convert an integer value representing a fixed-point number from one 
-  /// fixed-point semantic to another fixed-point semantic. 
-  /// \p Src     - The source value 
-  /// \p SrcSema - The fixed-point semantic of the source value 
-  /// \p DstSema - The resulting fixed-point semantic 
-  Value *CreateFixedToFixed(Value *Src, const FixedPointSemantics &SrcSema, 
-                            const FixedPointSemantics &DstSema) { 
-    return Convert(Src, SrcSema, DstSema, false); 
-  } 
- 
-  /// Convert an integer value representing a fixed-point number to an integer 
-  /// with the given bit width and signedness. 
-  /// \p Src         - The source value 
-  /// \p SrcSema     - The fixed-point semantic of the source value 
-  /// \p DstWidth    - The bit width of the result value 
-  /// \p DstIsSigned - The signedness of the result value 
-  Value *CreateFixedToInteger(Value *Src, const FixedPointSemantics &SrcSema, 
-                              unsigned DstWidth, bool DstIsSigned) { 
-    return Convert( 
-        Src, SrcSema, 
-        FixedPointSemantics::GetIntegerSemantics(DstWidth, DstIsSigned), true); 
-  } 
- 
-  /// Convert an integer value with the given signedness to an integer value 
-  /// representing the given fixed-point semantic. 
-  /// \p Src         - The source value 
-  /// \p SrcIsSigned - The signedness of the source value 
-  /// \p DstSema     - The resulting fixed-point semantic 
-  Value *CreateIntegerToFixed(Value *Src, unsigned SrcIsSigned, 
-                              const FixedPointSemantics &DstSema) { 
-    return Convert(Src, 
-                   FixedPointSemantics::GetIntegerSemantics( 
-                       Src->getType()->getScalarSizeInBits(), SrcIsSigned), 
-                   DstSema, false); 
-  } 
- 
-  Value *CreateFixedToFloating(Value *Src, const FixedPointSemantics &SrcSema, 
-                               Type *DstTy) { 
-    Value *Result; 
-    Type *OpTy = getAccommodatingFloatType(DstTy, SrcSema); 
-    // Convert the raw fixed-point value directly to floating point. If the 
-    // value is too large to fit, it will be rounded, not truncated. 
-    Result = SrcSema.isSigned() ? B.CreateSIToFP(Src, OpTy) 
-                                : B.CreateUIToFP(Src, OpTy); 
-    // Rescale the integral-in-floating point by the scaling factor. This is 
-    // lossless, except for overflow to infinity which is unlikely. 
-    Result = B.CreateFMul(Result, 
-        ConstantFP::get(OpTy, std::pow(2, -(int)SrcSema.getScale()))); 
-    if (OpTy != DstTy) 
-      Result = B.CreateFPTrunc(Result, DstTy); 
-    return Result; 
-  } 
- 
-  Value *CreateFloatingToFixed(Value *Src, const FixedPointSemantics &DstSema) { 
-    bool UseSigned = DstSema.isSigned() || DstSema.hasUnsignedPadding(); 
-    Value *Result = Src; 
-    Type *OpTy = getAccommodatingFloatType(Src->getType(), DstSema); 
-    if (OpTy != Src->getType()) 
-      Result = B.CreateFPExt(Result, OpTy); 
-    // Rescale the floating point value so that its significant bits (for the 
-    // purposes of the conversion) are in the integral range. 
-    Result = B.CreateFMul(Result, 
-        ConstantFP::get(OpTy, std::pow(2, DstSema.getScale()))); 
- 
-    Type *ResultTy = B.getIntNTy(DstSema.getWidth()); 
-    if (DstSema.isSaturated()) { 
-      Intrinsic::ID IID = 
-          UseSigned ? Intrinsic::fptosi_sat : Intrinsic::fptoui_sat; 
-      Result = B.CreateIntrinsic(IID, {ResultTy, OpTy}, {Result}); 
-    } else { 
-      Result = UseSigned ? B.CreateFPToSI(Result, ResultTy) 
-                         : B.CreateFPToUI(Result, ResultTy); 
-    } 
- 
-    // When saturating unsigned-with-padding using signed operations, we may 
-    // get negative values. Emit an extra clamp to zero. 
-    if (DstSema.isSaturated() && DstSema.hasUnsignedPadding()) { 
-      Constant *Zero = Constant::getNullValue(Result->getType()); 
-      Result = 
-          B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin"); 
-    } 
- 
-    return Result; 
-  } 
- 
-  /// Add two fixed-point values and return the result in their common semantic. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateAdd(Value *LHS, const FixedPointSemantics &LHSSema, 
-                   Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
-    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding(); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    Value *Result; 
-    if (CommonSema.isSaturated()) { 
-      Intrinsic::ID IID = UseSigned ? Intrinsic::sadd_sat : Intrinsic::uadd_sat; 
-      Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS); 
-    } else { 
-      Result = B.CreateAdd(WideLHS, WideRHS); 
-    } 
- 
-    return CreateFixedToFixed(Result, CommonSema, 
-                              LHSSema.getCommonSemantics(RHSSema)); 
-  } 
- 
-  /// Subtract two fixed-point values and return the result in their common 
-  /// semantic. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateSub(Value *LHS, const FixedPointSemantics &LHSSema, 
-                   Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
-    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding(); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    Value *Result; 
-    if (CommonSema.isSaturated()) { 
-      Intrinsic::ID IID = UseSigned ? Intrinsic::ssub_sat : Intrinsic::usub_sat; 
-      Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS); 
-    } else { 
-      Result = B.CreateSub(WideLHS, WideRHS); 
-    } 
- 
-    // Subtraction can end up below 0 for padded unsigned operations, so emit 
-    // an extra clamp in that case. 
-    if (CommonSema.isSaturated() && CommonSema.hasUnsignedPadding()) { 
-      Constant *Zero = Constant::getNullValue(Result->getType()); 
-      Result = 
-          B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin"); 
-    } 
- 
-    return CreateFixedToFixed(Result, CommonSema, 
-                              LHSSema.getCommonSemantics(RHSSema)); 
-  } 
- 
-  /// Multiply two fixed-point values and return the result in their common 
-  /// semantic. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateMul(Value *LHS, const FixedPointSemantics &LHSSema, 
-                   Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
-    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding(); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    Intrinsic::ID IID; 
-    if (CommonSema.isSaturated()) { 
-      IID = UseSigned ? Intrinsic::smul_fix_sat : Intrinsic::umul_fix_sat; 
-    } else { 
-      IID = UseSigned ? Intrinsic::smul_fix : Intrinsic::umul_fix; 
-    } 
-    Value *Result = B.CreateIntrinsic( 
-        IID, {WideLHS->getType()}, 
-        {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())}); 
- 
-    return CreateFixedToFixed(Result, CommonSema, 
-                              LHSSema.getCommonSemantics(RHSSema)); 
-  } 
- 
-  /// Divide two fixed-point values and return the result in their common 
-  /// semantic. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateDiv(Value *LHS, const FixedPointSemantics &LHSSema, 
-                   Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
-    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding(); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    Intrinsic::ID IID; 
-    if (CommonSema.isSaturated()) { 
-      IID = UseSigned ? Intrinsic::sdiv_fix_sat : Intrinsic::udiv_fix_sat; 
-    } else { 
-      IID = UseSigned ? Intrinsic::sdiv_fix : Intrinsic::udiv_fix; 
-    } 
-    Value *Result = B.CreateIntrinsic( 
-        IID, {WideLHS->getType()}, 
-        {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())}); 
- 
-    return CreateFixedToFixed(Result, CommonSema, 
-                              LHSSema.getCommonSemantics(RHSSema)); 
-  } 
- 
-  /// Left shift a fixed-point value by an unsigned integer value. The integer 
-  /// value can be any bit width. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  Value *CreateShl(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS) { 
-    bool UseSigned = LHSSema.isSigned() || LHSSema.hasUnsignedPadding(); 
- 
-    RHS = B.CreateIntCast(RHS, LHS->getType(), /*IsSigned=*/false); 
- 
-    Value *Result; 
-    if (LHSSema.isSaturated()) { 
-      Intrinsic::ID IID = UseSigned ? Intrinsic::sshl_sat : Intrinsic::ushl_sat; 
-      Result = B.CreateBinaryIntrinsic(IID, LHS, RHS); 
-    } else { 
-      Result = B.CreateShl(LHS, RHS); 
-    } 
- 
-    return Result; 
-  } 
- 
-  /// Right shift a fixed-point value by an unsigned integer value. The integer 
-  /// value can be any bit width. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  Value *CreateShr(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS) { 
-    RHS = B.CreateIntCast(RHS, LHS->getType(), false); 
- 
-    return LHSSema.isSigned() ? B.CreateAShr(LHS, RHS) : B.CreateLShr(LHS, RHS); 
-  } 
- 
-  /// Compare two fixed-point values for equality. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateEQ(Value *LHS, const FixedPointSemantics &LHSSema, 
-                  Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    return B.CreateICmpEQ(WideLHS, WideRHS); 
-  } 
- 
-  /// Compare two fixed-point values for inequality. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateNE(Value *LHS, const FixedPointSemantics &LHSSema, 
-                  Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    return B.CreateICmpNE(WideLHS, WideRHS); 
-  } 
- 
-  /// Compare two fixed-point values as LHS < RHS. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateLT(Value *LHS, const FixedPointSemantics &LHSSema, 
-                  Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    return CommonSema.isSigned() ? B.CreateICmpSLT(WideLHS, WideRHS) 
-                                 : B.CreateICmpULT(WideLHS, WideRHS); 
-  } 
- 
-  /// Compare two fixed-point values as LHS <= RHS. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateLE(Value *LHS, const FixedPointSemantics &LHSSema, 
-                  Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    return CommonSema.isSigned() ? B.CreateICmpSLE(WideLHS, WideRHS) 
-                                 : B.CreateICmpULE(WideLHS, WideRHS); 
-  } 
- 
-  /// Compare two fixed-point values as LHS > RHS. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateGT(Value *LHS, const FixedPointSemantics &LHSSema, 
-                  Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    return CommonSema.isSigned() ? B.CreateICmpSGT(WideLHS, WideRHS) 
-                                 : B.CreateICmpUGT(WideLHS, WideRHS); 
-  } 
- 
-  /// Compare two fixed-point values as LHS >= RHS. 
-  /// \p LHS     - The left hand side 
-  /// \p LHSSema - The semantic of the left hand side 
-  /// \p RHS     - The right hand side 
-  /// \p RHSSema - The semantic of the right hand side 
-  Value *CreateGE(Value *LHS, const FixedPointSemantics &LHSSema, 
-                  Value *RHS, const FixedPointSemantics &RHSSema) { 
-    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema); 
- 
-    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema); 
-    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema); 
- 
-    return CommonSema.isSigned() ? B.CreateICmpSGE(WideLHS, WideRHS) 
-                                 : B.CreateICmpUGE(WideLHS, WideRHS); 
-  } 
-}; 
- 
-} // end namespace llvm 
- 
-#endif // LLVM_IR_FIXEDPOINTBUILDER_H 
- 
-#ifdef __GNUC__ 
-#pragma GCC diagnostic pop 
-#endif 
+#pragma once
+
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+#endif
+
+//===- llvm/FixedPointBuilder.h - Builder for fixed-point ops ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the FixedPointBuilder class, which is used as a convenient
+// way to lower fixed-point arithmetic operations to LLVM IR.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_IR_FIXEDPOINTBUILDER_H
+#define LLVM_IR_FIXEDPOINTBUILDER_H
+
+#include "llvm/ADT/APFixedPoint.h"
+#include "llvm/IR/Constant.h"
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InstrTypes.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/Type.h"
+#include "llvm/IR/Value.h"
+
+namespace llvm {
+
+template <class IRBuilderTy> class FixedPointBuilder {
+  IRBuilderTy &B;
+
+  Value *Convert(Value *Src, const FixedPointSemantics &SrcSema,
+                 const FixedPointSemantics &DstSema, bool DstIsInteger) {
+    unsigned SrcWidth = SrcSema.getWidth();
+    unsigned DstWidth = DstSema.getWidth();
+    unsigned SrcScale = SrcSema.getScale();
+    unsigned DstScale = DstSema.getScale();
+    bool SrcIsSigned = SrcSema.isSigned();
+    bool DstIsSigned = DstSema.isSigned();
+
+    Type *DstIntTy = B.getIntNTy(DstWidth);
+
+    Value *Result = Src;
+    unsigned ResultWidth = SrcWidth;
+
+    // Downscale.
+    if (DstScale < SrcScale) {
+      // When converting to integers, we round towards zero. For negative
+      // numbers, right shifting rounds towards negative infinity. In this case,
+      // we can just round up before shifting.
+      if (DstIsInteger && SrcIsSigned) {
+        Value *Zero = Constant::getNullValue(Result->getType());
+        Value *IsNegative = B.CreateICmpSLT(Result, Zero);
+        Value *LowBits = ConstantInt::get(
+            B.getContext(), APInt::getLowBitsSet(ResultWidth, SrcScale));
+        Value *Rounded = B.CreateAdd(Result, LowBits);
+        Result = B.CreateSelect(IsNegative, Rounded, Result);
+      }
+
+      Result = SrcIsSigned
+                   ? B.CreateAShr(Result, SrcScale - DstScale, "downscale")
+                   : B.CreateLShr(Result, SrcScale - DstScale, "downscale");
+    }
+
+    if (!DstSema.isSaturated()) {
+      // Resize.
+      Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
+
+      // Upscale.
+      if (DstScale > SrcScale)
+        Result = B.CreateShl(Result, DstScale - SrcScale, "upscale");
+    } else {
+      // Adjust the number of fractional bits.
+      if (DstScale > SrcScale) {
+        // Compare to DstWidth to prevent resizing twice.
+        ResultWidth = std::max(SrcWidth + DstScale - SrcScale, DstWidth);
+        Type *UpscaledTy = B.getIntNTy(ResultWidth);
+        Result = B.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize");
+        Result = B.CreateShl(Result, DstScale - SrcScale, "upscale");
+      }
+
+      // Handle saturation.
+      bool LessIntBits = DstSema.getIntegralBits() < SrcSema.getIntegralBits();
+      if (LessIntBits) {
+        Value *Max = ConstantInt::get(
+            B.getContext(),
+            APFixedPoint::getMax(DstSema).getValue().extOrTrunc(ResultWidth));
+        Value *TooHigh = SrcIsSigned ? B.CreateICmpSGT(Result, Max)
+                                     : B.CreateICmpUGT(Result, Max);
+        Result = B.CreateSelect(TooHigh, Max, Result, "satmax");
+      }
+      // Cannot overflow min to dest type if src is unsigned since all fixed
+      // point types can cover the unsigned min of 0.
+      if (SrcIsSigned && (LessIntBits || !DstIsSigned)) {
+        Value *Min = ConstantInt::get(
+            B.getContext(),
+            APFixedPoint::getMin(DstSema).getValue().extOrTrunc(ResultWidth));
+        Value *TooLow = B.CreateICmpSLT(Result, Min);
+        Result = B.CreateSelect(TooLow, Min, Result, "satmin");
+      }
+
+      // Resize the integer part to get the final destination size.
+      if (ResultWidth != DstWidth)
+        Result = B.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
+    }
+    return Result;
+  }
+
+  /// Get the common semantic for two semantics, with the added imposition that
+  /// saturated padded types retain the padding bit.
+  FixedPointSemantics
+  getCommonBinopSemantic(const FixedPointSemantics &LHSSema,
+                         const FixedPointSemantics &RHSSema) {
+    auto C = LHSSema.getCommonSemantics(RHSSema);
+    bool BothPadded =
+        LHSSema.hasUnsignedPadding() && RHSSema.hasUnsignedPadding();
+    return FixedPointSemantics(
+        C.getWidth() + (unsigned)(BothPadded && C.isSaturated()), C.getScale(),
+        C.isSigned(), C.isSaturated(), BothPadded);
+  }
+
+  /// Given a floating point type and a fixed-point semantic, return a floating
+  /// point type which can accommodate the fixed-point semantic. This is either
+  /// \p Ty, or a floating point type with a larger exponent than Ty.
+  Type *getAccommodatingFloatType(Type *Ty, const FixedPointSemantics &Sema) {
+    const fltSemantics *FloatSema = &Ty->getFltSemantics();
+    while (!Sema.fitsInFloatSemantics(*FloatSema))
+      FloatSema = APFixedPoint::promoteFloatSemantics(FloatSema);
+    return Type::getFloatingPointTy(Ty->getContext(), *FloatSema);
+  }
+
+public:
+  FixedPointBuilder(IRBuilderTy &Builder) : B(Builder) {}
+
+  /// Convert an integer value representing a fixed-point number from one
+  /// fixed-point semantic to another fixed-point semantic.
+  /// \p Src     - The source value
+  /// \p SrcSema - The fixed-point semantic of the source value
+  /// \p DstSema - The resulting fixed-point semantic
+  Value *CreateFixedToFixed(Value *Src, const FixedPointSemantics &SrcSema,
+                            const FixedPointSemantics &DstSema) {
+    return Convert(Src, SrcSema, DstSema, false);
+  }
+
+  /// Convert an integer value representing a fixed-point number to an integer
+  /// with the given bit width and signedness.
+  /// \p Src         - The source value
+  /// \p SrcSema     - The fixed-point semantic of the source value
+  /// \p DstWidth    - The bit width of the result value
+  /// \p DstIsSigned - The signedness of the result value
+  Value *CreateFixedToInteger(Value *Src, const FixedPointSemantics &SrcSema,
+                              unsigned DstWidth, bool DstIsSigned) {
+    return Convert(
+        Src, SrcSema,
+        FixedPointSemantics::GetIntegerSemantics(DstWidth, DstIsSigned), true);
+  }
+
+  /// Convert an integer value with the given signedness to an integer value
+  /// representing the given fixed-point semantic.
+  /// \p Src         - The source value
+  /// \p SrcIsSigned - The signedness of the source value
+  /// \p DstSema     - The resulting fixed-point semantic
+  Value *CreateIntegerToFixed(Value *Src, unsigned SrcIsSigned,
+                              const FixedPointSemantics &DstSema) {
+    return Convert(Src,
+                   FixedPointSemantics::GetIntegerSemantics(
+                       Src->getType()->getScalarSizeInBits(), SrcIsSigned),
+                   DstSema, false);
+  }
+
+  Value *CreateFixedToFloating(Value *Src, const FixedPointSemantics &SrcSema,
+                               Type *DstTy) {
+    Value *Result;
+    Type *OpTy = getAccommodatingFloatType(DstTy, SrcSema);
+    // Convert the raw fixed-point value directly to floating point. If the
+    // value is too large to fit, it will be rounded, not truncated.
+    Result = SrcSema.isSigned() ? B.CreateSIToFP(Src, OpTy)
+                                : B.CreateUIToFP(Src, OpTy);
+    // Rescale the integral-in-floating point by the scaling factor. This is
+    // lossless, except for overflow to infinity which is unlikely.
+    Result = B.CreateFMul(Result,
+        ConstantFP::get(OpTy, std::pow(2, -(int)SrcSema.getScale())));
+    if (OpTy != DstTy)
+      Result = B.CreateFPTrunc(Result, DstTy);
+    return Result;
+  }
+
+  Value *CreateFloatingToFixed(Value *Src, const FixedPointSemantics &DstSema) {
+    bool UseSigned = DstSema.isSigned() || DstSema.hasUnsignedPadding();
+    Value *Result = Src;
+    Type *OpTy = getAccommodatingFloatType(Src->getType(), DstSema);
+    if (OpTy != Src->getType())
+      Result = B.CreateFPExt(Result, OpTy);
+    // Rescale the floating point value so that its significant bits (for the
+    // purposes of the conversion) are in the integral range.
+    Result = B.CreateFMul(Result,
+        ConstantFP::get(OpTy, std::pow(2, DstSema.getScale())));
+
+    Type *ResultTy = B.getIntNTy(DstSema.getWidth());
+    if (DstSema.isSaturated()) {
+      Intrinsic::ID IID =
+          UseSigned ? Intrinsic::fptosi_sat : Intrinsic::fptoui_sat;
+      Result = B.CreateIntrinsic(IID, {ResultTy, OpTy}, {Result});
+    } else {
+      Result = UseSigned ? B.CreateFPToSI(Result, ResultTy)
+                         : B.CreateFPToUI(Result, ResultTy);
+    }
+
+    // When saturating unsigned-with-padding using signed operations, we may
+    // get negative values. Emit an extra clamp to zero.
+    if (DstSema.isSaturated() && DstSema.hasUnsignedPadding()) {
+      Constant *Zero = Constant::getNullValue(Result->getType());
+      Result =
+          B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin");
+    }
+
+    return Result;
+  }
+
+  /// Add two fixed-point values and return the result in their common semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateAdd(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Value *Result;
+    if (CommonSema.isSaturated()) {
+      Intrinsic::ID IID = UseSigned ? Intrinsic::sadd_sat : Intrinsic::uadd_sat;
+      Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS);
+    } else {
+      Result = B.CreateAdd(WideLHS, WideRHS);
+    }
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Subtract two fixed-point values and return the result in their common
+  /// semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateSub(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Value *Result;
+    if (CommonSema.isSaturated()) {
+      Intrinsic::ID IID = UseSigned ? Intrinsic::ssub_sat : Intrinsic::usub_sat;
+      Result = B.CreateBinaryIntrinsic(IID, WideLHS, WideRHS);
+    } else {
+      Result = B.CreateSub(WideLHS, WideRHS);
+    }
+
+    // Subtraction can end up below 0 for padded unsigned operations, so emit
+    // an extra clamp in that case.
+    if (CommonSema.isSaturated() && CommonSema.hasUnsignedPadding()) {
+      Constant *Zero = Constant::getNullValue(Result->getType());
+      Result =
+          B.CreateSelect(B.CreateICmpSLT(Result, Zero), Zero, Result, "satmin");
+    }
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Multiply two fixed-point values and return the result in their common
+  /// semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateMul(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Intrinsic::ID IID;
+    if (CommonSema.isSaturated()) {
+      IID = UseSigned ? Intrinsic::smul_fix_sat : Intrinsic::umul_fix_sat;
+    } else {
+      IID = UseSigned ? Intrinsic::smul_fix : Intrinsic::umul_fix;
+    }
+    Value *Result = B.CreateIntrinsic(
+        IID, {WideLHS->getType()},
+        {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())});
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Divide two fixed-point values and return the result in their common
+  /// semantic.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateDiv(Value *LHS, const FixedPointSemantics &LHSSema,
+                   Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+    bool UseSigned = CommonSema.isSigned() || CommonSema.hasUnsignedPadding();
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    Intrinsic::ID IID;
+    if (CommonSema.isSaturated()) {
+      IID = UseSigned ? Intrinsic::sdiv_fix_sat : Intrinsic::udiv_fix_sat;
+    } else {
+      IID = UseSigned ? Intrinsic::sdiv_fix : Intrinsic::udiv_fix;
+    }
+    Value *Result = B.CreateIntrinsic(
+        IID, {WideLHS->getType()},
+        {WideLHS, WideRHS, B.getInt32(CommonSema.getScale())});
+
+    return CreateFixedToFixed(Result, CommonSema,
+                              LHSSema.getCommonSemantics(RHSSema));
+  }
+
+  /// Left shift a fixed-point value by an unsigned integer value. The integer
+  /// value can be any bit width.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  Value *CreateShl(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS) {
+    bool UseSigned = LHSSema.isSigned() || LHSSema.hasUnsignedPadding();
+
+    RHS = B.CreateIntCast(RHS, LHS->getType(), /*IsSigned=*/false);
+
+    Value *Result;
+    if (LHSSema.isSaturated()) {
+      Intrinsic::ID IID = UseSigned ? Intrinsic::sshl_sat : Intrinsic::ushl_sat;
+      Result = B.CreateBinaryIntrinsic(IID, LHS, RHS);
+    } else {
+      Result = B.CreateShl(LHS, RHS);
+    }
+
+    return Result;
+  }
+
+  /// Right shift a fixed-point value by an unsigned integer value. The integer
+  /// value can be any bit width.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  Value *CreateShr(Value *LHS, const FixedPointSemantics &LHSSema, Value *RHS) {
+    RHS = B.CreateIntCast(RHS, LHS->getType(), false);
+
+    return LHSSema.isSigned() ? B.CreateAShr(LHS, RHS) : B.CreateLShr(LHS, RHS);
+  }
+
+  /// Compare two fixed-point values for equality.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateEQ(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return B.CreateICmpEQ(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values for inequality.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateNE(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return B.CreateICmpNE(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS < RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateLT(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSLT(WideLHS, WideRHS)
+                                 : B.CreateICmpULT(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS <= RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateLE(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSLE(WideLHS, WideRHS)
+                                 : B.CreateICmpULE(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS > RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateGT(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSGT(WideLHS, WideRHS)
+                                 : B.CreateICmpUGT(WideLHS, WideRHS);
+  }
+
+  /// Compare two fixed-point values as LHS >= RHS.
+  /// \p LHS     - The left hand side
+  /// \p LHSSema - The semantic of the left hand side
+  /// \p RHS     - The right hand side
+  /// \p RHSSema - The semantic of the right hand side
+  Value *CreateGE(Value *LHS, const FixedPointSemantics &LHSSema,
+                  Value *RHS, const FixedPointSemantics &RHSSema) {
+    auto CommonSema = getCommonBinopSemantic(LHSSema, RHSSema);
+
+    Value *WideLHS = CreateFixedToFixed(LHS, LHSSema, CommonSema);
+    Value *WideRHS = CreateFixedToFixed(RHS, RHSSema, CommonSema);
+
+    return CommonSema.isSigned() ? B.CreateICmpSGE(WideLHS, WideRHS)
+                                 : B.CreateICmpUGE(WideLHS, WideRHS);
+  }
+};
+
+} // end namespace llvm
+
+#endif // LLVM_IR_FIXEDPOINTBUILDER_H
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif