update to set up make variables for compiling modules with libhrtime
[dyninst.git] / common / src / osfKludges.C
1 /*
2  * Copyright (c) 1996-2000 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // $Id: osfKludges.C,v 1.6 2000/08/20 21:58:25 paradyn Exp $
43
44 #include "common/h/headers.h"
45
46 extern "C" {
47 //extern int accept(int, struct sockaddr *addr, int *);
48 //extern int accept(int, struct sockaddr *addr, size_t *);
49 //extern void bzero(char *b, int length);
50 extern int gethostname(char*, int);
51 extern int getrusage(int, struct rusage*);
52 //extern int getsockname(int, struct sockaddr*, int *);
53 //extern int getsockname(int, struct sockaddr*, size_t *);
54
55 extern int listen(int, int);
56 extern int rexec(char **ahost, u_short inport, char *user, char *passwd,
57                  char *cmd, int *fd2p);
58 extern int socket(int, int, int);
59 extern int socketpair(int, int, int, int sv[2]);
60 extern int pipe(int fd[2]);
61 extern int vfork();
62 extern int fork();
63 extern int strcasecmp(const char *s1, const char *s2);
64 extern int strncasecmp(const char *s1, const char *s2, long unsigned int  n);
65 };
66
67 /* Non standard (even from sunos4 to sunos5 -- blech */
68
69 /* POSIX */
70 void P_abort() { abort();}
71 int P_close (int FILEDES) { return (close(FILEDES));}
72 int P_dup2 (int OLD, int NEW) { return (dup2(OLD, NEW));}
73 // int P_execlp (const char *FILENAME, const char *ARG0) {
74 //  return (execlp(FILENAME, ARG0, NULL));}
75 int P_execvp (const char *FILENAME, char *const ARGV[]) {
76   return (execvp(FILENAME, ARGV));}
77 void P__exit (int STATUS) { _exit(STATUS);}
78 int P_fcntl (int filedes, int command, int arg2) {
79   return (fcntl(filedes, command, arg2));}
80 FILE * P_fdopen (int FILEDES, const char *OPENTYPE) {
81   return (fdopen(FILEDES, OPENTYPE));}
82 FILE * P_fopen (const char *FILENAME, const char *OPENTYPE) {
83   return (fopen(FILENAME, OPENTYPE));}
84 int P_fstat (int FILEDES, struct stat *BUF) { return (fstat(FILEDES, BUF));}
85 pid_t P_getpid () { return (getpid());}
86 int P_kill(pid_t PID, int SIGNUM) { return (kill(PID, SIGNUM));}
87 off_t P_lseek (int FILEDES, off_t OFFSET, int WHENCE) {
88   return (lseek(FILEDES, OFFSET, WHENCE));}
89 int P_open(const char *FILENAME, int FLAGS, mode_t MODE) {
90   return (open(FILENAME, FLAGS, MODE));}
91 int P_pclose (FILE *STREAM) { return (pclose(STREAM));}
92 FILE *P_popen (const char *COMMAND, const char *MODE) { return (popen(COMMAND, MODE));}
93 size_t P_read (int FILEDES, void *BUFFER, size_t SIZE) {
94   return (read(FILEDES, BUFFER, SIZE));}
95 int P_uname(struct utsname *unm) { return (uname(unm));}
96 pid_t P_wait(int *status_ptr) { return (wait(status_ptr));}
97 pid_t P_waitpid(pid_t pid, int *statusp, int options) {
98   return (waitpid(pid, statusp, options));}
99 size_t P_write (int FILEDES, const void *BUFFER, size_t SIZE) {
100   return (write(FILEDES, BUFFER, SIZE));}
101 int P_chdir(const char *path) { return (chdir(path)); }
102
103 int P_putenv(char *str) { return putenv(str); }
104
105 /* SYSTEM-V shared memory */
106 int P_shmget(key_t thekey, int size, int flags) { return shmget(thekey, size, flags); }
107 void *P_shmat(int shmid, void *addr, int flags) { return shmat(shmid, addr, flags); }
108 int P_shmdt(void *addr) { return shmdt(addr); }
109 int P_shmctl(int shmid, int cmd, struct shmid_ds *buf) { return shmctl(shmid, cmd, buf); }
110
111 /* ANSI */
112 void P_exit (int STATUS) { exit(STATUS);}
113 int P_fflush(FILE *stream) {return (fflush(stream));}
114 char *P_fgets (char *S, int COUNT, FILE *STREAM) { return (fgets(S, COUNT, STREAM));}
115 void * P_malloc (size_t SIZE) { return (malloc(SIZE));}
116 void * P_memcpy (void *A1, const void *A2, size_t SIZE) {
117   return (memcpy(A1, A2, SIZE));}
118 void * P_memset (void *BLOCK, int C, unsigned SIZE) {
119   return (memset(BLOCK, C, SIZE));}
120 void P_perror (const char *MESSAGE) { perror(MESSAGE);}
121 P_sig_handler P_signal (int SIGNUM, P_sig_handler ACTION) {
122   return (signal(SIGNUM, ACTION));}
123 char *P_strcat(char *TO, const char *FROM) { return (strcat(TO, FROM));}
124 char *P_strchr(const char *S, int C) { return (strchr(S, C));}
125 int P_strcmp(const char *S1, const char *S2) { return (strcmp(S1, S2));}
126 char *P_strcpy(char *TO, const char *FROM) { return (strcpy(TO, FROM));}
127 char *P_strdup(const char *FROM) { return (strdup(FROM));}
128 size_t P_strlen (const char *S) { return (strlen(S));}
129 char * P_strncat (char *TO, const char *FROM, size_t SIZE) {
130   return (strncat(TO, FROM, SIZE));}
131 int P_strncmp (const char *S1, const char *S2, size_t SIZE) {
132   return (strncmp(S1, S2, SIZE));}
133 char * P_strncpy (char *TO, const char *FROM, size_t SIZE) {
134   return (strncpy(TO, FROM, SIZE));}
135 char * P_strrchr (const char *STRING, int C) { return (strrchr(STRING, C));}
136 char * P_strstr (const char *HAYSTACK, const char *NEEDLE) {
137   return (strstr(HAYSTACK, NEEDLE));}
138 double P_strtod (const char *STRING, char **TAILPTR) {
139   return(strtod(STRING, TAILPTR));}
140 char * P_strtok (char *NEWSTRING, const char *DELIMITERS) {
141   return (strtok(NEWSTRING, DELIMITERS));}
142 long int P_strtol (const char *STRING, char **TAILPTR, int BASE){
143   return (strtol(STRING, TAILPTR, BASE));}
144 unsigned long int P_strtoul(const char *STRING, char **TAILPTR, int BASE){
145   return (strtoul(STRING, TAILPTR, BASE));}
146
147 /* BSD */
148
149 int P_accept (int SOCK, struct sockaddr *ADDR, size_t *LENGTH_PTR) {
150 #if defined(CROSSCOMPILER)
151   return (accept(SOCK, ADDR, (int *)LENGTH_PTR));
152 #else
153   return (accept(SOCK, ADDR, (int *)LENGTH_PTR));
154 #endif
155 }
156
157 int P_bind(int socket, struct sockaddr *addr, size_t len) {
158   return (bind(socket, addr, len));}
159
160 // void P_bzero(void *block, size_t size) { bzero(block, size);}
161
162 int P_connect(int socket, struct sockaddr *addr, size_t len) {
163   return (connect(socket, addr, len));}
164
165 struct hostent *P_gethostbyname (const char *NAME) { 
166   return (gethostbyname(NAME));
167 }
168
169 int P_gethostname(char *name, size_t size) {
170   return (gethostname(name, size));}
171
172 int P_getrusage(int i, struct rusage *r) {return (getrusage(i, r));}
173
174 struct servent *P_getservbyname (const char *NAME, const char *PROTO) {
175   return (getservbyname(NAME, PROTO));}
176
177 int P_getsockname (int SOCKET, struct sockaddr *ADDR, size_t *LENGTH_PTR) {
178 #if defined(CROSSCOMPILER)
179   return (getsockname(SOCKET, ADDR, (int *)LENGTH_PTR));
180 #else
181   return (getsockname(SOCKET, ADDR, (int *)LENGTH_PTR));
182 #endif
183 }
184
185 /* int P_gettimeofday (struct timeval *TP, struct timezone *TZP) {
186   return (gettimeofday(TP, TZP));} */
187
188 int P_listen(int socket, unsigned int n) {
189   return (listen(socket, n));}
190
191 caddr_t P_mmap(caddr_t addr, size_t len, int prot, int flags,
192                int fd, off_t off) {
193   return ((caddr_t)mmap(addr, len, prot, flags, fd, off));}
194
195 int P_munmap(caddr_t ca, int i) {return (munmap(ca, i));}
196
197 int P_select (int wid, fd_set *rd, fd_set *wr, fd_set *ex, struct timeval *tm) {
198   return (select((unsigned long)wid, rd, wr, ex, tm));}
199
200 int P_socket (int NAMESPACE, int STYLE, int PROTOCOL) {
201   return (socket(NAMESPACE, STYLE, PROTOCOL));}
202
203 int P_socketpair(int NAMESPACE, int style, int protocol, int filedes[2]) {
204   return (socketpair(NAMESPACE, style, protocol, filedes));}
205
206 int P_pipe(int fd[2]) { return (pipe(fd)); }
207
208 int P_strcasecmp(const char *s1, const char *s2) {
209   return (strcasecmp((char*)s1, (char*)s2));}
210
211 int P_strncasecmp (const char *S1, const char *S2, size_t N) {
212   return (strncasecmp((char*)S1, (char*)S2, N));}
213
214 int P_rexec(char **ahost, u_short inport, char *user,
215             char *passwd, char *cmd, int *fd2p){
216   return (rexec(ahost, inport, user, passwd, cmd, fd2p));}
217
218 void P_endservent(void) { endservent(); }
219
220 void P_xdr_destroy(XDR *xdrs) { xdr_destroy(xdrs); }
221 bool_t P_xdr_u_char(XDR *x, u_char *u) { return (xdr_u_char(x, u));}
222 bool_t P_xdr_int(XDR *x, int *i) { return (xdr_int(x, i));}
223 bool_t P_xdr_double(XDR *x, double *d) { return (xdr_double(x, d));}
224 bool_t P_xdr_u_int(XDR *x, u_int *u) { return (xdr_u_int(x, u));}
225 bool_t P_xdr_float(XDR *x, float *f) { return (xdr_float(x, f));}
226 bool_t P_xdr_char(XDR *x, char *c) { return (xdr_char(x, c));}
227 bool_t P_xdr_string(XDR *x, char **c, const u_int maxsize) {
228   return (xdr_string(x, c, maxsize));}
229 bool_t P_xdrrec_endofrecord(XDR *x, int now) {return (xdrrec_endofrecord(x, now));}
230 bool_t P_xdrrec_skiprecord(XDR*x) { return (xdrrec_skiprecord(x));}
231 void P_xdrrec_create(XDR *x, const u_int send_sz, const u_int rec_sz,
232                      const caddr_t handle, 
233                      xdr_rd_func readit, xdr_wr_func writeit) {
234   xdrrec_create(x, send_sz, rec_sz, handle, 
235                 (int(*)(...))readit, 
236                 (int(*)(...))writeit);}
237
238
239 unsigned long long PDYN_div1000(unsigned long long in) {
240    /* Divides by 1000 without an integer division instruction or library call, both of
241     * which are slow.
242     * We do only shifts, adds, and subtracts.
243     *
244     * We divide by 1000 in this way:
245     * multiply by 1/1000, or multiply by (1/1000)*2^30 and then right-shift by 30.
246     * So what is 1/1000 * 2^30?
247     * It is 1,073,742.   (actually this is rounded)
248     * So we can multiply by 1,073,742 and then right-shift by 30 (neat, eh?)
249     *
250     * Now for multiplying by 1,073,742...
251     * 1,073,742 = (1,048,576 + 16384 + 8192 + 512 + 64 + 8 + 4 + 2)
252     * or, slightly optimized:
253     * = (1,048,576 + 16384 + 8192 + 512 + 64 + 16 - 2)
254     * for a total of 8 shifts and 6 add/subs, or 14 operations.
255     *
256     */
257
258    unsigned long long temp = in << 20; // multiply by 1,048,576
259       // beware of overflow; left shift by 20 is quite a lot.
260       // If you know that the input fits in 32 bits (4 billion) then
261       // no problem.  But if it's much bigger then start worrying...
262
263    temp += in << 14; // 16384
264    temp += in << 13; // 8192
265    temp += in << 9;  // 512
266    temp += in << 6;  // 64
267    temp += in << 4;  // 16
268    temp -= in >> 2;  // 2
269
270    return (temp >> 30); // divide by 2^30
271 }
272
273 unsigned long long PDYN_divMillion(unsigned long long in) {
274    /* Divides by 1,000,000 without an integer division instruction or library call,
275     * both of which are slow.
276     * We do only shifts, adds, and subtracts.
277     *
278     * We divide by 1,000,000 in this way:
279     * multiply by 1/1,000,000, or multiply by (1/1,000,000)*2^30 and then right-shift
280     * by 30.  So what is 1/1,000,000 * 2^30?
281     * It is 1,074.   (actually this is rounded)
282     * So we can multiply by 1,074 and then right-shift by 30 (neat, eh?)
283     *
284     * Now for multiplying by 1,074
285     * 1,074 = (1024 + 32 + 16 + 2)
286     * for a total of 4 shifts and 4 add/subs, or 8 operations.
287     *
288     * Note: compare with div1000 -- it's cheaper to divide by a million than
289     *       by a thousand (!)
290     *
291     */
292
293    unsigned long long temp = in << 10; // multiply by 1024
294       // beware of overflow...if the input arg uses more than 52 bits
295       // than start worrying about whether (in << 10) plus the smaller additions
296       // we're gonna do next will fit in 64...
297
298    temp += in << 5; // 32
299    temp += in << 4; // 16
300    temp += in << 1; // 2
301
302    return (temp >> 30); // divide by 2^30
303 }
304
305 unsigned long long PDYN_mulMillion(unsigned long long in) {
306    unsigned long long result = in;
307
308    /* multiply by 125 by multiplying by 128 and subtracting 3x */
309    result = (result << 7) - result - result - result;
310
311    /* multiply by 125 again, for a total of 15625x */
312    result = (result << 7) - result - result - result;
313
314    /* multiply by 64, for a total of 1,000,000x */
315    result <<= 6;
316
317    /* cost was: 3 shifts and 6 subtracts
318     * cost of calling mul1000(mul1000()) would be: 6 shifts and 4 subtracts
319     *
320     * Another algorithm is to multiply by 2^6 and then 5^6.
321     * The former is super-cheap (one shift); the latter is more expensive.
322     * 5^6 = 15625 = 16384 - 512 - 256 + 8 + 1
323     * so multiplying by 5^6 means 4 shift operations and 4 add/sub ops
324     * so multiplying by 1000000 means 5 shift operations and 4 add/sub ops.
325     * That may or may not be cheaper than what we're doing (3 shifts; 6 subtracts);
326     * I'm not sure.  --ari
327     */
328
329    return result;
330 }