466 lines
19 KiB
C
466 lines
19 KiB
C
|
//===- 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
|