mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-25 06:06:06 +00:00
Code Issues Projects Releases Wiki Activity

Constant Fold Logf128 calls (#84501)

Browse Source 
This patch enables constant folding for 128 bit floating-point logf
calls. This is achieved by querying if the host system has the logf128()
symbol available with a CMake test. If so, replace the runtime call with
the compile time value returned from logf128.
This commit is contained in:
Matthew Devereau 2024-04-18 10:19:01 +01:00 committed by GitHub
parent 63d8058ef5
commit e90bc9cfd4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
14 changed files with 236 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
llvm/CMakeLists.txt
View File

@ -562,6 +562,8 @@ set(LLVM_USE_STATIC_ZSTD FALSE CACHE BOOL "Use static version of zstd. Can be TR
set(LLVM_ENABLE_CURL "OFF" CACHE STRING "Use libcurl for the HTTP client if available. Can be ON, OFF, or FORCE_ON")
set(LLVM_HAS_LOGF128 "OFF" CACHE STRING "Use logf128 to constant fold fp128 logarithm calls. Can be ON, OFF, or FORCE_ON")
set(LLVM_ENABLE_HTTPLIB "OFF" CACHE STRING "Use cpp-httplib HTTP server library if available. Can be ON, OFF, or FORCE_ON")
set(LLVM_Z3_INSTALL_DIR "" CACHE STRING "Install directory of the Z3 solver.")

11
llvm/cmake/config-ix.cmake
View File

@ -257,6 +257,17 @@ else()
set(LLVM_ENABLE_TERMINFO 0)
endif()
if(LLVM_HAS_LOGF128)
include(CheckCXXSymbolExists)
check_cxx_symbol_exists(logf128 math.h HAS_LOGF128)
if(LLVM_HAS_LOGF128 STREQUAL FORCE_ON AND NOT HAS_LOGF128)
message(FATAL_ERROR "Failed to configure logf128")
endif()
set(LLVM_HAS_LOGF128 "${HAS_LOGF128}")
endif()
# function checks
check_symbol_exists(arc4random "stdlib.h" HAVE_DECL_ARC4RANDOM)
find_package(Backtrace)

13
llvm/include/llvm/ADT/APFloat.h
View File

@ -19,6 +19,7 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/FloatingPointMode.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/float128.h"
#include <memory>
#define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL) \
@ -354,6 +355,9 @@ public:
Expected<opStatus> convertFromString(StringRef, roundingMode);
APInt bitcastToAPInt() const;
double convertToDouble() const;
#ifdef __FLOAT128__
float128 convertToQuad() const;
#endif
float convertToFloat() const;
/// @}
@ -1218,6 +1222,15 @@ public:
/// shorter semantics, like IEEEsingle and others.
double convertToDouble() const;
/// Converts this APFloat to host float value.
///
/// \pre The APFloat must be built using semantics, that can be represented by
/// the host float type without loss of precision. It can be IEEEquad and
/// shorter semantics, like IEEEdouble and others.
#ifdef __FLOAT128__
float128 convertToQuad() const;
#endif
/// Converts this APFloat to host float value.
///
/// \pre The APFloat must be built using semantics, that can be represented by

8
llvm/include/llvm/ADT/APInt.h
View File

@ -17,6 +17,7 @@
#include "llvm/Support/Compiler.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/float128.h"
#include <cassert>
#include <climits>
#include <cstring>
@ -1670,6 +1671,13 @@ public:
/// any bit width. Exactly 64 bits will be translated.
double bitsToDouble() const { return llvm::bit_cast<double>(getWord(0)); }
#ifdef __FLOAT128__
float128 bitsToQuad() const {
__uint128_t ul = ((__uint128_t)U.pVal[1] << 64) + U.pVal[0];
return llvm::bit_cast<float128>(ul);
}
#endif
/// Converts APInt bits to a float
///
/// The conversion does not do a translation from integer to float, it just

3
llvm/include/llvm/Config/llvm-config.h.cmake
View File

@ -198,4 +198,7 @@
/* Define if plugins enabled */
#cmakedefine LLVM_ENABLE_PLUGINS
/* Define if logf128 is available */
#cmakedefine LLVM_HAS_LOGF128
#endif

21
llvm/include/llvm/Support/float128.h Normal file
View File

@ -0,0 +1,21 @@
//===-- llvm/Support/float128.h - Compiler abstraction support --*- 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_FLOAT128
#define LLVM_FLOAT128
namespace llvm {
#if defined(__clang__) && defined(__FLOAT128__)
typedef __float128 float128;
#elif defined(__FLOAT128__) && (defined(__GNUC__) || defined(__GNUG__))
typedef _Float128 float128;
#endif
} // namespace llvm
#endif // LLVM_FLOAT128

6
llvm/lib/Analysis/CMakeLists.txt
View File

@ -159,3 +159,9 @@ add_llvm_component_library(LLVMAnalysis
Support
TargetParser
)
include(CheckCXXSymbolExists)
check_cxx_symbol_exists(logf128 math.h HAS_LOGF128)
if(HAS_LOGF128)
target_compile_definitions(LLVMAnalysis PRIVATE HAS_LOGF128)
endif()

11
llvm/lib/Analysis/ConstantFolding.cpp
View File

@ -2089,6 +2089,17 @@ static Constant *ConstantFoldScalarCall1(StringRef Name,
if (IntrinsicID == Intrinsic::canonicalize)
return constantFoldCanonicalize(Ty, Call, U);
#if defined(__FLOAT128__) && defined(HAS_LOGF128)
if (Ty->isFP128Ty()) {
switch (IntrinsicID) {
default:
return nullptr;
case Intrinsic::log:
return ConstantFP::get(Ty, logf128(Op->getValueAPF().convertToQuad()));
}
}
#endif
if (!Ty->isHalfTy() && !Ty->isFloatTy() && !Ty->isDoubleTy())
return nullptr;

24
llvm/lib/Support/APFloat.cpp
View File

@ -3670,6 +3670,15 @@ double IEEEFloat::convertToDouble() const {
return api.bitsToDouble();
}
#ifdef __FLOAT128__
float128 IEEEFloat::convertToQuad() const {
assert(semantics == (const llvm::fltSemantics *)&semIEEEquad &&
"Float semantics are not IEEEquads");
APInt api = bitcastToAPInt();
return api.bitsToQuad();
}
#endif
/// Integer bit is explicit in this format. Intel hardware (387 and later)
/// does not support these bit patterns:
/// exponent = all 1's, integer bit 0, significand 0 ("pseudoinfinity")
@ -5265,6 +5274,21 @@ double APFloat::convertToDouble() const {
return Temp.getIEEE().convertToDouble();
}
#ifdef __FLOAT128__
float128 APFloat::convertToQuad() const {
if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEquad)
return getIEEE().convertToQuad();
assert(getSemantics().isRepresentableBy(semIEEEquad) &&
"Float semantics is not representable by IEEEquad");
APFloat Temp = *this;
bool LosesInfo;
opStatus St = Temp.convert(semIEEEquad, rmNearestTiesToEven, &LosesInfo);
assert(!(St & opInexact) && !LosesInfo && "Unexpected imprecision");
(void)St;
return Temp.getIEEE().convertToQuad();
}
#endif
float APFloat::convertToFloat() const {
if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEsingle)
return getIEEE().convertToFloat();

1
llvm/test/CMakeLists.txt
View File

@ -25,6 +25,7 @@ llvm_canonicalize_cmake_booleans(
LLVM_INCLUDE_DXIL_TESTS
LLVM_TOOL_LLVM_DRIVER_BUILD
LLVM_INCLUDE_SPIRV_TOOLS_TESTS
LLVM_HAS_LOGF128
)
configure_lit_site_cfg(

126
llvm/test/Transforms/InstSimplify/ConstProp/logf128.ll Normal file
View File

@ -0,0 +1,126 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 4
; RUN: opt < %s -passes=instsimplify -S | FileCheck %s
; REQUIRES: has_logf128
declare fp128 @llvm.log.f128(fp128)
define fp128 @log_e_64(){
; CHECK-LABEL: define fp128 @log_e_64() {
; CHECK-NEXT: ret fp128 0xL300000000000000040010A2B23F3BAB7
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000004005000000000000)
ret fp128 %A
}
define fp128 @log_e_smallest_positive_subnormal_number(){
; CHECK-LABEL: define fp128 @log_e_smallest_positive_subnormal_number() {
; CHECK-NEXT: ret fp128 0xL3000000000000000C00C654628220780
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000010000000000000000)
ret fp128 %A
}
define fp128 @log_e_largest_subnormal_number(){
; CHECK-LABEL: define fp128 @log_e_largest_subnormal_number() {
; CHECK-NEXT: ret fp128 0xLD000000000000000C00C62D918CE2421
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xLFFFFFFFFFFFFFFFF0000FFFFFFFFFFFF)
ret fp128 %A
}
define fp128 @log_e_smallest_positive_normal_number(){
;
; CHECK-LABEL: define fp128 @log_e_smallest_positive_normal_number() {
; CHECK-NEXT: ret fp128 0xLD000000000000000C00C62D918CE2421
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000000001000000000000)
ret fp128 %A
}
define fp128 @log_e_largest_normal_number(){
; CHECK-LABEL: define fp128 @log_e_largest_normal_number() {
; CHECK-NEXT: ret fp128 0xLF000000000000000400C62E42FEFA39E
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xLFFFFFFFFFFFFFFFF7FFEFFFFFFFFFFFF)
ret fp128 %A
}
define fp128 @log_e_largest_number_less_than_one(){
; CHECK-LABEL: define fp128 @log_e_largest_number_less_than_one() {
; CHECK-NEXT: ret fp128 0xL0000000000000000BF8E000000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xLFFFFFFFFFFFFFFFF3FFEFFFFFFFFFFFF)
ret fp128 %A
}
define fp128 @log_e_1(){
; CHECK-LABEL: define fp128 @log_e_1() {
; CHECK-NEXT: ret fp128 0xL00000000000000000000000000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000003FFF000000000000)
ret fp128 %A
}
define fp128 @log_e_smallest_number_larger_than_one(){
; CHECK-LABEL: define fp128 @log_e_smallest_number_larger_than_one() {
; CHECK-NEXT: ret fp128 0xL00000000000000003F8F000000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000013FFF000000000000)
ret fp128 %A
}
define fp128 @log_e_negative_2(){
; CHECK-LABEL: define fp128 @log_e_negative_2() {
; CHECK-NEXT: ret fp128 0xL00000000000000007FFF800000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL0000000000000000C000000000000000)
ret fp128 %A
}
define fp128 @log_e_0(){
; CHECK-LABEL: define fp128 @log_e_0() {
; CHECK-NEXT: ret fp128 0xL0000000000000000FFFF000000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000000000000000000000)
ret fp128 %A
}
define fp128 @log_e_negative_0(){
; CHECK-LABEL: define fp128 @log_e_negative_0() {
; CHECK-NEXT: ret fp128 0xL0000000000000000FFFF000000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000008000000000000000)
ret fp128 %A
}
define fp128 @log_e_infinity(){
; CHECK-LABEL: define fp128 @log_e_infinity() {
; CHECK-NEXT: ret fp128 0xL00000000000000007FFF000000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000007FFF000000000000)
ret fp128 %A
}
define fp128 @log_e_negative_infinity(){
; CHECK-LABEL: define fp128 @log_e_negative_infinity() {
; CHECK-NEXT: ret fp128 0xL00000000000000007FFF800000000000
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL0000000000000000FFFF000000000000)
ret fp128 %A
}
define fp128 @log_e_nan(){
; CHECK-LABEL: define fp128 @log_e_nan() {
; CHECK-NEXT: ret fp128 0xL00000000000000007FFF800000000001
;
%A = call fp128 @llvm.log.f128(fp128 noundef 0xL00000000000000007FFF000000000001)
ret fp128 %A
}
define <2 x fp128> @log_e_negative_2_vector(){
; CHECK-LABEL: define <2 x fp128> @log_e_negative_2_vector() {
; CHECK-NEXT: ret <2 x fp128> <fp128 0xL00000000000000007FFF800000000000, fp128 0xL00000000000000007FFF800000000000>
;
%A = call <2 x fp128> @llvm.log.v2f128(<2 x fp128> <fp128 0xL0000000000000000C000000000000000, fp128 0xL0000000000000000C000000000000001>)
ret <2 x fp128> %A
}

3
llvm/test/lit.cfg.py
View File

@ -614,3 +614,6 @@ if "MemoryWithOrigins" in config.llvm_use_sanitizer:
# "OBJECT_MODE" to 'any' by default on AIX OS.
if "system-aix" in config.available_features:
config.environment["OBJECT_MODE"] = "any"
if config.has_logf128:
config.available_features.add("has_logf128")

1
llvm/test/lit.site.cfg.py.in
View File

@ -61,6 +61,7 @@ config.reverse_iteration = @LLVM_ENABLE_REVERSE_ITERATION@
config.dxil_tests = @LLVM_INCLUDE_DXIL_TESTS@
config.have_llvm_driver = @LLVM_TOOL_LLVM_DRIVER_BUILD@
config.spirv_tools_tests = @LLVM_INCLUDE_SPIRV_TOOLS_TESTS@
config.has_logf128 = @LLVM_HAS_LOGF128@
import lit.llvm
lit.llvm.initialize(lit_config, config)

6
llvm/unittests/Analysis/CMakeLists.txt
View File

@ -80,5 +80,11 @@ if(NOT WIN32)
export_executable_symbols_for_plugins(AnalysisTests)
endif()
include(CheckCXXSymbolExists)
check_cxx_symbol_exists(logf128 math.h HAS_LOGF128)
if(HAS_LOGF128)
target_compile_definitions(AnalysisTests PRIVATE HAS_LOGF128)
endif()
add_subdirectory(InlineAdvisorPlugin)
add_subdirectory(InlineOrderPlugin)