wangtao
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Revert "Split single & double comparison routines into separate implementation 

files," for now, I missed some necesary updates.

llvm-svn: 128296
This commit is contained in:
Daniel Dunbar 2011-03-25 18:45:39 +00:00
parent 4fd2194638
commit 4c70f3e6ac
16 changed files with 121 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
compiler-rt/lib/ledf2.c → compiler-rt/lib/comparedf2.c
View File

@ -1,4 +1,4 @@
//===-- lib/ledf2.c - Double-precision comparisons ----------------*- C -*-===// //===-- lib/comparedf2.c - Double-precision comparisons -----------*- C -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@ -40,6 +40,13 @@
#define DOUBLE_PRECISION #define DOUBLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
enum LE_RESULT {
LE_LESS = -1,
LE_EQUAL = 0,
LE_GREATER = 1,
LE_UNORDERED = 1
};
enum LE_RESULT __ledf2(fp_t a, fp_t b) { enum LE_RESULT __ledf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
@ -71,3 +78,55 @@ enum LE_RESULT __ledf2(fp_t a, fp_t b) {
else return LE_GREATER; else return LE_GREATER;
} }
} }
enum GE_RESULT {
GE_LESS = -1,
GE_EQUAL = 0,
GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED
};
enum GE_RESULT __gedf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
if ((aAbs | bAbs) == 0) return GE_EQUAL;
if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
} else {
if (aInt > bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
}
}
int __unorddf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep;
}
// The following are alternative names for the preceeding routines.
enum LE_RESULT __eqdf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}
enum LE_RESULT __ltdf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}
enum LE_RESULT __nedf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}
enum GE_RESULT __gtdf2(fp_t a, fp_t b) {
return __gedf2(a, b);
}

60
compiler-rt/lib/lesf2.c → compiler-rt/lib/comparesf2.c
View File

@ -1,4 +1,4 @@
//===-- lib/lesf2.c - Single-precision comparisons ----------------*- C -*-===// //===-- lib/comparesf2.c - Single-precision comparisons -----------*- C -*-===//
// //
// The LLVM Compiler Infrastructure // The LLVM Compiler Infrastructure
// //
@ -40,6 +40,13 @@
#define SINGLE_PRECISION #define SINGLE_PRECISION
#include "fp_lib.h" #include "fp_lib.h"
enum LE_RESULT {
LE_LESS = -1,
LE_EQUAL = 0,
LE_GREATER = 1,
LE_UNORDERED = 1
};
enum LE_RESULT __lesf2(fp_t a, fp_t b) { enum LE_RESULT __lesf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a); const srep_t aInt = toRep(a);
@ -71,3 +78,54 @@ enum LE_RESULT __lesf2(fp_t a, fp_t b) {
else return LE_GREATER; else return LE_GREATER;
} }
} }
enum GE_RESULT {
GE_LESS = -1,
GE_EQUAL = 0,
GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED
};
enum GE_RESULT __gesf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
if ((aAbs | bAbs) == 0) return GE_EQUAL;
if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
} else {
if (aInt > bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
}
}
int __unordsf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep;
}
// The following are alternative names for the preceeding routines.
enum LE_RESULT __eqsf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}
enum LE_RESULT __ltsf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}
enum LE_RESULT __nesf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}
enum GE_RESULT __gtsf2(fp_t a, fp_t b) {
return __gesf2(a, b);
}

16
compiler-rt/lib/eqdf2.c
View File

@ -1,16 +0,0 @@
//===-- lib/eqdf2.c - Double-precision comparisons -----------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION
#include "fp_lib.h"
enum LE_RESULT __ledf2(fp_t a, fp_t b);
enum LE_RESULT __eqdf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}

16
compiler-rt/lib/eqsf2.c
View File

@ -1,16 +0,0 @@
//===-- lib/comparesf2.c - Single-precision comparisons -----------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define SINGLE_PRECISION
#include "fp_lib.h"
enum LE_RESULT __lesf2(fp_t a, fp_t b);
enum LE_RESULT __eqsf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}

14
compiler-rt/lib/fp_lib.h
View File

@ -25,20 +25,6 @@
#include <stdbool.h> #include <stdbool.h>
#include <limits.h> #include <limits.h>
// Result enumerations used in comparison routines.
enum LE_RESULT {
LE_LESS = -1,
LE_EQUAL = 0,
LE_GREATER = 1,
LE_UNORDERED = 1
};
enum GE_RESULT {
GE_LESS = -1,
GE_EQUAL = 0,
GE_GREATER = 1,
GE_UNORDERED = -1 // Note: different from LE_UNORDERED
};
#if defined SINGLE_PRECISION #if defined SINGLE_PRECISION
typedef uint32_t rep_t; typedef uint32_t rep_t;

61
compiler-rt/lib/gedf2.c
View File

@ -1,61 +0,0 @@
//===-- lib/gedf2.c - Double-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the following soft-float comparison routines:
//
// __eqdf2 __gedf2 __unorddf2
// __ledf2 __gtdf2
// __ltdf2
// __nedf2
//
// The semantics of the routines grouped in each column are identical, so there
// is a single implementation for each, and wrappers to provide the other names.
//
// The main routines behave as follows:
//
// __ledf2(a,b) returns -1 if a < b
// 0 if a == b
// 1 if a > b
// 1 if either a or b is NaN
//
// __gedf2(a,b) returns -1 if a < b
// 0 if a == b
// 1 if a > b
// -1 if either a or b is NaN
//
// __unorddf2(a,b) returns 0 if both a and b are numbers
// 1 if either a or b is NaN
//
// Note that __ledf2( ) and __gedf2( ) are identical except in their handling of
// NaN values.
//
//===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION
#include "fp_lib.h"
enum GE_RESULT __gedf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
if ((aAbs | bAbs) == 0) return GE_EQUAL;
if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
} else {
if (aInt > bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
}
}

61
compiler-rt/lib/gesf2.c
View File

@ -1,61 +0,0 @@
//===-- lib/gesf2.c - Single-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the following soft-fp_t comparison routines:
//
// __eqsf2 __gesf2 __unordsf2
// __lesf2 __gtsf2
// __ltsf2
// __nesf2
//
// The semantics of the routines grouped in each column are identical, so there
// is a single implementation for each, and wrappers to provide the other names.
//
// The main routines behave as follows:
//
// __lesf2(a,b) returns -1 if a < b
// 0 if a == b
// 1 if a > b
// 1 if either a or b is NaN
//
// __gesf2(a,b) returns -1 if a < b
// 0 if a == b
// 1 if a > b
// -1 if either a or b is NaN
//
// __unordsf2(a,b) returns 0 if both a and b are numbers
// 1 if either a or b is NaN
//
// Note that __lesf2( ) and __gesf2( ) are identical except in their handling of
// NaN values.
//
//===----------------------------------------------------------------------===//
#define SINGLE_PRECISION
#include "fp_lib.h"
enum GE_RESULT __gesf2(fp_t a, fp_t b) {
const srep_t aInt = toRep(a);
const srep_t bInt = toRep(b);
const rep_t aAbs = aInt & absMask;
const rep_t bAbs = bInt & absMask;
if (aAbs > infRep || bAbs > infRep) return GE_UNORDERED;
if ((aAbs | bAbs) == 0) return GE_EQUAL;
if ((aInt & bInt) >= 0) {
if (aInt < bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
} else {
if (aInt > bInt) return GE_LESS;
else if (aInt == bInt) return GE_EQUAL;
else return GE_GREATER;
}
}

17
compiler-rt/lib/gtdf2.c
View File

@ -1,17 +0,0 @@
//===-- lib/gtdf2.c - Double-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION
#include "fp_lib.h"
enum GE_RESULT __gedf2(fp_t a, fp_t b);
enum GE_RESULT __gtdf2(fp_t a, fp_t b) {
return __gedf2(a, b);
}

16
compiler-rt/lib/gtsf2.c
View File

@ -1,16 +0,0 @@
//===-- lib/gtsf2.c - Single-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define SINGLE_PRECISION
#include "fp_lib.h"
enum GE_RESULT __gesf2(fp_t a, fp_t b);
enum GE_RESULT __gtsf2(fp_t a, fp_t b) {
return __gesf2(a, b);
}

16
compiler-rt/lib/ltdf2.c
View File

@ -1,16 +0,0 @@
//===-- lib/ltdf2.c - Double-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION
#include "fp_lib.h"
enum LE_RESULT __ledf2(fp_t a, fp_t b);
enum LE_RESULT __ltdf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}

16
compiler-rt/lib/ltsf2.c
View File

@ -1,16 +0,0 @@
//===-- lib/comparesf2.c - Single-precision comparisons -----------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define SINGLE_PRECISION
#include "fp_lib.h"
enum LE_RESULT __lesf2(fp_t a, fp_t b);
enum LE_RESULT __ltsf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}

17
compiler-rt/lib/nedf2.c
View File

@ -1,17 +0,0 @@
//===-- lib/nedf2.c - Double-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION
#include "fp_lib.h"
enum LE_RESULT __ledf2(fp_t a, fp_t b);
enum LE_RESULT __nedf2(fp_t a, fp_t b) {
return __ledf2(a, b);
}

16
compiler-rt/lib/nesf2.c
View File

@ -1,16 +0,0 @@
//===-- lib/nesf2.c - Single-precision comparisons ----------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define SINGLE_PRECISION
#include "fp_lib.h"
enum LE_RESULT __lesf2(fp_t a, fp_t b);
enum LE_RESULT __nesf2(fp_t a, fp_t b) {
return __lesf2(a, b);
}

47
compiler-rt/lib/unorddf2.c
View File

@ -1,47 +0,0 @@
//===-- lib/unorddf2.c - Double-precision comparisons -------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// // This file implements the following soft-float comparison routines:
//
// __eqdf2 __gedf2 __unorddf2
// __ledf2 __gtdf2
// __ltdf2
// __nedf2
//
// The semantics of the routines grouped in each column are identical, so there
// is a single implementation for each, and wrappers to provide the other names.
//
// The main routines behave as follows:
//
// __ledf2(a,b) returns -1 if a < b
// 0 if a == b
// 1 if a > b
// 1 if either a or b is NaN
//
// __gedf2(a,b) returns -1 if a < b
// 0 if a == b
// 1 if a > b
// -1 if either a or b is NaN
//
// __unorddf2(a,b) returns 0 if both a and b are numbers
// 1 if either a or b is NaN
//
// Note that __ledf2( ) and __gedf2( ) are identical except in their handling of
// NaN values.
//
//===----------------------------------------------------------------------===//
#define DOUBLE_PRECISION
#include "fp_lib.h"
int __unorddf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep;
}

17
compiler-rt/lib/unordsf2.c
View File

@ -1,17 +0,0 @@
//===-- lib/unordsf2.c - Single-precision comparisons -------------*- C -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#define SINGLE_PRECISION
#include "fp_lib.h"
int __unordsf2(fp_t a, fp_t b) {
const rep_t aAbs = toRep(a) & absMask;
const rep_t bAbs = toRep(b) & absMask;
return aAbs > infRep || bAbs > infRep;
}

3
compiler-rt/make/platform/clang_darwin.mk
View File

@ -223,7 +223,8 @@ FUNCTIONS.cc_kext.x86_64 := $(CCKEXT_X86_FUNCTIONS) \
CCKEXT_MISSING_FUNCTIONS := \ CCKEXT_MISSING_FUNCTIONS := \
cmpdf2 cmpsf2 div0 \ cmpdf2 cmpsf2 div0 \
ffssi2 \ ffssi2 \
udiv_w_sdiv bswapdi2 \ gtdf2 gtsf2 ltdf2 ltsf2 \
udiv_w_sdiv unorddf2 unordsf2 bswapdi2 \
bswapsi2 \ bswapsi2 \
gcc_bcmp \ gcc_bcmp \
do_global_dtors \ do_global_dtors \