From f3d5e526d08aa91850b502be26c16a09bc8a5b80 Mon Sep 17 00:00:00 2001
From: orbitcowboy <ettl.martin78@gmail.com>
Date: Thu, 5 Oct 2017 09:58:12 +0200
Subject: [PATCH] std.cfg: Added more returnValue-types.

---
 cfg/std.cfg | 661 +++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 597 insertions(+), 64 deletions(-)

diff --git a/cfg/std.cfg b/cfg/std.cfg
index 0b68ab62b..48c2a5580 100644
--- a/cfg/std.cfg
+++ b/cfg/std.cfg
@@ -1966,13 +1966,12 @@
   </function>
   <!-- double hypot(double x, double y); -->
   <!-- double hypot(double x, double y, double z); -->
-  <!-- float hypotf(float x, float y); -->
-  <!-- long double hypotl(long double x, long double y); -->
-  <function name="hypot,std::hypot,hypotf,std::hypotf,hypotl,std::hypotl">
+  <function name="hypot,std::hypot">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -1983,6 +1982,34 @@
       <not-uninit/>
     </arg>
   </function>
+  <!-- float hypotf(float x, float y); -->
+  <function name="hypotf,std::hypotf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double hypotl(long double x, long double y); -->
+  <function name="hypotl,std::hypotl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- int fscanf(FILE *stream, const char *format, ...); -->
   <function name="fscanf,std::fscanf">
     <noreturn>false</noreturn>
@@ -2077,6 +2104,7 @@
   <function name="fgetws,std::fgetws">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t*"/>
     <arg nr="1">
       <not-null/>
       <minsize type="argvalue" arg="2"/>
@@ -2747,25 +2775,62 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- long int labs(long int x); -->
-  <!-- long long int llabs(long long int x);-->
-  <function name="labs,llabs,std::labs,std::llabs">
+  <function name="labs,std::labs">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
-    <returnValue>arg1&gt;0?arg1:-arg1</returnValue>
+    <returnValue type="long int">arg1&gt;0?arg1:-arg1</returnValue>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long long int llabs(long long int x);-->
+  <function name="llabs,std::llabs">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long long int">arg1&gt;0?arg1:-arg1</returnValue>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double ldexp(double x, int exp); -->
-  <!-- float ldexpf(float x, int exp); -->
-  <!-- long double ldexpl(long double x, int exp); -->
-  <function name="ldexp,std::ldexp,ldexpf,ldexpl">
+  <function name="ldexp,std::ldexp">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float ldexpf(float x, int exp); -->
+  <function name="ldexpf,std::ldexpf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double ldexpl(long double x, int exp); -->
+  <function name="ldexpl,std::ldexpl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2774,25 +2839,67 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double lgamma(double x); -->
-  <!-- float lgammaf(float x); -->
-  <!-- long double lgammal(long double x); -->
-  <function name="lgamma,std::lgamma,lgammaf,std::lgammaf,lgammal,std::lgammal">
+  <function name="lgamma,std::lgamma">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float lgammaf(float x); -->
+  <function name="lgammaf,std::lgammaf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double lgammal(long double x); -->
+  <function name="lgammal,std::lgammal">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double rint(double x); -->
-  <!-- float rintf(float x); -->
-  <!-- long double rintl(long double x); -->
-  <function name="rint,std::rint,rintf,std::rintf,rintl,std::rintl">
+  <function name="rint,std::rint">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float rintf(float x); -->
+  <function name="rintf,std::rintf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double rintl(long double x); -->
+  <function name="rintl,std::rintl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2804,6 +2911,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
+    <returnValue type="long int"/>
     <leak-ignore/>
     <arg nr="1">
       <not-uninit/>
@@ -2817,6 +2925,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="long long int"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2829,6 +2938,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="long long int"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2841,6 +2951,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="long int"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2862,11 +2973,25 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- ldiv_t ldiv(long int num, long int denom); -->
+  <function name="ldiv,lldiv,std::ldiv,std::lldiv">
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="ldiv_t"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+      <valid>:-1,1:</valid>
+    </arg>
+  </function>
   <!-- lldiv_t lldiv(long long int num, long long int denom); -->
   <function name="ldiv,lldiv,std::ldiv,std::lldiv">
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="lldiv_t"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2879,6 +3004,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="localtime,std::localtime">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="struct tm *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -2888,6 +3014,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="localtime_s,std::localtime_s">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="struct tm *"/>
     <arg nr="1">
       <not-null/>
     </arg>
@@ -2896,12 +3023,31 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double log(double x); -->
-  <!-- float logf(float x); -->
-  <!-- long double logl(long double x);-->
-  <function name="log,std::log,logf,logl">
+  <function name="log,std::log">
     <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float logf(float x); -->
+  <function name="logf,std::logf">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double logl(long double x);-->
+  <function name="logl,std::logl">
+    <use-retval/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -2990,13 +3136,34 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double logb(double x); -->
-  <!-- float logbf(float x); -->
-  <!-- long double logbl(long double x); -->
-  <function name="logb,std::logb,logbf,std::logbf,logbl,std::logbl">
+  <function name="logb,std::logb">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float logbf(float x); -->
+  <function name="logbf,std::logbf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double logbl(long double x); -->
+  <function name="logbl,std::logbl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3044,13 +3211,36 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double nan(const char *tagp); -->
-  <!-- float nanf(const char *tagp); -->
-  <!-- long double nanl(const char *tagp); -->
-  <function name="nan,std::nan,nanf,std::nanf,nanl,std::nanl">
+  <function name="nan,std::nan">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float nanf(const char *tagp); -->
+  <function name="nanf,std::nanf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double nanl(const char *tagp); -->
+  <function name="nanl,std::nanl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -3093,74 +3283,208 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- int ilogb(double x); -->
+  <function name="ilogb,std::ilogb">
+    <use-retval/>
+    <returnValue type="int"/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <returnValue type="double"/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- int ilogbf(float x); -->
+  <function name="ilogbf,std::ilogbf">
+    <use-retval/>
+    <returnValue type="int"/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <returnValue type="float"/>
+    <leak-ignore/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
   <!-- int ilogbl(long double x); -->
-  <function name="ilogb,std::ilogb,ilogbf,ilogbl">
+  <function name="ilogbl,std::ilogbl">
     <use-retval/>
     <returnValue type="int"/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double log10(double x); -->
-  <!-- float log10f(float x);-->
-  <!-- long double log10l(long double x); -->
-  <function name="log10,std::log10,log10f,log10l">
+  <function name="log10,std::log10">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float log10f(float x);-->
+  <function name="log10f,std::log10f">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double log10l(long double x); -->
+  <function name="log10l,std::log10l">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double log1p(double x); -->
-  <!-- float log1pf(float x); -->
-  <!-- long double log1pl(long double x); -->
-  <function name="log1p,std::log1p,log1pf,std::log1pf,log1pl,std::log1pl">
+  <function name="log1p,std::log1p">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float log1pf(float x); -->
+  <function name="log1pf,std::log1pf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double log1pl(long double x); -->
+  <function name="log1pl,std::log1pl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double log2(double x); -->
-  <!-- float log2f(float x); -->
-  <!-- long double log2l(long double x); -->
-  <function name="log2,std::log2,log2f,std::log2f,log2l,std::log2l">
+  <function name="log2,std::log2">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float log2f(float x); -->
+  <function name="log2f,std::log2f">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double log2l(long double x); -->
+  <function name="log2l,std::log2l">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double nearbyint(double x); -->
-  <!-- float nearbyintf(float x); -->
-  <!-- long double nearbyintl(long double x); -->
-  <function name="nearbyint,std::nearbyint,nearbyintf,std::nearbyintf,nearbyintl,std::nearbyintl">
+  <function name="nearbyint,std::nearbyint">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float nearbyintf(float x); -->
+  <function name="nearbyintf,std::nearbyintf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double nearbyintl(long double x); -->
+  <function name="nearbyintl,std::nearbyintl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
   </function>
   <!-- double nextafter(double x, double y); -->
-  <!-- float nextafterf(float x, float y); -->
-  <!-- long double nextafterl(long double x, long double y);-->
-  <function name="nextafter,std::nextafter,nextafterf,std::nextafterf,nextafterl,std::nextafterl">
+  <function name="nextafter,std::nextafter">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float nextafterf(float x, float y); -->
+  <function name="nextafterf,std::nextafterf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double nextafterl(long double x, long double y);-->
+  <function name="nextafterl,std::nextafterl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3169,13 +3493,40 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double nexttoward(double x, long double y); -->
-  <!-- float nexttowardf(float x, long double y); -->
-  <!-- long double nexttowardl(long double x, long double y); -->
-  <function name="nexttoward,std::nexttoward,nexttowardf,std::nexttowardf,nexttowardl,std::nexttowardl">
+  <function name="nexttoward,std::nexttoward">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float nexttowardf(float x, long double y); -->
+  <function name="nexttowardf,std::nexttowardf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double nexttowardl(long double x, long double y); -->
+  <function name="nexttowardl,std::nexttowardl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3197,6 +3548,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- void * malloc(size_t size); -->
   <function name="malloc,std::malloc">
     <use-retval/>
+    <returnValue type="void *"/>
     <noreturn>false</noreturn>
     <arg nr="1">
       <not-uninit/>
@@ -3206,6 +3558,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- void *alloca(size_t size); -->
   <function name="alloca">
     <use-retval/>
+    <returnValue type="void *"/>
     <noreturn>false</noreturn>
     <arg nr="1">
       <not-uninit/>
@@ -3219,6 +3572,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -3241,6 +3595,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -3392,6 +3747,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="memset,std::memset">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void *"/>
     <arg nr="1">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -3409,6 +3765,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="wmemset,std::wmemset">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t *"/>
     <arg nr="1">
       <not-null/>
       <minsize type="argvalue" arg="3"/>
@@ -3434,11 +3791,34 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double modf(double x, double *ip); -->
-  <!-- float modff(float x, float *ip); -->
-  <!-- long double modfl(long double x, long double *ip); -->
-  <function name="modf,std::modf,modff,modfl">
+  <function name="modf,std::modf">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- float modff(float x, float *ip); -->
+  <function name="modff,std::modff">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- long double modfl(long double x, long double *ip); -->
+  <function name="modfl,std::modfl">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3455,13 +3835,40 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double pow(double x, double y); -->
-  <!-- float powf(float x, float y);-->
-  <!-- long double powl(long double x, long double y); -->
-  <function name="pow,std::pow,powf,powl">
+  <function name="pow,std::pow">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float powf(float x, float y);-->
+  <function name="powf,std::powf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double powl(long double x, long double y); -->
+  <function name="powl,std::powl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3485,13 +3892,40 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double remainder(double x, double y); -->
-  <!-- float remainderf(float x, float y); -->
-  <!-- long double remainderl(long double x, long double y); -->
-  <function name="remainder,std::remainder,remainderf,std::remainderf,remainderl,std::remainderl">
+  <function name="remainder,std::remainder">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float remainderf(float x, float y); -->
+  <function name="remainderf,std::remainderf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double remainderl(long double x, long double y); -->
+  <function name="remainderl,std::remainderl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3500,13 +3934,46 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double remquo(double, x, double y, int *quo); -->
-  <!-- float remquof(float x, float y, int *quo); -->
-  <!-- long double remquol(long double x, long double y, int *quo); -->
-  <function name="remquo,std::remquo,remquof,std::remquof,remquol,std::remquol">
+  <function name="remquo,std::remquo">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- float remquof(float x, float y, int *quo); -->
+  <function name="remquof,std::remquof">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+    <arg nr="2">
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-null/>
+    </arg>
+  </function>
+  <!-- long double remquol(long double x, long double y, int *quo); -->
+  <function name="remquol,std::remquol">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3554,6 +4021,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="void *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -3659,6 +4127,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- void *realloc(void *block, size_t newsize); -->
   <function name="realloc,std::realloc">
     <noreturn>false</noreturn>
+    <returnValue type="void *"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3704,13 +4173,34 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- double round(double x); -->
-  <!-- float roundf(float x); -->
-  <!-- long double roundl(long double x); -->
-  <function name="round,std::round,roundf,std::roundf,roundl,std::roundl">
+  <function name="round,std::round">
     <use-retval/>
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- float roundf(float x); -->
+  <function name="roundf,std::roundf">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-uninit/>
+    </arg>
+  </function>
+  <!-- long double roundl(long double x); -->
+  <function name="roundl,std::roundl">
+    <use-retval/>
+    <pure/>
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -3983,7 +4473,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   </function>
   <!-- wchar_t *wcscpy(wchar_t *deststr, const wchar_t *srcstr); -->
   <function name="wcscpy,std::wcscpy">
-    <returnValue type="wchar_t"/>
+    <returnValue type="wchar_t *"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
     <arg nr="1">
@@ -4172,6 +4662,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <pure/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -4248,6 +4739,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <!-- struct lconv* localeconv(void); -->
   <function name="localeconv,std::localeconv">
     <use-retval/>
+    <returnValue type="struct lconv*"/>
     <noreturn>false</noreturn>
     <leak-ignore/>
   </function>
@@ -4255,6 +4747,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="setlocale,std::setlocale">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="char *"/>
     <arg nr="1">
       <not-uninit/>
     </arg>
@@ -4309,6 +4802,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -4321,6 +4815,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
   <function name="wcsncpy,std::wcsncpy">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t *"/>
     <arg nr="1">
       <not-null/>
     </arg>
@@ -4403,6 +4898,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     <use-retval/>
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="wchar_t *"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -4443,10 +4939,24 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- intmax_t strtoimax(const char *s, char **endp, int base); -->
-  <!-- uintmax_t strtoumax(const char *s, char **endp, int base); -->
-  <function name="strtoimax,std::strtoimax,strtoumax,std::strtoumax">
+  <function name="strtoimax,std::strtoimax">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="intmax_t"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+    </arg>
+    <arg nr="3">
+      <not-uninit/>
+      <valid>0,2:36</valid>
+    </arg>
+  </function>
+  <!-- uintmax_t strtoumax(const char *s, char **endp, int base); -->
+  <function name="strtoumax,std::strtoumax">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="uintmax_t"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>
@@ -4457,11 +4967,34 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
     </arg>
   </function>
   <!-- float strtof(const char *s, char **endp); -->
-  <!-- double strtod(const char *s, char **endp); -->
-  <!-- long double strtold(const char *s, char **endp); -->
-  <function name="strtof,std::strtof,strtod,std::strtod,strtold,std::strtold">
+  <function name="strtof,std::strtof">
     <noreturn>false</noreturn>
     <leak-ignore/>
+    <returnValue type="float"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2"/>
+  </function>
+  <!-- double strtod(const char *s, char **endp); -->
+  <function name="strtod,std::strtod">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="double"/>
+    <arg nr="1">
+      <not-null/>
+      <not-uninit/>
+      <strz/>
+    </arg>
+    <arg nr="2"/>
+  </function>
+  <!-- long double strtold(const char *s, char **endp); -->
+  <function name="strtold,std::strtold">
+    <noreturn>false</noreturn>
+    <leak-ignore/>
+    <returnValue type="long double"/>
     <arg nr="1">
       <not-null/>
       <not-uninit/>