libc

When I compile C code with my cross toolchain, the linker prints pages of warnings saying that my executable uses hard floats but my libc uses soft floats. What's the difference? Hard floats use an on-chip floating point unit. Soft floats emulate one in software. The difference is speed. It's strange to see both used on the same target architecture, since the chip either has an FPU or doesn't. You can enable soft floating point in GCC with -msoft-float. You may want to recompile your libc to use hardware floating point if you use it. There are three ways to do floating point arithmetic: Use

I'm trying to learn more about the FFI in Rust and linking with C libraries (specifically libc ). While on my "quest" I came accross the following problem. Normal pattern in C void(* sig_set(int sig, void(*handler)(int))) { // uninitialized sigaction structs struct sigaction new_action, old_action; // assign options to new action new_action.sa_flags = SA_RESTART; new_action.sa_handler = handler; sigemptyset(&new_action.sa_mask); if(sigaction(sig, &new_action, &old_action) < 0) { fprintf(stderr, "Error: %s!\n", "signal error"); exit(1); } return old_action.sa_handler; } Attempt in Rust fn sig

If a socket is bound to IN6ADDR_ANY or INADDR_ANY and you use a call such as recvfrom() to receive messages on the socket. Is there a way to find out which interface the message came from? In the case of IPv6 link-scope messages, I was hoping that the from argument of recvfrom() would have the scope_id field initialized to the interface Id. Unfortunately it is set to 0 in my test program. Anybody know of a way to find out this information? Apart from binding to each interface, I'm not aware of a way with IPv4, per se. IPv6 has added the IPV6_PKTINFO socket option to address this shortcoming.

I can use select() to determine if a call to recv() would block, but once I've determined that their are bytes to be read, is their a way to query how many bytes are currently available before I actually call recv()? nickm If your OS provides it (and most do), you can use ioctl(..,FIONREAD,..): int get_n_readable_bytes(int fd) { int n = -1; if (ioctl(fd, FIONREAD, &n) < 0) { perror("ioctl failed"); return -1; } return n; } Windows provides an analogous ioctlsocket(..,FIONREAD,..), which expects a pointer to unsigned long: unsigned long get_n_readable_bytes(SOCKET sock) { unsigned long n = -1;

The result of abs(-2147483648) is -2147483648, isn't it? it seems unacceptable. printf("abs(-2147483648): %d\n", abs(-2147483648)); output: abs(-2147483648): -2147483648 Alexey Frunze The standard says about abs() : The abs , labs , and llabs functions compute the absolute value of an integer j . If the result cannot be represented, the behavior is undefined. And the result indeed cannot be represented because the 2's complement representation of signed integers isn't symmetric. Think about it... If you have 32 bits in an int , that gives you 2 32 distinct values from INT_MIN to INT_MAX . That

I'm currently using GCC 4.5.3, compiled for PowerPC 440, and am compiling some code that doesn't require libc. I don't have any direct calls to memcpy(), but the compiler seems to be inserting one during the build. There are linker options like -nostdlib, -nostartfiles, -nodefaultlibs but I'm unable to use them as I'm not doing the linking phase. I'm only compiling. With something like this: $ powerpc-440-eabi-gcc -O2 -g -c -o output.o input.c If I check the output.o with nm, I see a reference to memcpy: $ powerpc-440-eabi-nm output.o | grep memcpy U memcpy $ The GCC man page makes it clear

I'm using the standard mktime function to turn a struct tm into an epoch time value. The tm fields are populated locally, and I need to get the epoch time as GMT. tm has a gmtoff field to allow you to set the local GMT offset in seconds for just this purpose. But I can't figure out how to get that information. Surely there must be a standard function somewhere that will return the offset? How does localtime do it? Just do the following: #define _GNU_SOURCE /* for tm_gmtoff and tm_zone */ #include <stdio.h> #include <time.h> /* Checking errors returned by system calls was omitted for the sake