PR fortran/46416

	* quadmath.h (cbrtq, finiteq, isnanq, signbitq, sqrtq): Remove
	const from prototype argument.
	(cimagq, conjq, cprojq, crealq, fdimq, fmaxq, fminq, ilogbq,
	llrintq, log2q, lrintq, nearbyintq, remquoq): New prototypes.
	(__quadmath_extern_inline): Define.
	(cimagq, conjq, crealq): New inlines.
	* Makefile.am (libquadmath_la_SOURCES): Add math/cimagq.c,
	math/conjq.c, math/cprojq.c, math/crealq.c, math/fdimq.c,
	math/fmaxq.c, math/fminq.c, math/ilogbq.c, math/llrintq.c,
	math/log2q.c, math/lrintq.c, math/nearbyintq.c and math/remquoq.c.
	* Makefile.in: Regenerated.
	* quadmath_weak.h (cimagq, conjq, cprojq, crealq, fdimq, fmaxq,
	fminq, ilogbq, llrintq, log2q, lrintq, nearbyintq, remquoq): Add.
	* quadmath-imp.h (__LITTLE_ENDIAN__): Don't define.
	(ieee854_float128): Use __BYTE_ORDER == __ORDER_BIG_ENDIAN__
	tests instead of __BIG_ENDIAN__.
	* quadmath.map (QUADMATH_1.0): Add cimagq, conjq, cprojq, crealq,
	fdimq, fmaxq, fminq, ilogbq, llrintq, log2q, lrintq, nearbyintq
	and remquoq.
	* libquadmath.texi (cimagq, conjq, cprojq, crealq, fdimq, fmaxq,
	fminq, ilogbq, llrintq, log2q, lrintq, nearbyintq, remquoq): Add.
	* math/cprojq.c: New file.
	* math/ilogbq.c: New file.
	* math/fminq.c: New file.
	* math/llrintq.c: New file.
	* math/log2q.c: New file.
	* math/lrintq.c: New file.
	* math/crealq.c: New file.
	* math/nearbyintq.c: New file.
	* math/fmaxq.c: New file.
	* math/conjq.c: New file.
	* math/remquoq.c: New file.
	* math/cimagq.c: New file.
	* math/fdimq.c: New file.

	* math/ldexpq.c: Include errno.h.  Set errno to ERANGE if needed.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@168854 138bc75d-0d04-0410-961f-82ee72b054a4

22 files changed, 1094 insertions, 34 deletions

diff --git a/libquadmath/ChangeLog b/libquadmath/ChangeLog
index b7b7a43aa6b..c376950ea61 100644
--- a/libquadmath/ChangeLog
+++ b/libquadmath/ChangeLog
@@ -1,6 +1,44 @@
 2011-01-16  Jakub Jelinek  <jakub@redhat.com>
 
 	PR fortran/46416
+	* quadmath.h (cbrtq, finiteq, isnanq, signbitq, sqrtq): Remove
+	const from prototype argument.
+	(cimagq, conjq, cprojq, crealq, fdimq, fmaxq, fminq, ilogbq,
+	llrintq, log2q, lrintq, nearbyintq, remquoq): New prototypes.
+	(__quadmath_extern_inline): Define.
+	(cimagq, conjq, crealq): New inlines.
+	* Makefile.am (libquadmath_la_SOURCES): Add math/cimagq.c,
+	math/conjq.c, math/cprojq.c, math/crealq.c, math/fdimq.c,
+	math/fmaxq.c, math/fminq.c, math/ilogbq.c, math/llrintq.c,
+	math/log2q.c, math/lrintq.c, math/nearbyintq.c and math/remquoq.c.
+	* Makefile.in: Regenerated.
+	* quadmath_weak.h (cimagq, conjq, cprojq, crealq, fdimq, fmaxq,
+	fminq, ilogbq, llrintq, log2q, lrintq, nearbyintq, remquoq): Add.
+	* quadmath-imp.h (__LITTLE_ENDIAN__): Don't define.
+	(ieee854_float128): Use __BYTE_ORDER == __ORDER_BIG_ENDIAN__
+	tests instead of __BIG_ENDIAN__.
+	* quadmath.map (QUADMATH_1.0): Add cimagq, conjq, cprojq, crealq,
+	fdimq, fmaxq, fminq, ilogbq, llrintq, log2q, lrintq, nearbyintq
+	and remquoq.
+	* libquadmath.texi (cimagq, conjq, cprojq, crealq, fdimq, fmaxq,
+	fminq, ilogbq, llrintq, log2q, lrintq, nearbyintq, remquoq): Add.
+	* math/cprojq.c: New file.
+	* math/ilogbq.c: New file.
+	* math/fminq.c: New file.
+	* math/llrintq.c: New file.
+	* math/log2q.c: New file.
+	* math/lrintq.c: New file.
+	* math/crealq.c: New file.
+	* math/nearbyintq.c: New file.
+	* math/fmaxq.c: New file.
+	* math/conjq.c: New file.
+	* math/remquoq.c: New file.
+	* math/cimagq.c: New file.
+	* math/fdimq.c: New file.
+
+	* math/ldexpq.c: Include errno.h.  Set errno to ERANGE if needed.
+
+	PR fortran/46416
 	* quadmath.h (cacosq, cacoshq, casinq, casinhq, catanq, catanhq):
 	New prototypes.
 	(M_Eq, M_LOG2Eq, M_LOG10Eq, M_LN2q, M_LN10q, M_PIq, M_PI_2q, M_PI_4q,
diff --git a/libquadmath/Makefile.am b/libquadmath/Makefile.am
index 0a5c27f4875..b20142bfa2e 100644
--- a/libquadmath/Makefile.am
+++ b/libquadmath/Makefile.am
@@ -63,7 +63,10 @@ libquadmath_la_SOURCES = \
   math/nanq.c math/tgammaq.c math/finiteq.c math/nextafterq.c \
   math/truncq.c math/floorq.c math/powq.c math/fmaq.c \
   math/cacoshq.c math/cacosq.c math/casinhq.c math/casinq.c \
-  math/catanhq.c math/catanq.c
+  math/catanhq.c math/catanq.c math/cimagq.c math/conjq.c math/cprojq.c \
+  math/crealq.c math/fdimq.c math/fmaxq.c math/fminq.c math/ilogbq.c \
+  math/llrintq.c math/log2q.c math/lrintq.c math/nearbyintq.c math/remquoq.c
+
 
 # Work around what appears to be a GNU make bug handling MAKEFLAGS
 # values defined in terms of make variables, as is the case for CC and
diff --git a/libquadmath/Makefile.in b/libquadmath/Makefile.in
index 2fdebebbd7e..d73e6315778 100644
--- a/libquadmath/Makefile.in
+++ b/libquadmath/Makefile.in
@@ -125,7 +125,14 @@ am__dirstamp = $(am__leading_dot)dirstamp
 @BUILD_LIBQUADMATH_TRUE@	math/powq.lo math/fmaq.lo \
 @BUILD_LIBQUADMATH_TRUE@	math/cacoshq.lo math/cacosq.lo \
 @BUILD_LIBQUADMATH_TRUE@	math/casinhq.lo math/casinq.lo \
-@BUILD_LIBQUADMATH_TRUE@	math/catanhq.lo math/catanq.lo
+@BUILD_LIBQUADMATH_TRUE@	math/catanhq.lo math/catanq.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/cimagq.lo math/conjq.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/cprojq.lo math/crealq.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/fdimq.lo math/fmaxq.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/fminq.lo math/ilogbq.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/llrintq.lo math/log2q.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/lrintq.lo math/nearbyintq.lo \
+@BUILD_LIBQUADMATH_TRUE@	math/remquoq.lo
 libquadmath_la_OBJECTS = $(am_libquadmath_la_OBJECTS)
 libquadmath_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
@@ -329,7 +336,9 @@ AUTOMAKE_OPTIONS = 1.8 foreign
 @BUILD_LIBQUADMATH_TRUE@  math/nanq.c math/tgammaq.c math/finiteq.c math/nextafterq.c \
 @BUILD_LIBQUADMATH_TRUE@  math/truncq.c math/floorq.c math/powq.c math/fmaq.c \
 @BUILD_LIBQUADMATH_TRUE@  math/cacoshq.c math/cacosq.c math/casinhq.c math/casinq.c \
-@BUILD_LIBQUADMATH_TRUE@  math/catanhq.c math/catanq.c
+@BUILD_LIBQUADMATH_TRUE@  math/catanhq.c math/catanq.c math/cimagq.c math/conjq.c math/cprojq.c \
+@BUILD_LIBQUADMATH_TRUE@  math/crealq.c math/fdimq.c math/fmaxq.c math/fminq.c math/ilogbq.c \
+@BUILD_LIBQUADMATH_TRUE@  math/llrintq.c math/log2q.c math/lrintq.c math/nearbyintq.c math/remquoq.c
 
 
 # Work around what appears to be a GNU make bug handling MAKEFLAGS
@@ -581,6 +590,20 @@ math/casinhq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
 math/casinq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
 math/catanhq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
 math/catanq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/cimagq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/conjq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/cprojq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/crealq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/fdimq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/fmaxq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/fminq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/ilogbq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/llrintq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/log2q.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/lrintq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
+math/nearbyintq.lo: math/$(am__dirstamp) \
+	math/$(DEPDIR)/$(am__dirstamp)
+math/remquoq.lo: math/$(am__dirstamp) math/$(DEPDIR)/$(am__dirstamp)
 libquadmath.la: $(libquadmath_la_OBJECTS) $(libquadmath_la_DEPENDENCIES) 
 	$(libquadmath_la_LINK) $(am_libquadmath_la_rpath) $(libquadmath_la_OBJECTS) $(libquadmath_la_LIBADD) $(LIBS)
 
@@ -644,8 +667,12 @@ mostlyclean-compile:
 	-rm -f math/cbrtq.lo
 	-rm -f math/ceilq.$(OBJEXT)
 	-rm -f math/ceilq.lo
+	-rm -f math/cimagq.$(OBJEXT)
+	-rm -f math/cimagq.lo
 	-rm -f math/complex.$(OBJEXT)
 	-rm -f math/complex.lo
+	-rm -f math/conjq.$(OBJEXT)
+	-rm -f math/conjq.lo
 	-rm -f math/copysignq.$(OBJEXT)
 	-rm -f math/copysignq.lo
 	-rm -f math/coshq.$(OBJEXT)
@@ -654,6 +681,10 @@ mostlyclean-compile:
 	-rm -f math/cosq.lo
 	-rm -f math/cosq_kernel.$(OBJEXT)
 	-rm -f math/cosq_kernel.lo
+	-rm -f math/cprojq.$(OBJEXT)
+	-rm -f math/cprojq.lo
+	-rm -f math/crealq.$(OBJEXT)
+	-rm -f math/crealq.lo
 	-rm -f math/erfq.$(OBJEXT)
 	-rm -f math/erfq.lo
 	-rm -f math/expm1q.$(OBJEXT)
@@ -662,18 +693,26 @@ mostlyclean-compile:
 	-rm -f math/expq.lo
 	-rm -f math/fabsq.$(OBJEXT)
 	-rm -f math/fabsq.lo
+	-rm -f math/fdimq.$(OBJEXT)
+	-rm -f math/fdimq.lo
 	-rm -f math/finiteq.$(OBJEXT)
 	-rm -f math/finiteq.lo
 	-rm -f math/floorq.$(OBJEXT)
 	-rm -f math/floorq.lo
 	-rm -f math/fmaq.$(OBJEXT)
 	-rm -f math/fmaq.lo
+	-rm -f math/fmaxq.$(OBJEXT)
+	-rm -f math/fmaxq.lo
+	-rm -f math/fminq.$(OBJEXT)
+	-rm -f math/fminq.lo
 	-rm -f math/fmodq.$(OBJEXT)
 	-rm -f math/fmodq.lo
 	-rm -f math/frexpq.$(OBJEXT)
 	-rm -f math/frexpq.lo
 	-rm -f math/hypotq.$(OBJEXT)
 	-rm -f math/hypotq.lo
+	-rm -f math/ilogbq.$(OBJEXT)
+	-rm -f math/ilogbq.lo
 	-rm -f math/isinfq.$(OBJEXT)
 	-rm -f math/isinfq.lo
 	-rm -f math/isnanq.$(OBJEXT)
@@ -688,20 +727,28 @@ mostlyclean-compile:
 	-rm -f math/ldexpq.lo
 	-rm -f math/lgammaq.$(OBJEXT)
 	-rm -f math/lgammaq.lo
+	-rm -f math/llrintq.$(OBJEXT)
+	-rm -f math/llrintq.lo
 	-rm -f math/llroundq.$(OBJEXT)
 	-rm -f math/llroundq.lo
 	-rm -f math/log10q.$(OBJEXT)
 	-rm -f math/log10q.lo
 	-rm -f math/log1pq.$(OBJEXT)
 	-rm -f math/log1pq.lo
+	-rm -f math/log2q.$(OBJEXT)
+	-rm -f math/log2q.lo
 	-rm -f math/logq.$(OBJEXT)
 	-rm -f math/logq.lo
+	-rm -f math/lrintq.$(OBJEXT)
+	-rm -f math/lrintq.lo
 	-rm -f math/lroundq.$(OBJEXT)
 	-rm -f math/lroundq.lo
 	-rm -f math/modfq.$(OBJEXT)
 	-rm -f math/modfq.lo
 	-rm -f math/nanq.$(OBJEXT)
 	-rm -f math/nanq.lo
+	-rm -f math/nearbyintq.$(OBJEXT)
+	-rm -f math/nearbyintq.lo
 	-rm -f math/nextafterq.$(OBJEXT)
 	-rm -f math/nextafterq.lo
 	-rm -f math/powq.$(OBJEXT)
@@ -710,6 +757,8 @@ mostlyclean-compile:
 	-rm -f math/rem_pio2q.lo
 	-rm -f math/remainderq.$(OBJEXT)
 	-rm -f math/remainderq.lo
+	-rm -f math/remquoq.$(OBJEXT)
+	-rm -f math/remquoq.lo
 	-rm -f math/rintq.$(OBJEXT)
 	-rm -f math/rintq.lo
 	-rm -f math/roundq.$(OBJEXT)
@@ -776,21 +825,29 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/catanq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/cbrtq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/ceilq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/cimagq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/complex.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/conjq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/copysignq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/coshq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/cosq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/cosq_kernel.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/cprojq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/crealq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/erfq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/expm1q.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/expq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/fabsq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/fdimq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/finiteq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/floorq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/fmaq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/fmaxq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/fminq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/fmodq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/frexpq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/hypotq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/ilogbq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/isinfq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/isnanq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/j0q.Plo@am__quote@
@@ -798,17 +855,22 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/jnq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/ldexpq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/lgammaq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/llrintq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/llroundq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/log10q.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/log1pq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/log2q.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/logq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/lrintq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/lroundq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/modfq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/nanq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/nearbyintq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/nextafterq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/powq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/rem_pio2q.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/remainderq.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/remquoq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/rintq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/roundq.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@math/$(DEPDIR)/scalblnq.Plo@am__quote@
diff --git a/libquadmath/libquadmath.texi b/libquadmath/libquadmath.texi
index 50b9e62e495..b336f9b4a12 100644
--- a/libquadmath/libquadmath.texi
+++ b/libquadmath/libquadmath.texi
@@ -111,12 +111,16 @@ The following mathematical functions are available:
 @item @code{expm1q}: exponential minus 1 function
 @need 800
 @item @code{fabsq}: absolute value function
+@item @code{fdimq}: positive difference function
 @item @code{finiteq}: check finiteness of value
 @item @code{floorq}: floor value function
 @item @code{fmaq}: fused multiply and add
+@item @code{fmaxq}: determine maximum of two values
+@item @code{fminq}: determine minimum of two values
 @item @code{fmodq}: remainder value function
 @item @code{frexpq}: extract mantissa and exponent
 @item @code{hypotq}: Eucledian distance function
+@item @code{ilogbq}: get exponent of the value
 @item @code{isinfq}: check for infinity
 @item @code{isnanq}: check for not a number
 @item @code{j0q}: Bessel function of the first kind, first order
@@ -124,17 +128,22 @@ The following mathematical functions are available:
 @item @code{jnq}: Bessel function of the first kind, @var{n}-th order
 @item @code{ldexpq}: load exponent of the value
 @item @code{lgammaq}: logarithmic gamma function
+@item @code{llrintq}: round to nearest integer value
 @item @code{llroundq}: round to nearest integer value away from zero
 @item @code{logq}: natural logarithm function
 @item @code{log10q}: base 10 logarithm function
 @item @code{log1pq}: compute natural logarithm of the value plus one
+@item @code{log2q}: base 2 logarithm function
 @need 800
+@item @code{lrintq}: round to nearest integer value
 @item @code{lroundq}: round to nearest integer value away from zero
 @item @code{modfq}: decompose the floating-point number
 @item @code{nanq}: return quiet NaN
+@item @code{nearbyintq}: round to nearest integer
 @item @code{nextafterq}: next representable floating-point number
 @item @code{powq}: power function
 @item @code{remainderq}: remainder function
+@item @code{remquoq}: remainder and part of quotient
 @item @code{rintq}: round-to-nearest integral value
 @item @code{roundq}: round-to-nearest integral value, return @code{__float128}
 @item @code{scalblnq}: compute exponent using @code{FLT_RADIX}
@@ -152,8 +161,10 @@ The following mathematical functions are available:
 @item @code{y0q}: Bessel function of the second kind, first order
 @item @code{y1q}: Bessel function of the second kind, second order
 @item @code{ynq}: Bessel function of the second kind, @var{n}-th order
-@item @code{cabsq} complex absolute value function:
+@item @code{cabsq} complex absolute value function
 @item @code{cargq}: calculate the argument
+@item @code{cimagq} imaginary part of complex number
+@item @code{crealq}: real part of complex number
 @item @code{cacoshq}: complex arc hyperbolic cosine function
 @item @code{cacosq}: complex arc cosine function
 @item @code{casinhq}: complex arc hyperbolic sine function
@@ -168,7 +179,9 @@ The following mathematical functions are available:
                      real value
 @item @code{clogq}: complex natural logarithm
 @item @code{clog10q}: complex base 10 logarithm
+@item @code{conjq}: complex conjugate function
 @item @code{cpowq}: complex power function
+@item @code{cprojq}: project into Riemann Sphere
 @item @code{csinq}: complex sine function
 @item @code{csinhq}: complex hyperbolic sine function
 @item @code{csqrtq}: complex square root
diff --git a/libquadmath/math/cimagq.c b/libquadmath/math/cimagq.c
new file mode 100644
index 00000000000..9b3bf70a10d
--- /dev/null
+++ b/libquadmath/math/cimagq.c
@@ -0,0 +1,27 @@
+/* Return imaginary part of complex __float128 value.
+   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+__float128
+cimagq (__complex128 z)
+{
+  return __imag__ z;
+}
diff --git a/libquadmath/math/conjq.c b/libquadmath/math/conjq.c
new file mode 100644
index 00000000000..8587d12193b
--- /dev/null
+++ b/libquadmath/math/conjq.c
@@ -0,0 +1,27 @@
+/* Return complex conjugate of complex __float128 value.
+   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+__complex128
+conjq (__complex128 z)
+{
+  return ~z;
+}
diff --git a/libquadmath/math/cprojq.c b/libquadmath/math/cprojq.c
new file mode 100644
index 00000000000..6092c732503
--- /dev/null
+++ b/libquadmath/math/cprojq.c
@@ -0,0 +1,40 @@
+/* Compute projection of complex __float128 value to Riemann sphere.
+   Copyright (C) 1997, 1999, 2010 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+
+__complex128
+cprojq (__complex128 x)
+{
+  if (isnanq (__real__ x) && isnanq (__imag__ x))
+    return x;
+  else if (!finiteq (__real__ x) || !finiteq (__imag__ x))
+    {
+      __complex128 res;
+
+      __real__ res = __builtin_inf ();
+      __imag__ res = copysignq (0.0, __imag__ x);
+
+      return res;
+    }
+
+  return x;
+}
diff --git a/libquadmath/math/crealq.c b/libquadmath/math/crealq.c
new file mode 100644
index 00000000000..71f4a4405aa
--- /dev/null
+++ b/libquadmath/math/crealq.c
@@ -0,0 +1,27 @@
+/* Return real part of complex __float128 value.
+   Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+__float128
+crealq (__complex128 z)
+{
+  return __real__ z;
+}
diff --git a/libquadmath/math/fdimq.c b/libquadmath/math/fdimq.c
new file mode 100644
index 00000000000..539fb08c641
--- /dev/null
+++ b/libquadmath/math/fdimq.c
@@ -0,0 +1,43 @@
+/* Return positive difference between arguments.
+   Copyright (C) 1997, 2004, 2009 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include <errno.h>
+#include "quadmath-imp.h"
+
+__float128
+fdimq (__float128 x, __float128 y)
+{
+  int clsx = fpclassifyq (x);
+  int clsy = fpclassifyq (y);
+
+  if (clsx == QUADFP_NAN || clsy == QUADFP_NAN
+      || (y < 0 && clsx == QUADFP_INFINITE && clsy == QUADFP_INFINITE))
+    /* Raise invalid flag.  */
+    return x - y;
+
+  if (x <= y)
+    return 0.0Q;
+
+  __float128 r = x - y;
+  if (isinfq (r))
+    errno = ERANGE;
+
+  return r;
+}
diff --git a/libquadmath/math/fmaxq.c b/libquadmath/math/fmaxq.c
new file mode 100644
index 00000000000..e8ed6f440aa
--- /dev/null
+++ b/libquadmath/math/fmaxq.c
@@ -0,0 +1,28 @@
+/* Return maximum numeric value of X and Y.
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+
+__float128
+fmaxq (__float128 x, __float128 y)
+{
+  return (__builtin_isgreaterequal (x, y) || isnanq (y)) ? x : y;
+}
diff --git a/libquadmath/math/fminq.c b/libquadmath/math/fminq.c
new file mode 100644
index 00000000000..2fbe4116a6d
--- /dev/null
+++ b/libquadmath/math/fminq.c
@@ -0,0 +1,28 @@
+/* Return minimum numeric value of X and Y.
+   Copyright (C) 1997 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+
+__float128
+fminq (__float128 x, __float128 y)
+{
+  return (__builtin_islessequal (x, y) || isnanq (y)) ? x : y;
+}
diff --git a/libquadmath/math/ilogbq.c b/libquadmath/math/ilogbq.c
new file mode 100644
index 00000000000..47986f5b311
--- /dev/null
+++ b/libquadmath/math/ilogbq.c
@@ -0,0 +1,64 @@
+/* s_ilogbl.c -- long double version of s_ilogb.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+#if defined(LIBM_SCCS) && !defined(lint)
+static char rcsid[] = "$NetBSD: $";
+#endif
+
+/* ilogbl(long double x)
+ * return the binary exponent of non-zero x
+ * ilogbl(0) = FP_ILOGB0
+ * ilogbl(NaN) = FP_ILOGBNAN (no signal is raised)
+ * ilogbl(+-Inf) = INT_MAX (no signal is raised)
+ */
+
+#include <limits.h>
+#include <math.h>
+#include "quadmath-imp.h"
+
+#ifndef FP_ILOGB0
+# define FP_ILOGB0 INT_MIN
+#endif
+#ifndef FP_ILOGBNAN
+# define FP_ILOGBNAN INT_MAX
+#endif
+
+int
+ilogbq (__float128 x)
+{
+	int64_t hx,lx;
+	int ix;
+
+	GET_FLT128_WORDS64(hx,lx,x);
+	hx &= 0x7fffffffffffffffLL;
+	if(hx <= 0x0001000000000000LL) {
+	    if((hx|lx)==0)
+		return FP_ILOGB0;	/* ilogbl(0) = FP_ILOGB0 */
+	    else			/* subnormal x */
+		if(hx==0) {
+		    for (ix = -16431; lx>0; lx<<=1) ix -=1;
+		} else {
+		    for (ix = -16382, hx<<=15; hx>0; hx<<=1) ix -=1;
+		}
+	    return ix;
+	}
+	else if (hx<0x7fff000000000000LL) return (hx>>48)-0x3fff;
+	else if (FP_ILOGBNAN != INT_MAX) {
+	    /* ISO C99 requires ilogbl(+-Inf) == INT_MAX.  */
+	    if (((hx^0x7fff000000000000LL)|lx) == 0)
+		return INT_MAX;
+	}
+	return FP_ILOGBNAN;
+}
diff --git a/libquadmath/math/ldexpq.c b/libquadmath/math/ldexpq.c
index 73f52e509bf..394d4590cca 100644
--- a/libquadmath/math/ldexpq.c
+++ b/libquadmath/math/ldexpq.c
@@ -14,6 +14,7 @@
  * ====================================================
  */
 
+#include <errno.h>
 #include "quadmath-imp.h"
 
 __float128
@@ -21,6 +22,6 @@ ldexpq (__float128 value, int exp)
 {
   if(!finiteq(value)||value==0.0Q) return value;
   value = scalbnq(value,exp);
-  /* if(!__finitel(value)||value==0.0Q) __set_errno (ERANGE); */
+  if(!finiteq(value)||value==0.0Q) errno = ERANGE;
   return value;
 }
diff --git a/libquadmath/math/llrintq.c b/libquadmath/math/llrintq.c
new file mode 100644
index 00000000000..eef31d823b6
--- /dev/null
+++ b/libquadmath/math/llrintq.c
@@ -0,0 +1,71 @@
+/* Round argument to nearest integral value according to current rounding
+   direction.
+   Copyright (C) 1997, 1999, 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
+   		  Jakub Jelinek <jj@ultra.linux.cz>, 1999.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+static const __float128 two112[2] =
+{
+  5.19229685853482762853049632922009600E+33Q, /* 0x406F000000000000, 0 */
+ -5.19229685853482762853049632922009600E+33Q  /* 0xC06F000000000000, 0 */
+};
+
+long long int
+llrintq (__float128 x)
+{
+  int32_t j0;
+  uint64_t i0,i1;
+  volatile __float128 w;
+  __float128 t;
+  long long int result;
+  int sx;
+
+  GET_FLT128_WORDS64 (i0, i1, x);
+  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+  sx = i0 >> 63;
+  i0 &= 0x0000ffffffffffffLL;
+  i0 |= 0x0001000000000000LL;
+
+  if (j0 < (int32_t) (8 * sizeof (long long int)) - 1)
+    {
+      w = two112[sx] + x;
+      t = w - two112[sx];
+      GET_FLT128_WORDS64 (i0, i1, t);
+      j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+      i0 &= 0x0000ffffffffffffLL;
+      i0 |= 0x0001000000000000LL;
+
+      if (j0 < 0)
+	result = 0;
+      else if (j0 <= 48)
+	result = i0 >> (48 - j0);
+      else
+	result = ((long long int) i0 << (j0 - 48)) | (i1 >> (112 - j0));
+    }
+  else
+    {
+      /* The number is too large.  It is left implementation defined
+	 what happens.  */
+      return (long long int) x;
+    }
+
+  return sx ? -result : result;
+}
diff --git a/libquadmath/math/log2q.c b/libquadmath/math/log2q.c
new file mode 100644
index 00000000000..963b38c8483
--- /dev/null
+++ b/libquadmath/math/log2q.c
@@ -0,0 +1,248 @@
+/*                                                      log2l.c
+ *      Base 2 logarithm, 128-bit long double precision
+ *
+ *
+ *
+ * SYNOPSIS:
+ *
+ * long double x, y, log2l();
+ *
+ * y = log2l( x );
+ *
+ *
+ *
+ * DESCRIPTION:
+ *
+ * Returns the base 2 logarithm of x.
+ *
+ * The argument is separated into its exponent and fractional
+ * parts.  If the exponent is between -1 and +1, the (natural)
+ * logarithm of the fraction is approximated by
+ *
+ *     log(1+x) = x - 0.5 x^2 + x^3 P(x)/Q(x).
+ *
+ * Otherwise, setting  z = 2(x-1)/x+1),
+ *
+ *     log(x) = z + z^3 P(z)/Q(z).
+ *
+ *
+ *
+ * ACCURACY:
+ *
+ *                      Relative error:
+ * arithmetic   domain     # trials      peak         rms
+ *    IEEE      0.5, 2.0     100,000    2.6e-34     4.9e-35
+ *    IEEE     exp(+-10000)  100,000    9.6e-35     4.0e-35
+ *
+ * In the tests over the interval exp(+-10000), the logarithms
+ * of the random arguments were uniformly distributed over
+ * [-10000, +10000].
+ *
+ */
+
+/*
+   Cephes Math Library Release 2.2:  January, 1991
+   Copyright 1984, 1991 by Stephen L. Moshier
+   Adapted for glibc November, 2001
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA 
+ */
+
+#include "quadmath-imp.h"
+
+/* Coefficients for ln(1+x) = x - x**2/2 + x**3 P(x)/Q(x)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 5.3e-37,
+ * relative peak error spread = 2.3e-14
+ */
+static const __float128 P[13] =
+{
+  1.313572404063446165910279910527789794488E4Q,
+  7.771154681358524243729929227226708890930E4Q,
+  2.014652742082537582487669938141683759923E5Q,
+  3.007007295140399532324943111654767187848E5Q,
+  2.854829159639697837788887080758954924001E5Q,
+  1.797628303815655343403735250238293741397E5Q,
+  7.594356839258970405033155585486712125861E4Q,
+  2.128857716871515081352991964243375186031E4Q,
+  3.824952356185897735160588078446136783779E3Q,
+  4.114517881637811823002128927449878962058E2Q,
+  2.321125933898420063925789532045674660756E1Q,
+  4.998469661968096229986658302195402690910E-1Q,
+  1.538612243596254322971797716843006400388E-6Q
+};
+static const __float128 Q[12] =
+{
+  3.940717212190338497730839731583397586124E4Q,
+  2.626900195321832660448791748036714883242E5Q,
+  7.777690340007566932935753241556479363645E5Q,
+  1.347518538384329112529391120390701166528E6Q,
+  1.514882452993549494932585972882995548426E6Q,
+  1.158019977462989115839826904108208787040E6Q,
+  6.132189329546557743179177159925690841200E5Q,
+  2.248234257620569139969141618556349415120E5Q,
+  5.605842085972455027590989944010492125825E4Q,
+  9.147150349299596453976674231612674085381E3Q,
+  9.104928120962988414618126155557301584078E2Q,
+  4.839208193348159620282142911143429644326E1Q
+/* 1.000000000000000000000000000000000000000E0Q, */
+};
+
+/* Coefficients for log(x) = z + z^3 P(z^2)/Q(z^2),
+ * where z = 2(x-1)/(x+1)
+ * 1/sqrt(2) <= x < sqrt(2)
+ * Theoretical peak relative error = 1.1e-35,
+ * relative peak error spread 1.1e-9
+ */
+static const __float128 R[6] =
+{
+  1.418134209872192732479751274970992665513E5Q,
+ -8.977257995689735303686582344659576526998E4Q,
+  2.048819892795278657810231591630928516206E4Q,
+ -2.024301798136027039250415126250455056397E3Q,
+  8.057002716646055371965756206836056074715E1Q,
+ -8.828896441624934385266096344596648080902E-1Q
+};
+static const __float128 S[6] =
+{
+  1.701761051846631278975701529965589676574E6Q,
+ -1.332535117259762928288745111081235577029E6Q,
+  4.001557694070773974936904547424676279307E5Q,
+ -5.748542087379434595104154610899551484314E4Q,
+  3.998526750980007367835804959888064681098E3Q,
+ -1.186359407982897997337150403816839480438E2Q
+/* 1.000000000000000000000000000000000000000E0Q, */
+};
+
+static const __float128
+/* log2(e) - 1 */
+LOG2EA = 4.4269504088896340735992468100189213742664595E-1Q,
+/* sqrt(2)/2 */
+SQRTH = 7.071067811865475244008443621048490392848359E-1Q;
+
+
+/* Evaluate P[n] x^n  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static __float128
+neval (__float128 x, const __float128 *p, int n)
+{
+  __float128 y;
+
+  p += n;
+  y = *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+/* Evaluate x^n+1  +  P[n] x^(n)  +  P[n-1] x^(n-1)  +  ...  +  P[0] */
+
+static __float128
+deval (__float128 x, const __float128 *p, int n)
+{
+  __float128 y;
+
+  p += n;
+  y = x + *p--;
+  do
+    {
+      y = y * x + *p--;
+    }
+  while (--n > 0);
+  return y;
+}
+
+
+
+__float128
+log2q (__float128 x)
+{
+  __float128 z;
+  __float128 y;
+  int e;
+  int64_t hx, lx;
+
+/* Test for domain */
+  GET_FLT128_WORDS64 (hx, lx, x);
+  if (((hx & 0x7fffffffffffffffLL) | lx) == 0)
+    return (-1.0Q / (x - x));
+  if (hx < 0)
+    return (x - x) / (x - x);
+  if (hx >= 0x7fff000000000000LL)
+    return (x + x);
+
+/* separate mantissa from exponent */
+
+/* Note, frexp is used so that denormal numbers
+ * will be handled properly.
+ */
+  x = frexpq (x, &e);
+
+
+/* logarithm using log(x) = z + z**3 P(z)/Q(z),
+ * where z = 2(x-1)/x+1)
+ */
+  if ((e > 2) || (e < -2))
+    {
+      if (x < SQRTH)
+	{			/* 2( 2x-1 )/( 2x+1 ) */
+	  e -= 1;
+	  z = x - 0.5Q;
+	  y = 0.5Q * z + 0.5Q;
+	}
+      else
+	{			/*  2 (x-1)/(x+1)   */
+	  z = x - 0.5Q;
+	  z -= 0.5Q;
+	  y = 0.5Q * x + 0.5Q;
+	}
+      x = z / y;
+      z = x * x;
+      y = x * (z * neval (z, R, 5) / deval (z, S, 5));
+      goto done;
+    }
+
+
+/* logarithm using log(1+x) = x - .5x**2 + x**3 P(x)/Q(x) */
+
+  if (x < SQRTH)
+    {
+      e -= 1;
+      x = 2.0 * x - 1.0Q;	/*  2x - 1  */
+    }
+  else
+    {
+      x = x - 1.0Q;
+    }
+  z = x * x;
+  y = x * (z * neval (x, P, 12) / deval (x, Q, 11));
+  y = y - 0.5 * z;
+
+done:
+
+/* Multiply log of fraction by log2(e)
+ * and base 2 exponent by 1
+ */
+  z = y * LOG2EA;
+  z += x * LOG2EA;
+  z += y;
+  z += x;
+  z += e;
+  return (z);
+}
diff --git a/libquadmath/math/lrintq.c b/libquadmath/math/lrintq.c
new file mode 100644
index 00000000000..d1497ae3882
--- /dev/null
+++ b/libquadmath/math/lrintq.c
@@ -0,0 +1,85 @@
+/* Round argument to nearest integral value according to current rounding
+   direction.
+   Copyright (C) 1997, 1999, 2004, 2006 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
+   		  Jakub Jelinek <jj@ultra.linux.cz>, 1999.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+static const __float128 two112[2] =
+{
+  5.19229685853482762853049632922009600E+33Q, /* 0x406F000000000000, 0 */
+ -5.19229685853482762853049632922009600E+33Q  /* 0xC06F000000000000, 0 */
+};
+
+long int
+lrintq (__float128 x)
+{
+  int32_t j0;
+  uint64_t i0,i1;
+  volatile __float128 w;
+  __float128 t;
+  long int result;
+  int sx;
+
+  GET_FLT128_WORDS64 (i0, i1, x);
+  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+  sx = i0 >> 63;
+  i0 &= 0x0000ffffffffffffLL;
+  i0 |= 0x0001000000000000LL;
+
+  if (j0 < 48)
+    {
+      w = two112[sx] + x;
+      t = w - two112[sx];
+      GET_FLT128_WORDS64 (i0, i1, t);
+      j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+      i0 &= 0x0000ffffffffffffLL;
+      i0 |= 0x0001000000000000LL;
+
+      result = (j0 < 0 ? 0 : i0 >> (48 - j0));
+    }
+  else if (j0 < (int32_t) (8 * sizeof (long int)) - 1)
+    {
+      if (j0 >= 112)
+	result = ((long int) i0 << (j0 - 48)) | (i1 << (j0 - 112));
+      else
+	{
+	  w = two112[sx] + x;
+	  t = w - two112[sx];
+	  GET_FLT128_WORDS64 (i0, i1, t);
+	  j0 = ((i0 >> 48) & 0x7fff) - 0x3fff;
+	  i0 &= 0x0000ffffffffffffLL;
+	  i0 |= 0x0001000000000000LL;
+
+	  if (j0 == 48)
+	    result = (long int) i0;
+	  else
+	    result = ((long int) i0 << (j0 - 48)) | (i1 >> (112 - j0));
+	}
+    }
+  else
+    {
+      /* The number is too large.  It is left implementation defined
+	 what happens.  */
+      return (long int) x;
+    }
+
+  return sx ? -result : result;
+}
diff --git a/libquadmath/math/nearbyintq.c b/libquadmath/math/nearbyintq.c
new file mode 100644
index 00000000000..8e92c5afd4b
--- /dev/null
+++ b/libquadmath/math/nearbyintq.c
@@ -0,0 +1,98 @@
+/* nearbyintq.c -- __float128 version of s_nearbyint.c.
+ * Conversion to IEEE quad long double by Jakub Jelinek, jj@ultra.linux.cz.
+ */
+
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunPro, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * nearbyintq(x)
+ * Return x rounded to integral value according to the prevailing
+ * rounding mode.
+ * Method:
+ *	Using floating addition.
+ * Exception:
+ *	Inexact flag raised if x not equal to rintq(x).
+ */
+
+#include "quadmath-imp.h"
+#ifdef HAVE_FENV_H
+# include <fenv.h>
+# if defined HAVE_FEHOLDEXCEPT && defined HAVE_FESETENV
+#   define USE_FENV_H
+# endif
+#endif
+
+static const __float128
+TWO112[2]={
+  5.19229685853482762853049632922009600E+33Q, /* 0x406F000000000000, 0 */
+ -5.19229685853482762853049632922009600E+33Q  /* 0xC06F000000000000, 0 */
+};
+
+__float128
+nearbyintq(__float128 x)
+{
+#ifdef USE_FENV_H
+	fenv_t env;
+#endif
+	int64_t i0,j0,sx;
+	uint64_t i,i1;
+	__float128 w,t;
+	GET_FLT128_WORDS64(i0,i1,x);
+	sx = (((uint64_t)i0)>>63);
+	j0 = ((i0>>48)&0x7fff)-0x3fff;
+	if(j0<48) {
+	    if(j0<0) {
+		if(((i0&0x7fffffffffffffffLL)|i1)==0) return x;
+		i1 |= (i0&0x0000ffffffffffffLL);
+		i0 &= 0xffffe00000000000ULL;
+		i0 |= ((i1|-i1)>>16)&0x0000800000000000LL;
+		SET_FLT128_MSW64(x,i0);
+#ifdef USE_FENV_H
+		feholdexcept (&env);
+#endif
+	        w = TWO112[sx]+x;
+	        t = w-TWO112[sx];
+#ifdef USE_FENV_H
+	        fesetenv (&env);
+#endif
+		GET_FLT128_MSW64(i0,t);
+		SET_FLT128_MSW64(t,(i0&0x7fffffffffffffffLL)|(sx<<63));
+	        return t;
+	    } else {
+		i = (0x0000ffffffffffffLL)>>j0;
+		if(((i0&i)|i1)==0) return x; /* x is integral */
+		i>>=1;
+		if(((i0&i)|i1)!=0) {
+		    if(j0==47) i1 = 0x4000000000000000ULL; else
+		    i0 = (i0&(~i))|((0x0000200000000000LL)>>j0);
+		}
+	    }
+	} else if (j0>111) {
+	    if(j0==0x4000) return x+x;	/* inf or NaN */
+	    else return x;		/* x is integral */
+	} else {
+	    i = -1ULL>>(j0-48);
+	    if((i1&i)==0) return x;	/* x is integral */
+	    i>>=1;
+	    if((i1&i)!=0) i1 = (i1&(~i))|((0x4000000000000000LL)>>(j0-48));
+	}
+	SET_FLT128_WORDS64(x,i0,i1);
+#ifdef USE_FENV_H
+	feholdexcept (&env);
+#endif
+	w = TWO112[sx]+x;
+	t = w-TWO112[sx];
+#ifdef USE_FENV_H	
+	fesetenv (&env);
+#endif
+	return t;
+}
diff --git a/libquadmath/math/remquoq.c b/libquadmath/math/remquoq.c
new file mode 100644
index 00000000000..3e3b4f68ce4
--- /dev/null
+++ b/libquadmath/math/remquoq.c
@@ -0,0 +1,107 @@
+/* Compute remainder and a congruent to the quotient.
+   Copyright (C) 1997, 1999, 2002 Free Software Foundation, Inc.
+   This file is part of the GNU C Library.
+   Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997 and
+		  Jakub Jelinek <jj@ultra.linux.cz>, 1999.
+
+   The GNU C Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2.1 of the License, or (at your option) any later version.
+
+   The GNU C Library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with the GNU C Library; if not, write to the Free
+   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+   02111-1307 USA.  */
+
+#include "quadmath-imp.h"
+
+
+static const __float128 zero = 0.0;
+
+
+__float128
+remquoq (__float128 x, __float128 y, int *quo)
+{
+  int64_t hx,hy;
+  u_int64_t sx,lx,ly,qs;
+  int cquo;
+
+  GET_FLT128_WORDS64 (hx, lx, x);
+  GET_FLT128_WORDS64 (hy, ly, y);
+  sx = hx & 0x8000000000000000ULL;
+  qs = sx ^ (hy & 0x8000000000000000ULL);
+  hy &= 0x7fffffffffffffffLL;
+  hx &= 0x7fffffffffffffffLL;
+
+  /* Purge off exception values.  */
+  if ((hy | ly) == 0)
+    return (x * y) / (x * y); 			/* y = 0 */
+  if ((hx >= 0x7fff000000000000LL)		/* x not finite */
+      || ((hy >= 0x7fff000000000000LL)		/* y is NaN */
+	  && (((hy - 0x7fff000000000000LL) | ly) != 0)))
+    return (x * y) / (x * y);
+
+  if (hy <= 0x7ffbffffffffffffLL)
+    x = fmodq (x, 8 * y);              /* now x < 8y */
+      
+  if (((hx - hy) | (lx - ly)) == 0)
+    {
+      *quo = qs ? -1 : 1;
+      return zero * x;
+    }
+
+  x  = fabsq (x);
+  y  = fabsq (y);
+  cquo = 0;
+
+  if (x >= 4 * y)
+    {
+      x -= 4 * y;
+      cquo += 4;
+    }
+  if (x >= 2 * y)
+    {
+      x -= 2 * y;
+      cquo += 2;
+    }
+
+  if (hy < 0x0002000000000000LL)
+    {
+      if (x + x > y)
+	{
+	  x -= y;
+	  ++cquo;
+	  if (x + x >= y)
+	    {
+	      x -= y;
+	      ++cquo;
+	    }
+	}
+    }
+  else
+    {
+      __float128 y_half = 0.5Q * y;
+      if (x > y_half)
+	{
+	  x -= y;
+	  ++cquo;
+	  if (x >= y_half)
+	    {
+	      x -= y;
+	      ++cquo;
+	    }
+	}
+    }
+
+  *quo = qs ? -cquo : cquo;
+
+  if (sx)
+    x = -x;
+  return x;
+}
diff --git a/libquadmath/quadmath-imp.h b/libquadmath/quadmath-imp.h
index 5404c9eef99..58e3146e364 100644
--- a/libquadmath/quadmath-imp.h
+++ b/libquadmath/quadmath-imp.h
@@ -42,12 +42,6 @@ extern __float128 __quadmath_kernel_cosq (__float128, __float128);
 #endif
 
 
-// If we don't have macros to know endianess, assume little endian
-#if !defined(__BIG_ENDIAN__) && !defined(__LITTLE_ENDIAN__)
-# define __LITTLE_ENDIAN__ 1
-#endif
-
-
 // Main union type we use to manipulate the floating-point type
 typedef union
 {
@@ -55,13 +49,12 @@ typedef union
 
   struct
   {
-#if __BIG_ENDIAN__
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     unsigned negative:1;
     unsigned exponent:15;
     uint64_t mant_high:48;
     uint64_t mant_low:64;
-#endif
-#if __LITTLE_ENDIAN__
+#else
     uint64_t mant_low:64;
     uint64_t mant_high:48;
     unsigned exponent:15;
@@ -71,11 +64,10 @@ typedef union
 
   struct
   {
-#if __BIG_ENDIAN__
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     uint64_t high;
     uint64_t low;
-#endif
-#if __LITTLE_ENDIAN__
+#else
     uint64_t low;
     uint64_t high;
 #endif
@@ -83,13 +75,12 @@ typedef union
 
   struct
   {
-#if __BIG_ENDIAN__
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     uint32_t w0;
     uint32_t w1;
     uint32_t w2;
     uint32_t w3;
-#endif
-#if __LITTLE_ENDIAN__
+#else
     uint32_t w3;
     uint32_t w2;
     uint32_t w1;
@@ -99,14 +90,13 @@ typedef union
 
   struct
   {
-#if __BIG_ENDIAN__
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
     unsigned negative:1;
     unsigned exponent:15;
     unsigned quiet_nan:1;
     uint64_t mant_high:47;
     uint64_t mant_low:64;
-#endif
-#if __LITTLE_ENDIAN__
+#else
     uint64_t mant_low:64;
     uint64_t mant_high:47;
     unsigned quiet_nan:1;
diff --git a/libquadmath/quadmath.h b/libquadmath/quadmath.h
index bc413375560..268c299111e 100644
--- a/libquadmath/quadmath.h
+++ b/libquadmath/quadmath.h
@@ -36,7 +36,7 @@ extern __float128 asinhq (__float128);
 extern __float128 atanq (__float128);
 extern __float128 atanhq (__float128);
 extern __float128 atan2q (__float128, __float128);
-extern __float128 cbrtq (const __float128);
+extern __float128 cbrtq (__float128);
 extern __float128 ceilq (__float128);
 extern __float128 copysignq (__float128, __float128);
 extern __float128 coshq (__float128);
@@ -46,38 +46,47 @@ extern __float128 erfcq (__float128);
 extern __float128 expq (__float128);
 extern __float128 expm1q (__float128);
 extern __float128 fabsq (__float128);
-extern int finiteq (const __float128);
+extern __float128 fdimq (__float128, __float128);
+extern int finiteq (__float128);
 extern __float128 floorq (__float128);
 extern __float128 fmaq (__float128, __float128, __float128);
+extern __float128 fmaxq (__float128, __float128);
+extern __float128 fminq (__float128, __float128);
 extern __float128 fmodq (__float128, __float128);
 extern __float128 frexpq (__float128, int *);
 extern __float128 hypotq (__float128, __float128);
 extern int isinfq (__float128);
-extern int isnanq (const __float128);
+extern int ilogbq (__float128);
+extern int isnanq (__float128);
 extern __float128 j0q (__float128);
 extern __float128 j1q (__float128);
 extern __float128 jnq (int, __float128);
 extern __float128 ldexpq (__float128, int);
 extern __float128 lgammaq (__float128);
+extern long long int llrintq (__float128);
 extern long long int llroundq (__float128);
 extern __float128 logq (__float128);
 extern __float128 log10q (__float128);
+extern __float128 log2q (__float128);
 extern __float128 log1pq (__float128);
+extern long int lrintq (__float128);
 extern long int lroundq (__float128);
 extern __float128 modfq (__float128, __float128 *);
 extern __float128 nanq (const char *);
+extern __float128 nearbyintq (__float128);
 extern __float128 nextafterq (__float128, __float128);
 extern __float128 powq (__float128, __float128);
 extern __float128 remainderq (__float128, __float128);
+extern __float128 remquoq (__float128, __float128, int *);
 extern __float128 rintq (__float128);
 extern __float128 roundq (__float128);
 extern __float128 scalblnq (__float128, long int);
 extern __float128 scalbnq (__float128, int);
-extern int signbitq (const __float128);
+extern int signbitq (__float128);
 extern void sincosq (__float128, __float128 *, __float128 *);
 extern __float128 sinhq (__float128);
 extern __float128 sinq (__float128);
-extern __float128 sqrtq (const __float128);
+extern __float128 sqrtq (__float128);
 extern __float128 tanq (__float128);
 extern __float128 tanhq (__float128);
 extern __float128 tgammaq (__float128);
@@ -90,6 +99,8 @@ extern __float128 ynq (int, __float128);
 // Prototypes for complex functions
 extern __float128 cabsq (__complex128);
 extern __float128 cargq (__complex128);
+extern __float128 cimagq (__complex128);
+extern __float128 crealq (__complex128);
 extern __complex128 cacosq (__complex128);
 extern __complex128 cacoshq (__complex128);
 extern __complex128 casinq (__complex128);
@@ -102,7 +113,9 @@ extern __complex128 cexpq (__complex128);
 extern __complex128 cexpiq (__float128);
 extern __complex128 clogq (__complex128);
 extern __complex128 clog10q (__complex128);
+extern __complex128 conjq (__complex128);
 extern __complex128 cpowq (__complex128, __complex128);
+extern __complex128 cprojq (__complex128);
 extern __complex128 csinq (__complex128);
 extern __complex128 csinhq (__complex128);
 extern __complex128 csqrtq (__complex128);
@@ -146,4 +159,25 @@ extern void quadmath_dtoaq (char *, size_t, size_t, __float128);
 #define M_SQRT2q	1.4142135623730950488016887242096981Q  /* sqrt(2) */
 #define M_SQRT1_2q	0.7071067811865475244008443621048490Q  /* 1/sqrt(2) */
 
+#define __quadmath_extern_inline \
+  extern inline __attribute__ ((__gnu_inline__))
+
+__quadmath_extern_inline __float128
+cimagq (__complex128 __z)
+{
+  return __imag__ __z;
+}
+
+__quadmath_extern_inline __float128
+crealq (__complex128 __z)
+{
+  return __real__ __z;
+}
+
+__quadmath_extern_inline __complex128
+conjq (__complex128 __z)
+{
+  return __extension__ ~__z;
+}
+
 #endif
diff --git a/libquadmath/quadmath.map b/libquadmath/quadmath.map
index 2a6628751d7..eab606dac60 100644
--- a/libquadmath/quadmath.map
+++ b/libquadmath/quadmath.map
@@ -7,12 +7,6 @@ QUADMATH_1.0 {
     atanq;
     atanhq;
     atan2q;
-    cacoshq;
-    cacosq;
-    casinhq;
-    casinq;
-    catanhq;
-    catanq;
     cbrtq;
     ceilq;
     copysignq;
@@ -23,12 +17,16 @@ QUADMATH_1.0 {
     expq;
     expm1q;
     fabsq;
+    fdimq;
     finiteq;
     floorq;
     fmaq;
+    fmaxq;
+    fminq;
     fmodq;
     frexpq;
     hypotq;
+    ilogbq;
     isinfq;
     isnanq;
     j0q;
@@ -36,16 +34,21 @@ QUADMATH_1.0 {
     jnq;
     ldexpq;
     lgammaq;
+    llrintq;
     llroundq;
     logq;
     log10q;
     log1pq;
+    log2q;
+    lrintq;
     lroundq;
     modfq;
     nanq;
+    nearbyintq;
     nextafterq;
     powq;
     remainderq;
+    remquoq;
     rintq;
     roundq;
     scalblnq;
@@ -64,13 +67,23 @@ QUADMATH_1.0 {
     ynq;
     cabsq;
     cargq;
+    cimagq;
+    crealq;
+    cacoshq;
+    cacosq;
+    casinhq;
+    casinq;
+    catanhq;
+    catanq;
     ccosq;
     ccoshq;
     cexpq;
     cexpiq;
     clogq;
     clog10q;
+    conjq;
     cpowq;
+    cprojq;
     csinq;
     csinhq;
     csqrtq;
diff --git a/libquadmath/quadmath_weak.h b/libquadmath/quadmath_weak.h
index d2c3d86d4a2..28cc14ad8bb 100644
--- a/libquadmath/quadmath_weak.h
+++ b/libquadmath/quadmath_weak.h
@@ -53,12 +53,16 @@ __qmath3 (erfcq)
 __qmath3 (expq)
 __qmath3 (expm1q)
 __qmath3 (fabsq)
+__qmath3 (fdimq)
 __qmath3 (finiteq)
 __qmath3 (floorq)
 __qmath3 (fmaq)
+__qmath3 (fmaxq)
+__qmath3 (fminq)
 __qmath3 (fmodq)
 __qmath3 (frexpq)
 __qmath3 (hypotq)
+__qmath3 (ilogbq)
 __qmath3 (isinfq)
 __qmath3 (isnanq)
 __qmath3 (j0q)
@@ -66,16 +70,21 @@ __qmath3 (j1q)
 __qmath3 (jnq)
 __qmath3 (ldexpq)
 __qmath3 (lgammaq)
+__qmath3 (llrintq)
 __qmath3 (llroundq)
 __qmath3 (logq)
 __qmath3 (log10q)
 __qmath3 (log1pq)
+__qmath3 (log2q)
+__qmath3 (lrintq)
 __qmath3 (lroundq)
 __qmath3 (modfq)
 __qmath3 (nanq)
+__qmath3 (nearbyintq)
 __qmath3 (nextafterq)
 __qmath3 (powq)
 __qmath3 (remainderq)
+__qmath3 (remquoq)
 __qmath3 (rintq)
 __qmath3 (roundq)
 __qmath3 (scalblnq)
@@ -97,6 +106,8 @@ __qmath3 (ynq)
 // Prototypes for complex functions
 __qmath3 (cabsq)
 __qmath3 (cargq)
+__qmath3 (cimagq)
+__qmath3 (crealq)
 __qmath3 (cacosq)
 __qmath3 (cacoshq)
 __qmath3 (casinq)
@@ -109,7 +120,9 @@ __qmath3 (cexpq)
 __qmath3 (cexpiq)
 __qmath3 (clogq)
 __qmath3 (clog10q)
+__qmath3 (conjq)
 __qmath3 (cpowq)
+__qmath3 (cprojq)
 __qmath3 (csinq)
 __qmath3 (csinhq)
 __qmath3 (csqrtq)