azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Force LLVM to inline basic math functions

Browse Source
This commit is contained in:
Sergey Bogolepov
2018-03-20 12:51:46 +07:00
committed by Sergey Bogolepov
parent fd3683eb00
commit bcf1722ecd
2 changed files with 288 additions and 284 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/src/main/cpp/Common.h
+2
View File
@@ -23,6 +23,8 @@
#define RUNTIME_PURE __attribute__((pure))
#define RUNTIME_USED __attribute__((used))
#define ALWAYS_INLINE __attribute__((always_inline))
#if KONAN_NO_THREADS
#define THREAD_LOCAL_VARIABLE
#else
runtime/src/main/cpp/Operator.cpp
+286 -284
View File
@@ -21,6 +21,8 @@
#include "Natives.h"
#include "Exceptions.h"
#include "Common.h"
namespace {
template<typename R, typename Ta, typename Tb> R div(Ta a, Tb b) {
@@ -36,28 +38,28 @@ extern "C" {
//--- Boolean -----------------------------------------------------------------//
KBoolean Kotlin_Boolean_not (KBoolean a ) { return !a; }
KBoolean Kotlin_Boolean_and_Boolean (KBoolean a, KBoolean b) { return a && b; }
KBoolean Kotlin_Boolean_or_Boolean (KBoolean a, KBoolean b) { return a || b; }
KBoolean Kotlin_Boolean_xor_Boolean (KBoolean a, KBoolean b) { return a != b; }
ALWAYS_INLINE KBoolean Kotlin_Boolean_not (KBoolean a ) { return !a; }
ALWAYS_INLINE KBoolean Kotlin_Boolean_and_Boolean (KBoolean a, KBoolean b) { return a && b; }
ALWAYS_INLINE KBoolean Kotlin_Boolean_or_Boolean (KBoolean a, KBoolean b) { return a || b; }
ALWAYS_INLINE KBoolean Kotlin_Boolean_xor_Boolean (KBoolean a, KBoolean b) { return a != b; }
KInt Kotlin_Boolean_compareTo_Boolean(KBoolean a, KBoolean b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
//--- Char --------------------------------------------------------------------//
KInt Kotlin_Char_compareTo_Char (KChar a, KChar b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KChar Kotlin_Char_plus_Int (KChar a, KInt b) { return a + b; }
KInt Kotlin_Char_minus_Char (KChar a, KChar b) { return a - b; }
KChar Kotlin_Char_minus_Int (KChar a, KInt b) { return a - b; }
KChar Kotlin_Char_inc (KChar a ) { return a + 1; }
KChar Kotlin_Char_dec (KChar a ) { return a - 1; }
ALWAYS_INLINE KChar Kotlin_Char_plus_Int (KChar a, KInt b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Char_minus_Char (KChar a, KChar b) { return a - b; }
ALWAYS_INLINE KChar Kotlin_Char_minus_Int (KChar a, KInt b) { return a - b; }
ALWAYS_INLINE KChar Kotlin_Char_inc (KChar a ) { return a + 1; }
ALWAYS_INLINE KChar Kotlin_Char_dec (KChar a ) { return a - 1; }
KByte Kotlin_Char_toByte (KChar a ) { return a; }
KChar Kotlin_Char_toChar (KChar a ) { return a; }
KShort Kotlin_Char_toShort (KChar a ) { return a; }
KInt Kotlin_Char_toInt (KChar a ) { return a; }
KLong Kotlin_Char_toLong (KChar a ) { return a; }
KFloat Kotlin_Char_toFloat (KChar a ) { return a; }
KDouble Kotlin_Char_toDouble (KChar a ) { return a; }
ALWAYS_INLINE KByte Kotlin_Char_toByte (KChar a ) { return a; }
ALWAYS_INLINE KChar Kotlin_Char_toChar (KChar a ) { return a; }
ALWAYS_INLINE KShort Kotlin_Char_toShort (KChar a ) { return a; }
ALWAYS_INLINE KInt Kotlin_Char_toInt (KChar a ) { return a; }
ALWAYS_INLINE KLong Kotlin_Char_toLong (KChar a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Char_toFloat (KChar a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Char_toDouble (KChar a ) { return a; }
//--- Byte --------------------------------------------------------------------//
@@ -68,58 +70,58 @@ KInt Kotlin_Byte_compareTo_Long (KByte a, KLong b) { if (a == b) return 0
KInt Kotlin_Byte_compareTo_Float (KByte a, KFloat b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Byte_compareTo_Double (KByte a, KDouble b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Byte_plus_Byte (KByte a, KByte b) { return a + b; }
KInt Kotlin_Byte_plus_Short (KByte a, KShort b) { return a + b; }
KInt Kotlin_Byte_plus_Int (KByte a, KInt b) { return a + b; }
KLong Kotlin_Byte_plus_Long (KByte a, KLong b) { return a + b; }
KFloat Kotlin_Byte_plus_Float (KByte a, KFloat b) { return a + b; }
KDouble Kotlin_Byte_plus_Double (KByte a, KDouble b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Byte_plus_Byte (KByte a, KByte b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Byte_plus_Short (KByte a, KShort b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Byte_plus_Int (KByte a, KInt b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Byte_plus_Long (KByte a, KLong b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Byte_plus_Float (KByte a, KFloat b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Byte_plus_Double (KByte a, KDouble b) { return a + b; }
KInt Kotlin_Byte_minus_Byte (KByte a, KByte b) { return a - b; }
KInt Kotlin_Byte_minus_Short (KByte a, KShort b) { return a - b; }
KInt Kotlin_Byte_minus_Int (KByte a, KInt b) { return a - b; }
KLong Kotlin_Byte_minus_Long (KByte a, KLong b) { return a - b; }
KFloat Kotlin_Byte_minus_Float (KByte a, KFloat b) { return a - b; }
KDouble Kotlin_Byte_minus_Double (KByte a, KDouble b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Byte_minus_Byte (KByte a, KByte b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Byte_minus_Short (KByte a, KShort b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Byte_minus_Int (KByte a, KInt b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Byte_minus_Long (KByte a, KLong b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Byte_minus_Float (KByte a, KFloat b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Byte_minus_Double (KByte a, KDouble b) { return a - b; }
KInt Kotlin_Byte_div_Byte (KByte a, KByte b) { return div<KInt>(a, b); }
KInt Kotlin_Byte_div_Short (KByte a, KShort b) { return div<KInt>(a, b); }
KInt Kotlin_Byte_div_Int (KByte a, KInt b) { return div<KInt>(a, b); }
KLong Kotlin_Byte_div_Long (KByte a, KLong b) { return div<KLong>(a, b); }
KFloat Kotlin_Byte_div_Float (KByte a, KFloat b) { return a / b; }
KDouble Kotlin_Byte_div_Double (KByte a, KDouble b) { return a / b; }
ALWAYS_INLINE KInt Kotlin_Byte_div_Byte (KByte a, KByte b) { return div<KInt>(a, b); }
ALWAYS_INLINE KInt Kotlin_Byte_div_Short (KByte a, KShort b) { return div<KInt>(a, b); }
ALWAYS_INLINE KInt Kotlin_Byte_div_Int (KByte a, KInt b) { return div<KInt>(a, b); }
ALWAYS_INLINE KLong Kotlin_Byte_div_Long (KByte a, KLong b) { return div<KLong>(a, b); }
ALWAYS_INLINE KFloat Kotlin_Byte_div_Float (KByte a, KFloat b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Byte_div_Double (KByte a, KDouble b) { return a / b; }
KInt Kotlin_Byte_mod_Byte (KByte a, KByte b) { return a % b; }
KInt Kotlin_Byte_mod_Short (KByte a, KShort b) { return a % b; }
KInt Kotlin_Byte_mod_Int (KByte a, KInt b) { return a % b; }
KLong Kotlin_Byte_mod_Long (KByte a, KLong b) { return a % b; }
KFloat Kotlin_Byte_mod_Float (KByte a, KFloat b) { return fmodf(a, b); }
KDouble Kotlin_Byte_mod_Double (KByte a, KDouble b) { return fmod (a, b); }
ALWAYS_INLINE KInt Kotlin_Byte_mod_Byte (KByte a, KByte b) { return a % b; }
ALWAYS_INLINE KInt Kotlin_Byte_mod_Short (KByte a, KShort b) { return a % b; }
ALWAYS_INLINE KInt Kotlin_Byte_mod_Int (KByte a, KInt b) { return a % b; }
ALWAYS_INLINE KLong Kotlin_Byte_mod_Long (KByte a, KLong b) { return a % b; }
ALWAYS_INLINE KFloat Kotlin_Byte_mod_Float (KByte a, KFloat b) { return fmodf(a, b); }
ALWAYS_INLINE KDouble Kotlin_Byte_mod_Double (KByte a, KDouble b) { return fmod (a, b); }
KInt Kotlin_Byte_times_Byte (KByte a, KByte b) { return a * b; }
KInt Kotlin_Byte_times_Short (KByte a, KShort b) { return a * b; }
KInt Kotlin_Byte_times_Int (KByte a, KInt b) { return a * b; }
KLong Kotlin_Byte_times_Long (KByte a, KLong b) { return a * b; }
KFloat Kotlin_Byte_times_Float (KByte a, KFloat b) { return a * b; }
KDouble Kotlin_Byte_times_Double (KByte a, KDouble b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Byte_times_Byte (KByte a, KByte b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Byte_times_Short (KByte a, KShort b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Byte_times_Int (KByte a, KInt b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Byte_times_Long (KByte a, KLong b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Byte_times_Float (KByte a, KFloat b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Byte_times_Double (KByte a, KDouble b) { return a * b; }
KByte Kotlin_Byte_inc (KByte a ) { return ++a; }
KByte Kotlin_Byte_dec (KByte a ) { return --a; }
KInt Kotlin_Byte_unaryPlus (KByte a ) { return +a; }
KInt Kotlin_Byte_unaryMinus (KByte a ) { return -a; }
ALWAYS_INLINE KByte Kotlin_Byte_inc (KByte a ) { return ++a; }
ALWAYS_INLINE KByte Kotlin_Byte_dec (KByte a ) { return --a; }
ALWAYS_INLINE KInt Kotlin_Byte_unaryPlus (KByte a ) { return +a; }
ALWAYS_INLINE KInt Kotlin_Byte_unaryMinus (KByte a ) { return -a; }
KByte Kotlin_Byte_or_Byte (KByte a, KByte b) { return a | b; }
KByte Kotlin_Byte_xor_Byte (KByte a, KByte b) { return a ^ b; }
KByte Kotlin_Byte_and_Byte (KByte a, KByte b) { return a & b; }
KByte Kotlin_Byte_inv (KByte a ) { return ~a; }
ALWAYS_INLINE KByte Kotlin_Byte_or_Byte (KByte a, KByte b) { return a | b; }
ALWAYS_INLINE KByte Kotlin_Byte_xor_Byte (KByte a, KByte b) { return a ^ b; }
ALWAYS_INLINE KByte Kotlin_Byte_and_Byte (KByte a, KByte b) { return a & b; }
ALWAYS_INLINE KByte Kotlin_Byte_inv (KByte a ) { return ~a; }
KByte Kotlin_Byte_toByte (KByte a ) { return a; }
KChar Kotlin_Byte_toChar (KByte a ) { return a; }
KShort Kotlin_Byte_toShort (KByte a ) { return a; }
KInt Kotlin_Byte_toInt (KByte a ) { return a; }
KLong Kotlin_Byte_toLong (KByte a ) { return a; }
KFloat Kotlin_Byte_toFloat (KByte a ) { return a; }
KDouble Kotlin_Byte_toDouble (KByte a ) { return a; }
ALWAYS_INLINE KByte Kotlin_Byte_toByte (KByte a ) { return a; }
ALWAYS_INLINE KChar Kotlin_Byte_toChar (KByte a ) { return a; }
ALWAYS_INLINE KShort Kotlin_Byte_toShort (KByte a ) { return a; }
ALWAYS_INLINE KInt Kotlin_Byte_toInt (KByte a ) { return a; }
ALWAYS_INLINE KLong Kotlin_Byte_toLong (KByte a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Byte_toFloat (KByte a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Byte_toDouble (KByte a ) { return a; }
//--- Short -------------------------------------------------------------------//
@@ -130,58 +132,58 @@ KInt Kotlin_Short_compareTo_Long (KShort a, KLong b) { if (a == b) return
KInt Kotlin_Short_compareTo_Float (KShort a, KFloat b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Short_compareTo_Double (KShort a, KDouble b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Short_plus_Byte (KShort a, KByte b) { return a + b; }
KInt Kotlin_Short_plus_Short (KShort a, KShort b) { return a + b; }
KInt Kotlin_Short_plus_Int (KShort a, KInt b) { return a + b; }
KLong Kotlin_Short_plus_Long (KShort a, KLong b) { return a + b; }
KFloat Kotlin_Short_plus_Float (KShort a, KFloat b) { return a + b; }
KDouble Kotlin_Short_plus_Double (KShort a, KDouble b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Short_plus_Byte (KShort a, KByte b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Short_plus_Short (KShort a, KShort b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Short_plus_Int (KShort a, KInt b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Short_plus_Long (KShort a, KLong b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Short_plus_Float (KShort a, KFloat b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Short_plus_Double (KShort a, KDouble b) { return a + b; }
KInt Kotlin_Short_minus_Byte (KShort a, KByte b) { return a - b; }
KInt Kotlin_Short_minus_Short (KShort a, KShort b) { return a - b; }
KInt Kotlin_Short_minus_Int (KShort a, KInt b) { return a - b; }
KLong Kotlin_Short_minus_Long (KShort a, KLong b) { return a - b; }
KFloat Kotlin_Short_minus_Float (KShort a, KFloat b) { return a - b; }
KDouble Kotlin_Short_minus_Double (KShort a, KDouble b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Short_minus_Byte (KShort a, KByte b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Short_minus_Short (KShort a, KShort b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Short_minus_Int (KShort a, KInt b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Short_minus_Long (KShort a, KLong b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Short_minus_Float (KShort a, KFloat b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Short_minus_Double (KShort a, KDouble b) { return a - b; }
KInt Kotlin_Short_div_Byte (KShort a, KByte b) { return div<KInt>(a, b); }
KInt Kotlin_Short_div_Short (KShort a, KShort b) { return div<KInt>(a, b); }
KInt Kotlin_Short_div_Int (KShort a, KInt b) { return div<KInt>(a, b); }
KLong Kotlin_Short_div_Long (KShort a, KLong b) { return div<KLong>(a, b); }
KFloat Kotlin_Short_div_Float (KShort a, KFloat b) { return a / b; }
KDouble Kotlin_Short_div_Double (KShort a, KDouble b) { return a / b; }
ALWAYS_INLINE KInt Kotlin_Short_div_Byte (KShort a, KByte b) { return div<KInt>(a, b); }
ALWAYS_INLINE KInt Kotlin_Short_div_Short (KShort a, KShort b) { return div<KInt>(a, b); }
ALWAYS_INLINE KInt Kotlin_Short_div_Int (KShort a, KInt b) { return div<KInt>(a, b); }
ALWAYS_INLINE KLong Kotlin_Short_div_Long (KShort a, KLong b) { return div<KLong>(a, b); }
ALWAYS_INLINE KFloat Kotlin_Short_div_Float (KShort a, KFloat b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Short_div_Double (KShort a, KDouble b) { return a / b; }
KInt Kotlin_Short_mod_Byte (KShort a, KByte b) { return a % b; }
KInt Kotlin_Short_mod_Short (KShort a, KShort b) { return a % b; }
KInt Kotlin_Short_mod_Int (KShort a, KInt b) { return a % b; }
KLong Kotlin_Short_mod_Long (KShort a, KLong b) { return a % b; }
KFloat Kotlin_Short_mod_Float (KShort a, KFloat b) { return fmodf(a, b); }
KDouble Kotlin_Short_mod_Double (KShort a, KDouble b) { return fmod (a, b); }
ALWAYS_INLINE KInt Kotlin_Short_mod_Byte (KShort a, KByte b) { return a % b; }
ALWAYS_INLINE KInt Kotlin_Short_mod_Short (KShort a, KShort b) { return a % b; }
ALWAYS_INLINE KInt Kotlin_Short_mod_Int (KShort a, KInt b) { return a % b; }
ALWAYS_INLINE KLong Kotlin_Short_mod_Long (KShort a, KLong b) { return a % b; }
ALWAYS_INLINE KFloat Kotlin_Short_mod_Float (KShort a, KFloat b) { return fmodf(a, b); }
ALWAYS_INLINE KDouble Kotlin_Short_mod_Double (KShort a, KDouble b) { return fmod (a, b); }
KInt Kotlin_Short_times_Byte (KShort a, KByte b) { return a * b; }
KInt Kotlin_Short_times_Short (KShort a, KShort b) { return a * b; }
KInt Kotlin_Short_times_Int (KShort a, KInt b) { return a * b; }
KLong Kotlin_Short_times_Long (KShort a, KLong b) { return a * b; }
KFloat Kotlin_Short_times_Float (KShort a, KFloat b) { return a * b; }
KDouble Kotlin_Short_times_Double (KShort a, KDouble b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Short_times_Byte (KShort a, KByte b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Short_times_Short (KShort a, KShort b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Short_times_Int (KShort a, KInt b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Short_times_Long (KShort a, KLong b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Short_times_Float (KShort a, KFloat b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Short_times_Double (KShort a, KDouble b) { return a * b; }
KShort Kotlin_Short_inc (KShort a ) { return ++a; }
KShort Kotlin_Short_dec (KShort a ) { return --a; }
KInt Kotlin_Short_unaryPlus (KShort a ) { return +a; }
KInt Kotlin_Short_unaryMinus (KShort a ) { return -a; }
ALWAYS_INLINE KShort Kotlin_Short_inc (KShort a ) { return ++a; }
ALWAYS_INLINE KShort Kotlin_Short_dec (KShort a ) { return --a; }
ALWAYS_INLINE KInt Kotlin_Short_unaryPlus (KShort a ) { return +a; }
ALWAYS_INLINE KInt Kotlin_Short_unaryMinus (KShort a ) { return -a; }
KShort Kotlin_Short_or_Short (KShort a, KShort b) { return a | b; }
KShort Kotlin_Short_xor_Short (KShort a, KShort b) { return a ^ b; }
KShort Kotlin_Short_and_Short (KShort a, KShort b) { return a & b; }
KShort Kotlin_Short_inv (KShort a ) { return ~a; }
ALWAYS_INLINE KShort Kotlin_Short_or_Short (KShort a, KShort b) { return a | b; }
ALWAYS_INLINE KShort Kotlin_Short_xor_Short (KShort a, KShort b) { return a ^ b; }
ALWAYS_INLINE KShort Kotlin_Short_and_Short (KShort a, KShort b) { return a & b; }
ALWAYS_INLINE KShort Kotlin_Short_inv (KShort a ) { return ~a; }
KByte Kotlin_Short_toByte (KShort a ) { return a; }
KChar Kotlin_Short_toChar (KShort a ) { return a; }
KShort Kotlin_Short_toShort (KShort a ) { return a; }
KInt Kotlin_Short_toInt (KShort a ) { return a; }
KLong Kotlin_Short_toLong (KShort a ) { return a; }
KFloat Kotlin_Short_toFloat (KShort a ) { return a; }
KDouble Kotlin_Short_toDouble (KShort a ) { return a; }
ALWAYS_INLINE KByte Kotlin_Short_toByte (KShort a ) { return a; }
ALWAYS_INLINE KChar Kotlin_Short_toChar (KShort a ) { return a; }
ALWAYS_INLINE KShort Kotlin_Short_toShort (KShort a ) { return a; }
ALWAYS_INLINE KInt Kotlin_Short_toInt (KShort a ) { return a; }
ALWAYS_INLINE KLong Kotlin_Short_toLong (KShort a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Short_toFloat (KShort a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Short_toDouble (KShort a ) { return a; }
//--- Int ---------------------------------------------------------------------//
@@ -192,66 +194,66 @@ KInt Kotlin_Int_compareTo_Long (KInt a, KLong b) { if (a == b) return 0;
KInt Kotlin_Int_compareTo_Float (KInt a, KFloat b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Int_compareTo_Double (KInt a, KDouble b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Int_plus_Byte (KInt a, KByte b) { return a + b; }
KInt Kotlin_Int_plus_Short (KInt a, KShort b) { return a + b; }
KInt Kotlin_Int_plus_Int (KInt a, KInt b) { return a + b; }
KLong Kotlin_Int_plus_Long (KInt a, KLong b) { return a + b; }
KFloat Kotlin_Int_plus_Float (KInt a, KFloat b) { return a + b; }
KDouble Kotlin_Int_plus_Double (KInt a, KDouble b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Int_plus_Byte (KInt a, KByte b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Int_plus_Short (KInt a, KShort b) { return a + b; }
ALWAYS_INLINE KInt Kotlin_Int_plus_Int (KInt a, KInt b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Int_plus_Long (KInt a, KLong b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Int_plus_Float (KInt a, KFloat b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Int_plus_Double (KInt a, KDouble b) { return a + b; }
KInt Kotlin_Int_minus_Byte (KInt a, KByte b) { return a - b; }
KInt Kotlin_Int_minus_Short (KInt a, KShort b) { return a - b; }
KInt Kotlin_Int_minus_Int (KInt a, KInt b) { return a - b; }
KLong Kotlin_Int_minus_Long (KInt a, KLong b) { return a - b; }
KFloat Kotlin_Int_minus_Float (KInt a, KFloat b) { return a - b; }
KDouble Kotlin_Int_minus_Double (KInt a, KDouble b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Int_minus_Byte (KInt a, KByte b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Int_minus_Short (KInt a, KShort b) { return a - b; }
ALWAYS_INLINE KInt Kotlin_Int_minus_Int (KInt a, KInt b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Int_minus_Long (KInt a, KLong b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Int_minus_Float (KInt a, KFloat b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Int_minus_Double (KInt a, KDouble b) { return a - b; }
KInt Kotlin_Int_div_Byte (KInt a, KByte b) { return div<KInt>(a, b); }
KInt Kotlin_Int_div_Short (KInt a, KShort b) { return div<KInt>(a, b); }
KInt Kotlin_Int_div_Int (KInt a, KInt b) { return div<KInt>(a, b); }
KLong Kotlin_Int_div_Long (KInt a, KLong b) { return div<KLong>(a, b); }
KFloat Kotlin_Int_div_Float (KInt a, KFloat b) { return a / b; }
KDouble Kotlin_Int_div_Double (KInt a, KDouble b) { return a / b; }
ALWAYS_INLINE KInt Kotlin_Int_div_Byte (KInt a, KByte b) { return div<KInt>(a, b); }
ALWAYS_INLINE KInt Kotlin_Int_div_Short (KInt a, KShort b) { return div<KInt>(a, b); }
ALWAYS_INLINE KInt Kotlin_Int_div_Int (KInt a, KInt b) { return div<KInt>(a, b); }
ALWAYS_INLINE KLong Kotlin_Int_div_Long (KInt a, KLong b) { return div<KLong>(a, b); }
ALWAYS_INLINE KFloat Kotlin_Int_div_Float (KInt a, KFloat b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Int_div_Double (KInt a, KDouble b) { return a / b; }
KInt Kotlin_Int_mod_Byte (KInt a, KByte b) { return a % b; }
KInt Kotlin_Int_mod_Short (KInt a, KShort b) { return a % b; }
KInt Kotlin_Int_mod_Int (KInt a, KInt b) { return a % b; }
KLong Kotlin_Int_mod_Long (KInt a, KLong b) { return a % b; }
KFloat Kotlin_Int_mod_Float (KInt a, KFloat b) { return fmodf(a, b); }
KDouble Kotlin_Int_mod_Double (KInt a, KDouble b) { return fmod (a, b); }
ALWAYS_INLINE KInt Kotlin_Int_mod_Byte (KInt a, KByte b) { return a % b; }
ALWAYS_INLINE KInt Kotlin_Int_mod_Short (KInt a, KShort b) { return a % b; }
ALWAYS_INLINE KInt Kotlin_Int_mod_Int (KInt a, KInt b) { return a % b; }
ALWAYS_INLINE KLong Kotlin_Int_mod_Long (KInt a, KLong b) { return a % b; }
ALWAYS_INLINE KFloat Kotlin_Int_mod_Float (KInt a, KFloat b) { return fmodf(a, b); }
ALWAYS_INLINE KDouble Kotlin_Int_mod_Double (KInt a, KDouble b) { return fmod (a, b); }
KInt Kotlin_Int_times_Byte (KInt a, KByte b) { return a * b; }
KInt Kotlin_Int_times_Short (KInt a, KShort b) { return a * b; }
KInt Kotlin_Int_times_Int (KInt a, KInt b) { return a * b; }
KLong Kotlin_Int_times_Long (KInt a, KLong b) { return a * b; }
KFloat Kotlin_Int_times_Float (KInt a, KFloat b) { return a * b; }
KDouble Kotlin_Int_times_Double (KInt a, KDouble b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Int_times_Byte (KInt a, KByte b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Int_times_Short (KInt a, KShort b) { return a * b; }
ALWAYS_INLINE KInt Kotlin_Int_times_Int (KInt a, KInt b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Int_times_Long (KInt a, KLong b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Int_times_Float (KInt a, KFloat b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Int_times_Double (KInt a, KDouble b) { return a * b; }
KInt Kotlin_Int_inc (KInt a ) { return ++a; }
KInt Kotlin_Int_dec (KInt a ) { return --a; }
KInt Kotlin_Int_unaryPlus (KInt a ) { return +a; }
KInt Kotlin_Int_unaryMinus (KInt a ) { return -a; }
ALWAYS_INLINE KInt Kotlin_Int_inc (KInt a ) { return ++a; }
ALWAYS_INLINE KInt Kotlin_Int_dec (KInt a ) { return --a; }
ALWAYS_INLINE KInt Kotlin_Int_unaryPlus (KInt a ) { return +a; }
ALWAYS_INLINE KInt Kotlin_Int_unaryMinus (KInt a ) { return -a; }
KInt Kotlin_Int_or_Int (KInt a, KInt b) { return a | b; }
KInt Kotlin_Int_xor_Int (KInt a, KInt b) { return a ^ b; }
KInt Kotlin_Int_and_Int (KInt a, KInt b) { return a & b; }
KInt Kotlin_Int_inv (KInt a ) { return ~a; }
ALWAYS_INLINE KInt Kotlin_Int_or_Int (KInt a, KInt b) { return a | b; }
ALWAYS_INLINE KInt Kotlin_Int_xor_Int (KInt a, KInt b) { return a ^ b; }
ALWAYS_INLINE KInt Kotlin_Int_and_Int (KInt a, KInt b) { return a & b; }
ALWAYS_INLINE KInt Kotlin_Int_inv (KInt a ) { return ~a; }
// According to C++11 the result is undefined if the second operator is < 0 or >= <first operand bit length>.
// We avoid it by using only the least significant bits
KInt Kotlin_Int_shl_Int (KInt a, KInt b) { return a << (b & 31); }
KInt Kotlin_Int_shr_Int (KInt a, KInt b) { return a >> (b & 31); }
KInt Kotlin_Int_ushr_Int (KInt a, KInt b) {
ALWAYS_INLINE KInt Kotlin_Int_shl_Int (KInt a, KInt b) { return a << (b & 31); }
ALWAYS_INLINE KInt Kotlin_Int_shr_Int (KInt a, KInt b) { return a >> (b & 31); }
ALWAYS_INLINE KInt Kotlin_Int_ushr_Int (KInt a, KInt b) {
return static_cast<uint32_t>(a) >> (b & 31);
}
KByte Kotlin_Int_toByte (KInt a ) { return a; }
KChar Kotlin_Int_toChar (KInt a ) { return a; }
KShort Kotlin_Int_toShort (KInt a ) { return a; }
KInt Kotlin_Int_toInt (KInt a ) { return a; }
KLong Kotlin_Int_toLong (KInt a ) { return a; }
KFloat Kotlin_Int_toFloat (KInt a ) { return a; }
KDouble Kotlin_Int_toDouble (KInt a ) { return a; }
ALWAYS_INLINE KByte Kotlin_Int_toByte (KInt a ) { return a; }
ALWAYS_INLINE KChar Kotlin_Int_toChar (KInt a ) { return a; }
ALWAYS_INLINE KShort Kotlin_Int_toShort (KInt a ) { return a; }
ALWAYS_INLINE KInt Kotlin_Int_toInt (KInt a ) { return a; }
ALWAYS_INLINE KLong Kotlin_Int_toLong (KInt a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Int_toFloat (KInt a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Int_toDouble (KInt a ) { return a; }
//--- Long --------------------------------------------------------------------//
@@ -262,108 +264,108 @@ KInt Kotlin_Long_compareTo_Long (KLong a, KLong b) { if (a == b) return 0
KInt Kotlin_Long_compareTo_Float (KLong a, KFloat b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KInt Kotlin_Long_compareTo_Double (KLong a, KDouble b) { if (a == b) return 0; return (a < b) ? -1 : 1; }
KLong Kotlin_Long_plus_Byte (KLong a, KByte b) { return a + b; }
KLong Kotlin_Long_plus_Short (KLong a, KShort b) { return a + b; }
KLong Kotlin_Long_plus_Int (KLong a, KInt b) { return a + b; }
KLong Kotlin_Long_plus_Long (KLong a, KLong b) { return a + b; }
KFloat Kotlin_Long_plus_Float (KLong a, KFloat b) { return a + b; }
KDouble Kotlin_Long_plus_Double (KLong a, KDouble b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Long_plus_Byte (KLong a, KByte b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Long_plus_Short (KLong a, KShort b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Long_plus_Int (KLong a, KInt b) { return a + b; }
ALWAYS_INLINE KLong Kotlin_Long_plus_Long (KLong a, KLong b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Long_plus_Float (KLong a, KFloat b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Long_plus_Double (KLong a, KDouble b) { return a + b; }
KLong Kotlin_Long_minus_Byte (KLong a, KByte b) { return a - b; }
KLong Kotlin_Long_minus_Short (KLong a, KShort b) { return a - b; }
KLong Kotlin_Long_minus_Int (KLong a, KInt b) { return a - b; }
KLong Kotlin_Long_minus_Long (KLong a, KLong b) { return a - b; }
KFloat Kotlin_Long_minus_Float (KLong a, KFloat b) { return a - b; }
KDouble Kotlin_Long_minus_Double (KLong a, KDouble b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Long_minus_Byte (KLong a, KByte b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Long_minus_Short (KLong a, KShort b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Long_minus_Int (KLong a, KInt b) { return a - b; }
ALWAYS_INLINE KLong Kotlin_Long_minus_Long (KLong a, KLong b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Long_minus_Float (KLong a, KFloat b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Long_minus_Double (KLong a, KDouble b) { return a - b; }
KLong Kotlin_Long_div_Byte (KLong a, KByte b) { return div<KLong>(a, b); }
KLong Kotlin_Long_div_Short (KLong a, KShort b) { return div<KLong>(a, b); }
KLong Kotlin_Long_div_Int (KLong a, KInt b) { return div<KLong>(a, b); }
KLong Kotlin_Long_div_Long (KLong a, KLong b) { return div<KLong>(a, b); }
KFloat Kotlin_Long_div_Float (KLong a, KFloat b) { return a / b; }
KDouble Kotlin_Long_div_Double (KLong a, KDouble b) { return a / b; }
ALWAYS_INLINE KLong Kotlin_Long_div_Byte (KLong a, KByte b) { return div<KLong>(a, b); }
ALWAYS_INLINE KLong Kotlin_Long_div_Short (KLong a, KShort b) { return div<KLong>(a, b); }
ALWAYS_INLINE KLong Kotlin_Long_div_Int (KLong a, KInt b) { return div<KLong>(a, b); }
ALWAYS_INLINE KLong Kotlin_Long_div_Long (KLong a, KLong b) { return div<KLong>(a, b); }
ALWAYS_INLINE KFloat Kotlin_Long_div_Float (KLong a, KFloat b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Long_div_Double (KLong a, KDouble b) { return a / b; }
KLong Kotlin_Long_mod_Byte (KLong a, KByte b) { return a % b; }
KLong Kotlin_Long_mod_Short (KLong a, KShort b) { return a % b; }
KLong Kotlin_Long_mod_Int (KLong a, KInt b) { return a % b; }
KLong Kotlin_Long_mod_Long (KLong a, KLong b) { return a % b; }
KFloat Kotlin_Long_mod_Float (KLong a, KFloat b) { return fmodf(a, b); }
KDouble Kotlin_Long_mod_Double (KLong a, KDouble b) { return fmod (a, b); }
ALWAYS_INLINE KLong Kotlin_Long_mod_Byte (KLong a, KByte b) { return a % b; }
ALWAYS_INLINE KLong Kotlin_Long_mod_Short (KLong a, KShort b) { return a % b; }
ALWAYS_INLINE KLong Kotlin_Long_mod_Int (KLong a, KInt b) { return a % b; }
ALWAYS_INLINE KLong Kotlin_Long_mod_Long (KLong a, KLong b) { return a % b; }
ALWAYS_INLINE KFloat Kotlin_Long_mod_Float (KLong a, KFloat b) { return fmodf(a, b); }
ALWAYS_INLINE KDouble Kotlin_Long_mod_Double (KLong a, KDouble b) { return fmod (a, b); }
KLong Kotlin_Long_times_Byte (KLong a, KByte b) { return a * b; }
KLong Kotlin_Long_times_Short (KLong a, KShort b) { return a * b; }
KLong Kotlin_Long_times_Int (KLong a, KInt b) { return a * b; }
KLong Kotlin_Long_times_Long (KLong a, KLong b) { return a * b; }
KFloat Kotlin_Long_times_Float (KLong a, KFloat b) { return a * b; }
KDouble Kotlin_Long_times_Double (KLong a, KDouble b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Long_times_Byte (KLong a, KByte b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Long_times_Short (KLong a, KShort b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Long_times_Int (KLong a, KInt b) { return a * b; }
ALWAYS_INLINE KLong Kotlin_Long_times_Long (KLong a, KLong b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Long_times_Float (KLong a, KFloat b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Long_times_Double (KLong a, KDouble b) { return a * b; }
KLong Kotlin_Long_inc (KLong a ) { return ++a; }
KLong Kotlin_Long_dec (KLong a ) { return --a; }
KLong Kotlin_Long_unaryPlus (KLong a ) { return +a; }
KLong Kotlin_Long_unaryMinus (KLong a ) { return -a; }
ALWAYS_INLINE KLong Kotlin_Long_inc (KLong a ) { return ++a; }
ALWAYS_INLINE KLong Kotlin_Long_dec (KLong a ) { return --a; }
ALWAYS_INLINE KLong Kotlin_Long_unaryPlus (KLong a ) { return +a; }
ALWAYS_INLINE KLong Kotlin_Long_unaryMinus (KLong a ) { return -a; }
KLong Kotlin_Long_xor_Long (KLong a, KLong b) { return a ^ b; }
KLong Kotlin_Long_or_Long (KLong a, KLong b) { return a | b; }
KLong Kotlin_Long_and_Long (KLong a, KLong b) { return a & b; }
KLong Kotlin_Long_inv (KLong a ) { return ~a; }
ALWAYS_INLINE KLong Kotlin_Long_xor_Long (KLong a, KLong b) { return a ^ b; }
ALWAYS_INLINE KLong Kotlin_Long_or_Long (KLong a, KLong b) { return a | b; }
ALWAYS_INLINE KLong Kotlin_Long_and_Long (KLong a, KLong b) { return a & b; }
ALWAYS_INLINE KLong Kotlin_Long_inv (KLong a ) { return ~a; }
// According to C++11 the result is undefined if the second operator is < 0 or >= <first operand bit length>.
// We avoid it by using only the least significant bits
KLong Kotlin_Long_shl_Int (KLong a, KInt b) { return a << (b & 63); }
KLong Kotlin_Long_shr_Int (KLong a, KInt b) { return a >> (b & 63); }
KLong Kotlin_Long_ushr_Int (KLong a, KInt b) {
ALWAYS_INLINE KLong Kotlin_Long_shl_Int (KLong a, KInt b) { return a << (b & 63); }
ALWAYS_INLINE KLong Kotlin_Long_shr_Int (KLong a, KInt b) { return a >> (b & 63); }
ALWAYS_INLINE KLong Kotlin_Long_ushr_Int (KLong a, KInt b) {
return static_cast<uint64_t>(a) >> (b & 63);
}
KByte Kotlin_Long_toByte (KLong a ) { return a; }
KChar Kotlin_Long_toChar (KLong a ) { return a; }
KShort Kotlin_Long_toShort (KLong a ) { return a; }
KInt Kotlin_Long_toInt (KLong a ) { return a; }
KLong Kotlin_Long_toLong (KLong a ) { return a; }
KFloat Kotlin_Long_toFloat (KLong a ) { return a; }
KDouble Kotlin_Long_toDouble (KLong a ) { return a; }
ALWAYS_INLINE KByte Kotlin_Long_toByte (KLong a ) { return a; }
ALWAYS_INLINE KChar Kotlin_Long_toChar (KLong a ) { return a; }
ALWAYS_INLINE KShort Kotlin_Long_toShort (KLong a ) { return a; }
ALWAYS_INLINE KInt Kotlin_Long_toInt (KLong a ) { return a; }
ALWAYS_INLINE KLong Kotlin_Long_toLong (KLong a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Long_toFloat (KLong a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Long_toDouble (KLong a ) { return a; }
//--- Float -------------------------------------------------------------------//
KFloat Kotlin_Float_plus_Byte (KFloat a, KByte b) { return a + b; }
KFloat Kotlin_Float_plus_Short (KFloat a, KShort b) { return a + b; }
KFloat Kotlin_Float_plus_Int (KFloat a, KInt b) { return a + b; }
KFloat Kotlin_Float_plus_Long (KFloat a, KLong b) { return a + b; }
KFloat Kotlin_Float_plus_Float (KFloat a, KFloat b) { return a + b; }
KDouble Kotlin_Float_plus_Double (KFloat a, KDouble b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Float_plus_Byte (KFloat a, KByte b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Float_plus_Short (KFloat a, KShort b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Float_plus_Int (KFloat a, KInt b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Float_plus_Long (KFloat a, KLong b) { return a + b; }
ALWAYS_INLINE KFloat Kotlin_Float_plus_Float (KFloat a, KFloat b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Float_plus_Double (KFloat a, KDouble b) { return a + b; }
KFloat Kotlin_Float_minus_Byte (KFloat a, KByte b) { return a - b; }
KFloat Kotlin_Float_minus_Short (KFloat a, KShort b) { return a - b; }
KFloat Kotlin_Float_minus_Int (KFloat a, KInt b) { return a - b; }
KFloat Kotlin_Float_minus_Long (KFloat a, KLong b) { return a - b; }
KFloat Kotlin_Float_minus_Float (KFloat a, KFloat b) { return a - b; }
KDouble Kotlin_Float_minus_Double (KFloat a, KDouble b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Float_minus_Byte (KFloat a, KByte b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Float_minus_Short (KFloat a, KShort b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Float_minus_Int (KFloat a, KInt b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Float_minus_Long (KFloat a, KLong b) { return a - b; }
ALWAYS_INLINE KFloat Kotlin_Float_minus_Float (KFloat a, KFloat b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Float_minus_Double (KFloat a, KDouble b) { return a - b; }
KFloat Kotlin_Float_div_Byte (KFloat a, KByte b) { return a / b; }
KFloat Kotlin_Float_div_Short (KFloat a, KShort b) { return a / b; }
KFloat Kotlin_Float_div_Int (KFloat a, KInt b) { return a / b; }
KFloat Kotlin_Float_div_Long (KFloat a, KLong b) { return a / b; }
KFloat Kotlin_Float_div_Float (KFloat a, KFloat b) { return a / b; }
KDouble Kotlin_Float_div_Double (KFloat a, KDouble b) { return a / b; }
ALWAYS_INLINE KFloat Kotlin_Float_div_Byte (KFloat a, KByte b) { return a / b; }
ALWAYS_INLINE KFloat Kotlin_Float_div_Short (KFloat a, KShort b) { return a / b; }
ALWAYS_INLINE KFloat Kotlin_Float_div_Int (KFloat a, KInt b) { return a / b; }
ALWAYS_INLINE KFloat Kotlin_Float_div_Long (KFloat a, KLong b) { return a / b; }
ALWAYS_INLINE KFloat Kotlin_Float_div_Float (KFloat a, KFloat b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Float_div_Double (KFloat a, KDouble b) { return a / b; }
KFloat Kotlin_Float_mod_Byte (KFloat a, KByte b) { return fmodf(a, b); }
KFloat Kotlin_Float_mod_Short (KFloat a, KShort b) { return fmodf(a, b); }
KFloat Kotlin_Float_mod_Int (KFloat a, KInt b) { return fmodf(a, b); }
KFloat Kotlin_Float_mod_Long (KFloat a, KLong b) { return fmodf(a, b); }
KFloat Kotlin_Float_mod_Float (KFloat a, KFloat b) { return fmodf(a, b); }
KDouble Kotlin_Float_mod_Double (KFloat a, KDouble b) { return fmod (a, b); }
ALWAYS_INLINE KFloat Kotlin_Float_mod_Byte (KFloat a, KByte b) { return fmodf(a, b); }
ALWAYS_INLINE KFloat Kotlin_Float_mod_Short (KFloat a, KShort b) { return fmodf(a, b); }
ALWAYS_INLINE KFloat Kotlin_Float_mod_Int (KFloat a, KInt b) { return fmodf(a, b); }
ALWAYS_INLINE KFloat Kotlin_Float_mod_Long (KFloat a, KLong b) { return fmodf(a, b); }
ALWAYS_INLINE KFloat Kotlin_Float_mod_Float (KFloat a, KFloat b) { return fmodf(a, b); }
ALWAYS_INLINE KDouble Kotlin_Float_mod_Double (KFloat a, KDouble b) { return fmod (a, b); }
KFloat Kotlin_Float_times_Byte (KFloat a, KByte b) { return a * b; }
KFloat Kotlin_Float_times_Short (KFloat a, KShort b) { return a * b; }
KFloat Kotlin_Float_times_Int (KFloat a, KInt b) { return a * b; }
KFloat Kotlin_Float_times_Long (KFloat a, KLong b) { return a * b; }
KFloat Kotlin_Float_times_Float (KFloat a, KFloat b) { return a * b; }
KDouble Kotlin_Float_times_Double (KFloat a, KDouble b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Float_times_Byte (KFloat a, KByte b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Float_times_Short (KFloat a, KShort b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Float_times_Int (KFloat a, KInt b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Float_times_Long (KFloat a, KLong b) { return a * b; }
ALWAYS_INLINE KFloat Kotlin_Float_times_Float (KFloat a, KFloat b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Float_times_Double (KFloat a, KDouble b) { return a * b; }
KFloat Kotlin_Float_inc (KFloat a ) { return ++a; }
KFloat Kotlin_Float_dec (KFloat a ) { return --a; }
KFloat Kotlin_Float_unaryPlus (KFloat a ) { return +a; }
KFloat Kotlin_Float_unaryMinus (KFloat a ) { return -a; }
ALWAYS_INLINE KFloat Kotlin_Float_inc (KFloat a ) { return ++a; }
ALWAYS_INLINE KFloat Kotlin_Float_dec (KFloat a ) { return --a; }
ALWAYS_INLINE KFloat Kotlin_Float_unaryPlus (KFloat a ) { return +a; }
ALWAYS_INLINE KFloat Kotlin_Float_unaryMinus (KFloat a ) { return -a; }
KInt Kotlin_Float_toInt (KFloat a ) {
if (isnan(a)) return 0;
@@ -377,59 +379,59 @@ KLong Kotlin_Float_toLong (KFloat a ) {
if (a <= (KFloat) INT64_MIN) return INT64_MIN;
return a;
}
KFloat Kotlin_Float_toFloat (KFloat a ) { return a; }
KDouble Kotlin_Float_toDouble (KFloat a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Float_toFloat (KFloat a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Float_toDouble (KFloat a ) { return a; }
KByte Kotlin_Float_toByte (KFloat a ) { return (KByte) Kotlin_Float_toInt(a); }
KShort Kotlin_Float_toShort (KFloat a ) { return (KShort) Kotlin_Float_toInt(a); }
KInt Kotlin_Float_bits (KFloat a ) { return floatToBits(a); }
KFloat Kotlin_Float_fromBits (KInt a ) { return bitsToFloat(a); }
ALWAYS_INLINE KInt Kotlin_Float_bits (KFloat a ) { return floatToBits(a); }
ALWAYS_INLINE KFloat Kotlin_Float_fromBits (KInt a ) { return bitsToFloat(a); }
KBoolean Kotlin_Float_isNaN (KFloat a) { return isnan(a); }
KBoolean Kotlin_Float_isInfinite (KFloat a) { return isinf(a); }
KBoolean Kotlin_Float_isFinite (KFloat a) { return isfinite(a); }
ALWAYS_INLINE KBoolean Kotlin_Float_isNaN (KFloat a) { return isnan(a); }
ALWAYS_INLINE KBoolean Kotlin_Float_isInfinite (KFloat a) { return isinf(a); }
ALWAYS_INLINE KBoolean Kotlin_Float_isFinite (KFloat a) { return isfinite(a); }
//--- Double ------------------------------------------------------------------//
KDouble Kotlin_Double_plus_Byte (KDouble a, KByte b) { return a + b; }
KDouble Kotlin_Double_plus_Short (KDouble a, KShort b) { return a + b; }
KDouble Kotlin_Double_plus_Int (KDouble a, KInt b) { return a + b; }
KDouble Kotlin_Double_plus_Long (KDouble a, KLong b) { return a + b; }
KDouble Kotlin_Double_plus_Float (KDouble a, KFloat b) { return a + b; }
KDouble Kotlin_Double_plus_Double (KDouble a, KDouble b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Double_plus_Byte (KDouble a, KByte b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Double_plus_Short (KDouble a, KShort b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Double_plus_Int (KDouble a, KInt b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Double_plus_Long (KDouble a, KLong b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Double_plus_Float (KDouble a, KFloat b) { return a + b; }
ALWAYS_INLINE KDouble Kotlin_Double_plus_Double (KDouble a, KDouble b) { return a + b; }
KDouble Kotlin_Double_minus_Byte (KDouble a, KByte b) { return a - b; }
KDouble Kotlin_Double_minus_Short (KDouble a, KShort b) { return a - b; }
KDouble Kotlin_Double_minus_Int (KDouble a, KInt b) { return a - b; }
KDouble Kotlin_Double_minus_Long (KDouble a, KLong b) { return a - b; }
KDouble Kotlin_Double_minus_Float (KDouble a, KFloat b) { return a - b; }
KDouble Kotlin_Double_minus_Double (KDouble a, KDouble b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Double_minus_Byte (KDouble a, KByte b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Double_minus_Short (KDouble a, KShort b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Double_minus_Int (KDouble a, KInt b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Double_minus_Long (KDouble a, KLong b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Double_minus_Float (KDouble a, KFloat b) { return a - b; }
ALWAYS_INLINE KDouble Kotlin_Double_minus_Double (KDouble a, KDouble b) { return a - b; }
KDouble Kotlin_Double_div_Byte (KDouble a, KByte b) { return a / b; }
KDouble Kotlin_Double_div_Short (KDouble a, KShort b) { return a / b; }
KDouble Kotlin_Double_div_Int (KDouble a, KInt b) { return a / b; }
KDouble Kotlin_Double_div_Long (KDouble a, KLong b) { return a / b; }
KDouble Kotlin_Double_div_Float (KDouble a, KFloat b) { return a / b; }
KDouble Kotlin_Double_div_Double (KDouble a, KDouble b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Double_div_Byte (KDouble a, KByte b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Double_div_Short (KDouble a, KShort b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Double_div_Int (KDouble a, KInt b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Double_div_Long (KDouble a, KLong b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Double_div_Float (KDouble a, KFloat b) { return a / b; }
ALWAYS_INLINE KDouble Kotlin_Double_div_Double (KDouble a, KDouble b) { return a / b; }
KDouble Kotlin_Double_mod_Byte (KDouble a, KByte b) { return fmod(a, b); }
KDouble Kotlin_Double_mod_Short (KDouble a, KShort b) { return fmod(a, b); }
KDouble Kotlin_Double_mod_Int (KDouble a, KInt b) { return fmod(a, b); }
KDouble Kotlin_Double_mod_Long (KDouble a, KLong b) { return fmod(a, b); }
KDouble Kotlin_Double_mod_Float (KDouble a, KFloat b) { return fmod(a, b); }
KDouble Kotlin_Double_mod_Double (KDouble a, KDouble b) { return fmod(a, b); }
ALWAYS_INLINE KDouble Kotlin_Double_mod_Byte (KDouble a, KByte b) { return fmod(a, b); }
ALWAYS_INLINE KDouble Kotlin_Double_mod_Short (KDouble a, KShort b) { return fmod(a, b); }
ALWAYS_INLINE KDouble Kotlin_Double_mod_Int (KDouble a, KInt b) { return fmod(a, b); }
ALWAYS_INLINE KDouble Kotlin_Double_mod_Long (KDouble a, KLong b) { return fmod(a, b); }
ALWAYS_INLINE KDouble Kotlin_Double_mod_Float (KDouble a, KFloat b) { return fmod(a, b); }
ALWAYS_INLINE KDouble Kotlin_Double_mod_Double (KDouble a, KDouble b) { return fmod(a, b); }
KDouble Kotlin_Double_times_Byte (KDouble a, KByte b) { return a * b; }
KDouble Kotlin_Double_times_Short (KDouble a, KShort b) { return a * b; }
KDouble Kotlin_Double_times_Int (KDouble a, KInt b) { return a * b; }
KDouble Kotlin_Double_times_Long (KDouble a, KLong b) { return a * b; }
KDouble Kotlin_Double_times_Float (KDouble a, KFloat b) { return a * b; }
KDouble Kotlin_Double_times_Double (KDouble a, KDouble b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Double_times_Byte (KDouble a, KByte b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Double_times_Short (KDouble a, KShort b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Double_times_Int (KDouble a, KInt b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Double_times_Long (KDouble a, KLong b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Double_times_Float (KDouble a, KFloat b) { return a * b; }
ALWAYS_INLINE KDouble Kotlin_Double_times_Double (KDouble a, KDouble b) { return a * b; }
KDouble Kotlin_Double_inc (KDouble a ) { return ++a; }
KDouble Kotlin_Double_dec (KDouble a ) { return --a; }
KDouble Kotlin_Double_unaryPlus (KDouble a ) { return +a; }
KDouble Kotlin_Double_unaryMinus (KDouble a ) { return -a; }
ALWAYS_INLINE KDouble Kotlin_Double_inc (KDouble a ) { return ++a; }
ALWAYS_INLINE KDouble Kotlin_Double_dec (KDouble a ) { return --a; }
ALWAYS_INLINE KDouble Kotlin_Double_unaryPlus (KDouble a ) { return +a; }
ALWAYS_INLINE KDouble Kotlin_Double_unaryMinus (KDouble a ) { return -a; }
KInt Kotlin_Double_toInt (KDouble a ) {
if (isnan(a)) return 0;
@@ -444,14 +446,14 @@ KLong Kotlin_Double_toLong (KDouble a ) {
return a;
}
KFloat Kotlin_Double_toFloat (KDouble a ) { return a; }
KDouble Kotlin_Double_toDouble (KDouble a ) { return a; }
ALWAYS_INLINE KFloat Kotlin_Double_toFloat (KDouble a ) { return a; }
ALWAYS_INLINE KDouble Kotlin_Double_toDouble (KDouble a ) { return a; }
KLong Kotlin_Double_bits (KDouble a ) { return doubleToBits(a); }
KDouble Kotlin_Double_fromBits (KLong a ) { return bitsToDouble(a); }
ALWAYS_INLINE KLong Kotlin_Double_bits (KDouble a ) { return doubleToBits(a); }
ALWAYS_INLINE KDouble Kotlin_Double_fromBits (KLong a ) { return bitsToDouble(a); }
KBoolean Kotlin_Double_isNaN (KDouble a) { return isnan(a); }
KBoolean Kotlin_Double_isInfinite (KDouble a) { return isinf(a); }
KBoolean Kotlin_Double_isFinite (KDouble a) { return isfinite(a); }
ALWAYS_INLINE KBoolean Kotlin_Double_isNaN (KDouble a) { return isnan(a); }
ALWAYS_INLINE KBoolean Kotlin_Double_isInfinite (KDouble a) { return isinf(a); }
ALWAYS_INLINE KBoolean Kotlin_Double_isFinite (KDouble a) { return isfinite(a); }
} // extern "C"