Changeset 2919


Ignore:
Timestamp:
Mar 27, 2012, 2:22:52 AM (3 years ago)
Author:
wmb
Message:

Client library - big checkin to
a) Support cell-sized stdin and stdout properties
b) Clean up data typing to satisfy XCode compilers

Location:
clients
Files:
3 added
17 edited

Legend:

Unmodified
Added
Removed
  • clients/hello/hello.c

    r151 r2919  
    1 main() 
     1#include "1275.h" 
     2 
     3int main() 
    24{ 
    35    printf("Hello, world\n"); 
     6    return 0; 
    47} 
  • clients/lib/1275.h

    r1010 r2919  
    11// See license at end of file 
    22 
    3 #include "types.h" 
     3// ----------------------------------------------------------------- 
     4// Type definitions and miscellaneous data structures 
    45 
    5 typedef long phandle; 
    6 typedef long ihandle; 
     6#ifndef __1275_h__ 
     7#define __1275_h__ 
     8 
     9#define NULL   0 
     10 
     11typedef unsigned char UCHAR; 
     12typedef unsigned long ULONG; 
     13 
     14typedef ULONG cell_t ; 
     15typedef ULONG phandle; 
     16typedef ULONG ihandle; 
    717 
    818typedef struct { 
    9         long hi, lo; 
    10         long size; 
     19        ULONG hi, lo; 
     20        ULONG size; 
    1121} reg; 
    1222 
     
    2535#define new(t)  (t *)zalloc(sizeof(t)); 
    2636 
    27 #ifdef SPRO 
    28 typedef long long cell_t; 
    29 #else 
    30 typedef unsigned long cell_t ; 
    31 #endif 
     37#define LOW(index) (index) 
    3238 
    33 #ifdef CIF64 
    34 #define LOW(index) ((index*2) + 1) 
    35 #else 
    36 #define LOW(index) (index) 
    37 #endif 
     39// ----------------------------------------------------------------- 
     40// External C library functions, and the like. 
    3841 
     42#include <stdlib.h> 
     43 
     44extern int   decode_int(UCHAR *); 
     45extern void  exit(int); 
     46extern void  fatal(char *fmt, ...); 
     47extern void  free(void *); 
     48extern cell_t get_cell_prop(phandle, char *); 
     49extern cell_t get_cell_prop_def(phandle, char *, cell_t); 
     50extern int   get_int_prop(phandle, char *); 
     51extern int   get_int_prop_def(phandle, char *, int); 
     52extern char *get_str_prop(phandle, const char *, allocflag); 
     53extern void *malloc(size_t); 
     54extern void  memcpy(void *, void *, size_t); 
     55extern void  memset(void *, int, size_t); 
     56extern int   memcmp(const void *, const void *, size_t); 
     57extern int   printf(char *fmt, ...); 
     58extern void  putchar(UCHAR); 
     59extern void *realloc(void *, size_t); 
     60extern void  warn(char *fmt, ...); 
     61extern void *zalloc(size_t); 
     62 
     63// ----------------------------------------------------------------- 
     64// Open Firmware client interface calls. 
     65 
     66#define CIF_HANDLER_IN 3 
    3967extern int call_firmware(ULONG *); 
    40 extern void warn(char *fmt, ...); 
    41  
    42 #ifdef CIF64 
    43 #define CIF_HANDLER_IN 6 
    44 #else 
    45 #define CIF_HANDLER_IN 3 
    46 #endif 
    47  
    48 extern int call_firmware(ULONG *); 
    49 extern void warn(char *fmt, ...); 
    50 int atoi(const char *s); 
    5168 
    5269void OFClose(ihandle id); 
     
    5471phandle OFChild(phandle device_id); 
    5572phandle OFParent(phandle device_id); 
    56 long OFGetproplen(phandle device_id, char *name); 
    57 long OFGetprop(phandle device_id, char *name, char *buf, ULONG buflen); 
    58 long OFNextprop(phandle device_id, char *name, char *buf); 
    59 long OFSetprop(phandle device_id, char *name, char *buf, ULONG buflen); 
     73long OFGetproplen(phandle device_id, const char *name); 
     74long OFGetprop(phandle device_id, const char *name, UCHAR *buf, ULONG buflen); 
     75long OFNextprop(phandle device_id, const char *name, UCHAR *buf); 
     76long OFSetprop(phandle device_id, const char *name, UCHAR *buf, ULONG buflen); 
    6077phandle OFFinddevice(char *devicename); 
    6178ihandle OFOpen(char *devicename); 
    6279ihandle OFCreate(char *devicename); 
    6380void OFClose(ihandle id); 
    64 long OFRead(ihandle instance_id, char *addr, ULONG len); 
    65 long OFWrite(ihandle instance_id, char *addr, ULONG len); 
     81long OFRead(ihandle instance_id, UCHAR *addr, ULONG len); 
     82long OFWrite(ihandle instance_id, UCHAR *addr, ULONG len); 
    6683long OFSeek(ihandle instance_id, ULONG poshi, ULONG poslo); 
    67 ULONG OFClaim(char *addr, ULONG size, ULONG align); 
    68 VOID OFRelease(char *addr, ULONG size); 
    69 long OFPackageToPath(phandle device_id, char *addr, ULONG buflen); 
     84ULONG OFClaim(UCHAR *addr, ULONG size, ULONG align); 
     85void OFRelease(UCHAR *addr, ULONG size); 
     86long OFPackageToPath(phandle device_id, UCHAR *addr, ULONG buflen); 
    7087phandle OFInstanceToPackage(ihandle ih); 
    7188long OFCallMethod(char *method, ihandle id, ULONG arg); 
    72 long OFInterpret0(char *cmd); 
    73 ULONG OFMilliseconds(VOID); 
     89long OFInterpret0(const char *cmd); 
     90ULONG OFMilliseconds(void); 
    7491void (*OFSetCallback(void (*func)(void)))(void); 
    75 long OFBoot(char *bootspec); 
    76 VOID OFEnter(VOID); 
    77 VOID OFExit(VOID); 
     92void OFBoot(char *bootspec); 
     93void OFEnter(void); 
     94#ifdef __GNUC__ 
     95void OFExit(void) __attribute__((noreturn)); 
     96#else 
     97void OFExit(void); 
     98#endif 
    7899long OFCallMethodV(char *method, ihandle id, int nargs, int nrets, ...); 
    79100long OFInterpretV(char *cmd, int nargs, int nrets, ...); 
     101 
     102#endif  // __1275_h__ 
    80103 
    81104// LICENSE_BEGIN 
     
    102125// 
    103126// LICENSE_END 
     127 
  • clients/lib/arm/makefile

    r2545 r2919  
    1919endif 
    2020 
     21# DEVELOPER = $(shell xcode-select -print-path) 
     22# SDK = $(shell xcodebuild -showsdks | grep iphoneos | head -1 | sed 's/.*-sdk //') 
     23# CC = xcrun -sdk ${SDK} gcc 
     24#  
     25# Rationale for these flags: 
     26# -Oz optimizes for smallest possible size. (Apple-specific) 
     27# -fno-toplevel-reorder keeps inflate() as the first entry point. 
     28# -ffreestanding means don't assume standard libraries, inlines, and builtins 
     29# -thumb gives 30%-50% improvement over ARM32.  
     30# -arch armv7 uses more powerful instructions for less space. 
     31# -static -nostartfiles allows us to link this as a static text image. 
     32# CFLAGS = -I.. -Oz -arch armv7 -mthumb -static -nostartfiles \ 
     33#       -I$(DEVELOPER)/Platforms/iPhoneOS.platform/Developer/SDKs/$(SDK).sdk/usr/include \ 
     34#          -fno-toplevel-reorder -ffreestanding 
     35#  
     36LIBOBJS = cellprop.o \ 
     37          debug.o \ 
     38          intprop.o \ 
     39          lib.o \ 
     40          malloc.o \ 
     41          mem.o \ 
     42          printf.o \ 
     43          regprop.o \ 
     44          strings.o \ 
     45          strprop.o \ 
     46          wrappers.o 
     47 
    2148all: libobp.a hello start.o 
    2249 
    23 libobp.a: lib.o printf.o wrappers.o malloc.o strings.o printf.o debug.o main.o intprop.o regprop.o strprop.o mem.o 
    24         ar rcv libobp.a lib.o malloc.o wrappers.o strings.o printf.o debug.o main.o intprop.o regprop.o strprop.o mem.o 
     50libobp.a: ${LIBOBJS} 
     51        ar rcv libobp.a ${LIBOBJS} 
    2552        ranlib libobp.a 
    2653 
    2754# Build machine-independent library routines 
    2855 
    29 main.o: ../main.c 
    30         ${CC} ${CFLAGS} -c ../main.c 
    31  
    32 lib.o: ../lib.c 
    33         ${CC} ${CFLAGS} -c ../lib.c 
    34  
    35 printf.o: ../printf.c 
    36         ${CC} ${CFLAGS} -c ../printf.c 
    37  
    38 debug.o: ../debug.c 
    39         ${CC} ${CFLAGS} -c ../debug.c 
    40  
    41 strings.o: ../strings.c 
    42         ${CC} ${CFLAGS} -c ../strings.c 
    43  
    44 mem.o: ../mem.c 
    45         ${CC} ${CFLAGS} -c ../mem.c 
    46  
    47 intprop.o: ../intprop.c 
    48         ${CC} ${CFLAGS} -c ../intprop.c 
    49  
    50 regprop.o: ../regprop.c 
    51         ${CC} ${CFLAGS} -c ../regprop.c 
    52  
    53 strprop.o: ../strprop.c 
    54         ${CC} ${CFLAGS} -c ../strprop.c 
    55  
    56 wrappers.o: ../wrappers.c 
    57         ${CC} ${CFLAGS} -c ../wrappers.c 
    58  
    59 malloc.o: ../malloc.c 
    60         ${CC} ${CFLAGS} -c ../malloc.c 
     56%.o: ../%.c 
     57        ${CC} ${CFLAGS} -c $< 
    6158 
    6259# Build processor-specific startup code and call gateway 
     
    6562        ${CC} ${CFLAGS} -c start.c 
    6663 
     64# start.o: start.s 
     65#       ${CC} ${CFLAGS} -c start.s 
     66 
    6767# Hello is a demo program that uses the stdio library 
    6868 
    6969hello: libobp.a start.o hello.o 
    70         ld -Bstatic -oformat elf32-powerpc -T ofclient.lds -Ttext 0x100000 -o hello start.o hello.o -L. -lobp 
     70        ${CC} ${CFLAGS} -e _start -o hello start.o hello.o -L. -lobp 
    7171 
    7272hello.o: ../../hello/hello.c 
     
    7676        rm -f *~ *.o hello* *.a 
    7777 
    78  
    7978dist: 
    8079        (cd ../..; tar cfh /tmp/lib.tar lib/*.c lib/*.h lib/ppcgcc/*.c lib/ppcgcc/*.lds lib/ppcgcc/makefile hello) 
  • clients/lib/arm/start.c

    r2361 r2919  
    1414 
    1515void 
     16#ifdef __GNUC__ 
    1617_start(void *promptr) 
     18#else 
     19start(void *promptr) 
     20#endif 
    1721{ 
    1822    cif_handler = (int (*)()) promptr; 
  • clients/lib/debug.c

    r1 r2919  
    1111int Debug = 0; 
    1212 
    13 VOID 
     13void 
    1414debug(int debug_level, char *fmt, ...) 
    1515{ 
  • clients/lib/intprop.c

    r1 r2919  
    1818{ 
    1919        int res; 
    20         char buf[sizeof(int)]; 
     20        UCHAR buf[sizeof(int)]; 
    2121 
    2222        res = OFGetprop(node, key, buf, sizeof(int)); 
     
    3535{ 
    3636        int res; 
    37         char buf[sizeof(int)]; 
     37        UCHAR buf[sizeof(int)]; 
    3838 
    3939        res = OFGetprop(node, key, buf, sizeof(int)); 
  • clients/lib/lib.c

    r1021 r2919  
    44 
    55#include "1275.h" 
    6  
    7 extern void *malloc(); 
    8 extern char *get_str_prop(); 
    9 extern int  get_int_prop(); 
    10 extern int  get_int_prop_def(); 
    11  
    126#include "stdio.h" 
     7#include "string.h" 
    138 
    149FILE _stdin  = { -1, 0, 0}; 
     
    3126} 
    3227 
    33 VOID 
     28void 
    3429sleep(ULONG delay) 
    3530{ 
    36         delay = (delay * 1000) + OFMilliseconds(); 
    37         while ((OFMilliseconds() - delay) < 0) 
    38                 ; 
     31    ULONG now = OFMilliseconds(); 
     32    delay *= 1000; 
     33    while ((OFMilliseconds() - now) < delay) 
     34        ; 
    3935} 
    4036 
     
    4945} 
    5046 
     47void 
    5148parse_homedir(char *progname) 
    5249{ 
     
    7370  phandle ph; 
    7471  char *argstr; 
    75   int i; 
     72  int i = 0; 
     73  extern int main(int, char**); 
    7674 
    7775  if ((ph = OFFinddevice("/chosen")) == -1) 
    7876    abort() ; 
    79   stdin->id  = get_int_prop(ph, "stdin"); 
    80   stdout->id = get_int_prop(ph, "stdout"); 
     77  stdin->id  = get_cell_prop(ph, "stdin"); 
     78  stdout->id = get_cell_prop(ph, "stdout"); 
    8179 
    8280  argv[0] = get_str_prop(ph, "bootpath", ALLOC); 
     81  if (argv[0] != NULL) 
     82    parse_homedir(argv[0]); 
    8383  argstr  = get_str_prop(ph, "bootargs", ALLOC); 
    84  
    85   for (i = 1; i < 10;) { 
    86     if (*argstr == '\0') 
    87       break; 
    88     argv[i++] = argstr; 
    89     while (*argstr != ' ' && *argstr != '\0') 
    90       ++argstr; 
    91     if (*argstr == '\0') 
    92       break; 
    93     *argstr++ = '\0'; 
    94   } 
    95   parse_homedir(argv[0]); 
    96   main(i, argv); 
     84  if (argstr != NULL) { 
     85    for (i = 1; i < 10;) { 
     86      if (*argstr == '\0') 
     87        break; 
     88      argv[i++] = argstr; 
     89      while (*argstr != ' ' && *argstr != '\0') 
     90        ++argstr; 
     91      if (*argstr == '\0') 
     92        break; 
     93      *argstr++ = '\0'; 
     94    } 
     95  } 
     96  return main(i, argv); 
    9797} 
    9898 
     
    203203 
    204204int 
    205 fclose (FILE *fp) 
     205fclose(FILE *fp) 
    206206{ 
    207207  fflush(fp); 
    208208  OFClose(fp->id); 
    209   free(fp); 
     209  free((UCHAR *)fp); 
    210210  return(0); 
    211211} 
     
    217217} 
    218218 
    219 VOID 
    220 putchar(char c) 
     219void 
     220putchar(UCHAR c) 
    221221{ 
    222222  fputc(c, stdout); 
     223} 
     224 
     225int 
     226fputs(char *s, FILE *f) 
     227{ 
     228  char c; 
     229  while ((c = *s++) != 0) 
     230    fputc(c, f); 
     231  return(0); 
    223232} 
    224233 
     
    231240} 
    232241 
    233 VOID 
     242void 
    234243gets(char *buf) 
    235244{ 
     
    239248} 
    240249 
    241 int 
    242 fputs(char *s, FILE *f) 
    243 { 
    244   register char c; 
    245   while(c = *s++) 
    246     fputc(c, f); 
    247   return(0); 
    248 } 
    249  
    250250char * 
    251251fgets(char *buf, int n, FILE *f) 
     
    261261} 
    262262 
     263int 
    263264unlink(char *filename) 
    264265{ 
     
    267268} 
    268269 
    269 system(char *str) 
    270 { 
    271   OFInterpret0(str); 
     270int 
     271system(const char *str) 
     272{ 
     273  return (int)OFInterpret0(str); 
    272274} 
    273275 
    274276#define MAXENV 256 
    275277char * 
    276 getenv(char *str) 
     278getenv(const char *str) 
    277279{ 
    278280  phandle ph; 
    279   int res; 
    280281 
    281282  if ((ph = OFFinddevice("/options")) == -1) 
  • clients/lib/malloc.c

    r1 r2919  
    2929#define MALLOC 
    3030#include "malloc.h" 
    31 #ifndef NULL 
    32 #define NULL    0 
    33 #endif 
     31 
    3432#ifdef debug 
    3533# define ASSERT(p,q)    if (!(p)) fatal(q) 
     
    4442 
    4543#define PAGE_SIZE (ULONG)0x1000 
    46 #define ULONG unsigned long 
    47  
    48 char * 
    49 malloc(nbytes) 
    50         unsigned nbytes; 
     44 
     45static ULONG _log2(ULONG n); 
     46static void insque(struct qelem *, struct qelem *); 
     47static void remque(struct qelem *); 
     48 
     49void * 
     50malloc(size_t nbytes) 
    5151{ 
    5252        extern ULONG OFClaim(); 
    53         register struct overhead *p, *q; 
    54         register int surplus; 
    55         register struct qelem *bucket; 
     53        struct overhead *p, *q; 
     54        int surplus; 
     55        struct qelem *bucket; 
    5656        nbytes = ALIGN(nbytes, NALIGN) + sizeof(struct overhead); 
    5757        bucket = &buckets[_log2(nbytes-1) + 1]; /* log2 rounded up */ 
     
    6969        if (p == NULL) { 
    7070#ifdef USE_SBRK 
    71                 register int i; 
     71                int i; 
    7272                p = (struct overhead *)CURBRK; 
    7373                if ((int)p == -1) 
     
    8181                if ((int)q == -1) 
    8282                        return(NULL); 
    83                 p->ov_length = (char *)q - (char *)p; 
     83                p->ov_length = (UCHAR *)q - (UCHAR *)p; 
    8484                surplus = p->ov_length - nbytes; 
    8585                /* add to end of adjacency chain */ 
     
    111111        if (surplus > sizeof(struct overhead)) { 
    112112                /* if big enough, split it up */ 
    113                 q = (struct overhead *)( (char *)p + nbytes); 
     113                q = (struct overhead *)( (UCHAR *)p + nbytes); 
    114114                q->ov_length = surplus; 
    115115                p->ov_length = nbytes; 
     
    121121        } 
    122122        p->ov_magic = MAGIC_BUSY; 
    123         return((char*)p + sizeof(struct overhead)); 
     123        return((void *)p + sizeof(struct overhead)); 
    124124} 
    125125 
    126126void 
    127 free(mem) 
    128 register char *mem; 
    129 { 
    130         register struct overhead *p, *q; 
     127free(void *mem) 
     128{ 
     129        struct overhead *p, *q; 
    131130        if (mem == NULL) 
    132131                return; 
     
    143142                /* If lower segment can be merged */ 
    144143                if (   q->ov_magic == MAGIC_FREE 
    145                    && (char *)q + q->ov_length == (char *)p 
     144                   && (UCHAR *)q + q->ov_length == (UCHAR *)p 
    146145                ) { 
    147146                        /* remove lower address area from bucket chain */ 
     
    150149                        remque(TOADJ(p)); 
    151150                        q->ov_length += p->ov_length; 
    152                         p->ov_magic = NULL; 
     151                        p->ov_magic = 0; 
    153152                        p = q; 
    154153                } 
     
    160159a higher adjacent free area,\n addresses were found out of order!\n"); 
    161160                if (    q->ov_magic == MAGIC_FREE 
    162                    &&   (char *)p + p->ov_length == (char *)q 
     161                   &&   (UCHAR *)p + p->ov_length == (UCHAR *)q 
    163162                ) { 
    164163                        /* remove upper from bucket chain */ 
     
    167166                        remque(TOADJ(q)); 
    168167                        p->ov_length += q->ov_length; 
    169                         q->ov_magic = NULL; 
     168                        q->ov_magic = 0; 
    170169                } 
    171170        } 
     
    173172        if (    /* freed area is at end of memory */ 
    174173                endfree && adjhead.q_back == TOADJ(p) 
    175             &&  (char*)p + p->ov_length == (char *)CURBRK 
     174            &&  (UCHAR*)p + p->ov_length == (UCHAR *)CURBRK 
    176175        ) { 
    177176                /* remove from end of adjacency chain */ 
     
    188187} 
    189188 
    190 char * 
    191 realloc(mem,nbytes) 
    192 register char *mem; unsigned nbytes; 
    193 { 
    194         register char *newmem; 
    195         register struct overhead *p, *q; 
    196         register int surplus; 
     189void * 
     190realloc(void *old, size_t nbytes) 
     191{ 
     192        UCHAR *mem = (UCHAR *)old; 
     193        UCHAR *newmem; 
     194        struct overhead *p, *q; 
     195        int surplus; 
    197196        if (mem == NULL) 
    198197                return(malloc(nbytes)); 
    199         if(mem > (char*)FROMADJ(adjhead.q_back) + sizeof(struct overhead)) 
     198        if (mem > (UCHAR *)FROMADJ(adjhead.q_back) + sizeof(struct overhead)) 
    200199                return(NULL); 
    201200         
     
    216215                        if (    /* freed area is at end of memory */ 
    217216                                endfree && adjhead.q_back == TOADJ(p) 
    218                           &&    (char*)p + p->ov_length == (char *)CURBRK 
     217                          &&    (UCHAR*)p + p->ov_length == (UCHAR *)CURBRK 
    219218                        ) { 
    220219                                /* release memory to system */ 
     
    223222#endif 
    224223                        { 
    225                                 q = (struct overhead *)( (char *)p + nbytes); 
     224                                q = (struct overhead *)( (UCHAR *)p + nbytes); 
    226225                                q->ov_length = surplus; 
    227226                                q->ov_magic = MAGIC_FREE; 
     
    239238        newmem = malloc(nbytes); 
    240239        if (newmem != mem && newmem != NULL) { 
    241                 register int n; 
     240                int n; 
    242241                if (p->ov_magic == MAGIC_BUSY || p->ov_magic == MAGIC_FREE) { 
    243242                        n = p->ov_length - sizeof(struct overhead); 
    244243                        nbytes = (nbytes < n) ? nbytes : n ; 
    245244                } 
    246                 memcpy(newmem,mem,nbytes); 
     245                memcpy(newmem, mem, nbytes); 
    247246        } 
    248247        if (p->ov_magic == MAGIC_BUSY) 
     
    251250} 
    252251 
    253 _log2(n) 
    254 register int n; 
    255 { 
    256         register int i = 0; 
     252static ULONG _log2(ULONG n) 
     253{ 
     254        int i = 0; 
    257255        while ((n >>= 1) > 0) 
    258256                i++; 
     
    260258} 
    261259 
    262 void 
    263 insque(item,queu) 
    264 register struct qelem *item, *queu; 
    265 { 
    266         register struct qelem *pueu; 
     260static void 
     261insque(struct qelem *item, struct qelem *queu) 
     262{ 
     263        struct qelem *pueu; 
    267264        pueu = queu->q_forw; 
    268265        item->q_forw = pueu; 
     
    272269} 
    273270 
    274 void 
    275 remque(item) 
    276 register struct qelem *item; 
    277 { 
    278         register struct qelem *queu, *pueu; 
     271static void 
     272remque(struct qelem *item) 
     273{ 
     274        struct qelem *queu, *pueu; 
    279275        pueu = item->q_forw; 
    280276        queu = item->q_back; 
  • clients/lib/malloc.h

    r899 r2919  
    44 * A  "smarter" malloc                          William L. Sebok 
    55 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 
     6 
     7#include "1275.h" 
    68 
    79#define MAGIC_FREE      0x548a934c 
     
    2729struct qelem adjhead = { &adjhead, &adjhead }; 
    2830struct qelem buckets[NBUCKETS] = { 
    29         &buckets[0],  &buckets[0], 
    30         &buckets[1],  &buckets[1], 
    31         &buckets[2],  &buckets[2], 
    32         &buckets[3],  &buckets[3], 
    33         &buckets[4],  &buckets[4], 
    34         &buckets[5],  &buckets[5], 
    35         &buckets[6],  &buckets[6], 
    36         &buckets[7],  &buckets[7], 
    37         &buckets[8],  &buckets[8], 
    38         &buckets[9],  &buckets[9], 
    39         &buckets[10], &buckets[10], 
    40         &buckets[11], &buckets[11], 
    41         &buckets[12], &buckets[12], 
    42         &buckets[13], &buckets[13], 
    43         &buckets[14], &buckets[14], 
    44         &buckets[15], &buckets[15], 
    45         &buckets[16], &buckets[16], 
    46         &buckets[17], &buckets[17], 
    47         &buckets[18], &buckets[18], 
    48         &buckets[19], &buckets[19], 
    49         &buckets[20], &buckets[20], 
    50         &buckets[21], &buckets[21], 
    51         &buckets[22], &buckets[22], 
    52         &buckets[23], &buckets[23], 
     31        { &buckets[0],  &buckets[0]  }, 
     32        { &buckets[1],  &buckets[1]  }, 
     33        { &buckets[2],  &buckets[2]  }, 
     34        { &buckets[3],  &buckets[3]  }, 
     35        { &buckets[4],  &buckets[4]  }, 
     36        { &buckets[5],  &buckets[5]  }, 
     37        { &buckets[6],  &buckets[6]  }, 
     38        { &buckets[7],  &buckets[7]  }, 
     39        { &buckets[8],  &buckets[8]  }, 
     40        { &buckets[9],  &buckets[9]  }, 
     41        { &buckets[10], &buckets[10] }, 
     42        { &buckets[11], &buckets[11] }, 
     43        { &buckets[12], &buckets[12] }, 
     44        { &buckets[13], &buckets[13] }, 
     45        { &buckets[14], &buckets[14] }, 
     46        { &buckets[15], &buckets[15] }, 
     47        { &buckets[16], &buckets[16] }, 
     48        { &buckets[17], &buckets[17] }, 
     49        { &buckets[18], &buckets[18] }, 
     50        { &buckets[19], &buckets[19] }, 
     51        { &buckets[20], &buckets[20] }, 
     52        { &buckets[21], &buckets[21] }, 
     53        { &buckets[22], &buckets[22] }, 
     54        { &buckets[23], &buckets[23] }, 
    5355}; 
    5456#else 
     
    6870#define CURBRK  sbrk(0) 
    6971#endif 
    70  
    71 extern void insque(), remque(); 
    72 extern char *malloc(), *realloc(); 
    7372 
    7473// LICENSE_BEGIN 
  • clients/lib/mem.c

    r2354 r2919  
    33#include "1275.h" 
    44 
    5 VOID 
    6 memcpy(char *to, char *from, int len) 
     5void 
     6memcpy(void *to, void *from, size_t len) 
    77{ 
    8         while (len--) 
    9                 *to++ = *from++; 
     8    while (len-- > 0) 
     9        *(UCHAR *)to++ = *(UCHAR *)from++; 
    1010} 
    1111 
    12 VOID 
    13 memset(char *cp, int c, int len) 
     12void 
     13memset(void *cp, int c, size_t len) 
    1414{ 
    15         while (len--) 
    16                 *(cp + len) = c; 
     15    while (len-- > 0) 
     16        *((UCHAR *)cp + len) = c; 
    1717} 
    1818 
    1919int 
    20 memcmp(const void *s1, const void *s2, int n) 
     20memcmp(const void *s1, const void *s2, size_t n) 
    2121{ 
    2222        int diff; 
    23         while (n--) { 
    24                 diff = *(unsigned char *)s1++ - *(unsigned char *)s2++; 
     23        while (n-- > 0) { 
     24                diff = *(UCHAR *)s1++ - *(UCHAR *)s2++; 
    2525                if (diff) 
    2626                        return (diff < 0) ? -1 : 1; 
  • clients/lib/printf.c

    r2274 r2919  
    1717        const char *send = s+len; 
    1818 
    19         if (s != send && *s == '+' || *s == '-') { 
     19        if (s != send && (*s == '+' || *s == '-')) { 
    2020                minus = *s == '-'; 
    2121                s++; 
     
    7070} 
    7171 
    72 STATIC int 
     72static int 
    7373printbase(ULONG x, int base, int fieldlen, char padchar, int upcase) 
    7474{ 
     
    8181        memset(buf, 32, 0); 
    8282 
    83         if (base == 10 && (LONG) x < 0) { 
     83        if (base == 10 && (long) x < 0) { 
    8484                *s++ = '-'; 
    8585                x = -x; 
     
    9393        } while (x); 
    9494 
    95 cvtdone: 
    9695        for (fieldlen -= (s-buf); fieldlen > 0; --fieldlen) { 
    9796                putchar(padchar); 
     
    117116        char padchar; 
    118117 
    119         while (c = *fmt++) { 
     118        while ((c = *fmt++)) { 
    120119                if (c != '%') { 
    121120                        putchar(c); 
     
    150149                } 
    151150                while (c == 'h') {      // Mask for short modifier 
    152                         if (mask = 0xffff) 
     151                        if (mask == 0xffff) 
    153152                                mask = 0xff; 
    154153                        else 
     
    210209} 
    211210 
    212 VOID 
     211void 
    213212warn(char *fmt, ...) 
    214213{ 
     
    220219} 
    221220 
    222 VOID 
     221void 
    223222fatal(char *fmt, ...) 
    224223{ 
  • clients/lib/regprop.c

    r1 r2919  
    1010        static reg staticreg; 
    1111        reg *sregp; 
    12         int i; 
    1312 
    1413        if (buflen) 
     
    2524{ 
    2625        int res; 
    27         char *buf; 
     26        UCHAR *buf; 
    2827        reg *regp; 
    2928        int len = OFGetproplen(node, key); 
    3029 
    31         buf = (char *)malloc(len); 
     30        buf = (UCHAR *)malloc(len); 
    3231        res = OFGetprop(node, key, buf, len); 
    3332        if (res != len) { 
  • clients/lib/strings.c

    r2856 r2919  
    44 
    55#include "1275.h" 
    6  
    7 #define ISUPPER(c) ((c) >= 'A' && (c) <= 'Z') 
    8 #define TOLOWER(c) ((c) + 'a' - 'A') 
     6#include "string.h" 
    97 
    108int 
     
    2321 
    2422int 
    25 strncmp(const char *s, const char *t, int len) 
     23strncmp(const char *s, const char *t, size_t len) 
    2624{ 
    2725        int diff = 0; 
     
    5957 
    6058int 
    61 strncasecmp(const char *s, const char *t, int len) 
     59strncasecmp(const char *s, const char *t, size_t len) 
    6260{ 
    6361        char sc, tc; 
     
    9088 
    9189int 
    92 strnlen(const char *s, int maxlen) 
     90strnlen(const char *s, size_t maxlen) 
    9391{ 
    9492        int i; 
     
    104102        int i = 0; 
    105103 
    106         while (to[i] = from[i]) 
     104        while ((to[i] = from[i])) 
    107105                i += 1; 
    108106        return to; 
     
    110108 
    111109char * 
    112 strncpy(char *to, const char *from, int maxlen) 
     110strncpy(char *to, const char *from, size_t maxlen) 
    113111{ 
    114112        int i = 0; 
     
    191189} 
    192190 
    193 const void *memchr(const void *s, int c, int len) 
     191const void *memchr(const void *s, int c, size_t len) 
    194192{ 
    195193        const unsigned char *p = s; 
  • clients/lib/strprop.c

    r1 r2919  
    55#include "1275.h" 
    66 
    7 extern void *malloc(); 
    8 VOID * 
    9 zalloc(int size) 
     7void * 
     8zalloc(size_t size) 
    109{ 
    11         VOID *vp; 
     10        void *vp; 
    1211 
    13         vp = (void *)malloc(size); 
     12        vp = malloc(size); 
    1413        memset(vp, size, 0); 
    1514        return (vp); 
     
    1716 
    1817char * 
    19 get_str_prop(phandle node, char *key, allocflag alloc) 
     18get_str_prop(phandle node, const char *key, allocflag alloc) 
    2019{ 
    21         int len, res; 
    22         static char *priv_buf, priv_buf_len = 0; 
     20        ULONG len; 
     21        int res; 
     22        static char *priv_buf; 
     23        static ULONG priv_buf_len = 0; 
    2324        char *cp; 
    2425 
    2526        len = OFGetproplen(node, key); 
    26         if (len == -1 || len == 0) 
     27        /* 
     28         * Properly encoded properties have a null terminator, 
     29         * so if len == 1 we have a null string. 
     30         */ 
     31        if (len == -1 || len == 0 || len == 1) { 
    2732                return((char *) 0); 
     33        } 
    2834 
    29         /* 
    30          * Leave room for a null terminator, on the off chance that the 
    31          * property isn't null-terminated. 
    32          */ 
    33         len += 1; 
    3435        if (alloc == ALLOC) 
    3536                cp = (char *) zalloc(len); 
     
    4142                        priv_buf_len = len; 
    4243                } else 
    43                         memset(priv_buf, len, 0); 
     44                        memset((void *)priv_buf, len, 0); 
    4445                cp = priv_buf; 
    4546        } 
    46         len -= 1; 
    4747 
    48         res = OFGetprop(node, key, cp, len); 
     48        res = OFGetprop(node, key, (UCHAR *)cp, len); 
    4949        if (res != len) { 
    5050                fatal( 
  • clients/lib/wrappers.c

    r947 r2919  
    5454OFPeer(phandle device_id) 
    5555{ 
    56 #ifdef CIF64 
    57         ULONG argarray[] = { 0,(ULONG)"peer", 0,1, 0,1, 0,0, 0,0}; 
    58 #else 
    5956        cell_t argarray[] = { (cell_t)"peer",1,1,0,0}; 
    60 #endif 
    6157        argarray[CIF_HANDLER_IN+LOW(0)] = device_id; 
    6258        if (call_firmware(argarray) != 0) 
     
    7066OFChild(phandle device_id) 
    7167{ 
    72 #ifdef CIF64 
    73         ULONG argarray[] = { 0,(ULONG)"child", 0,1, 0,1, 0,0, 0,0}; 
    74 #else 
    7568        cell_t argarray[] = { (cell_t)"child",1,1,0,0}; 
    76 #endif 
    7769        argarray[CIF_HANDLER_IN+LOW(0)] = device_id; 
    7870        if (call_firmware(argarray) != 0) 
     
    8678OFParent(phandle device_id) 
    8779{ 
    88 #ifdef CIF64 
    89         ULONG argarray[] = { 0,(ULONG)"parent", 0,1, 0,1, 0,0, 0,0}; 
    90 #else 
    9180        cell_t argarray[] = { (cell_t)"parent", 1,1,0,0}; 
    92 #endif 
    9381        argarray[CIF_HANDLER_IN+LOW(0)] = device_id; 
    9482        if (call_firmware(argarray) != 0) 
     
    10290OFGetproplen( 
    10391    phandle device_id, 
    104     char *name 
    105     ) 
    106 { 
    107 #ifdef CIF64 
    108         ULONG argarray[] = { 0,(ULONG)"getproplen", 0,2, 0,1, 0,0, 0,0, 0,0}; 
    109 #else 
     92    const char *name 
     93    ) 
     94{ 
    11095        cell_t argarray[] = { (cell_t)"getproplen", 2,1,0,0,0}; 
    111 #endif 
    11296        argarray[CIF_HANDLER_IN+LOW(0)] = (long)device_id; 
    11397        argarray[CIF_HANDLER_IN+LOW(1)] = (long)name; 
     
    122106OFGetprop( 
    123107    phandle device_id, 
    124     char *name, 
    125     char *buf, 
     108    const char *name, 
     109    UCHAR *buf, 
    126110    ULONG buflen 
    127111    ) 
    128112{ 
    129 #ifdef CIF64 
    130         ULONG argarray[] = { 0,(ULONG)"getprop", 0,4, 0,1, 0,0, 0,0, 0,0, 0,0, 0,0}; 
    131 #else 
    132113        cell_t argarray[] = { (cell_t)"getprop", 4,1,0,0,0,0,0}; 
    133 #endif 
    134114        argarray[CIF_HANDLER_IN+LOW(0)] = (long)device_id; 
    135115        argarray[CIF_HANDLER_IN+LOW(1)] = (long)name; 
     
    146126OFNextprop( 
    147127    phandle device_id, 
    148     char *name, 
    149     char *buf 
    150     ) 
    151 { 
    152 #ifdef CIF64 
    153         ULONG argarray[] = { 0,(ULONG)"nextprop", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    154 #else 
     128    const char *name, 
     129    UCHAR *buf 
     130    ) 
     131{ 
    155132        cell_t argarray[] = { (cell_t)"nextprop", 3,1,0,0,0,0}; 
    156 #endif 
    157133        argarray[CIF_HANDLER_IN+LOW(0)] = (long)device_id; 
    158134        argarray[CIF_HANDLER_IN+LOW(1)] = (long)name; 
     
    168144OFSetprop( 
    169145    phandle device_id, 
    170     char *name, 
    171     char *buf, 
     146    const char *name, 
     147    UCHAR *buf, 
    172148    ULONG buflen 
    173149    ) 
    174150{ 
    175 #ifdef CIF64 
    176         ULONG argarray[] = { 0,(ULONG)"setprop", 0,4, 0,1, 0,0, 0,0, 0,0, 0,0, 0,0}; 
    177 #else 
    178151        cell_t argarray[] = { (cell_t)"setprop", 4,1,0,0,0,0,0}; 
    179 #endif 
    180152        argarray[CIF_HANDLER_IN+LOW(0)] = (long)device_id; 
    181153        argarray[CIF_HANDLER_IN+LOW(1)] = (long)name; 
     
    192164OFFinddevice( char *devicename) 
    193165{ 
    194 #ifdef CIF64 
    195         ULONG argarray[] = { 0,(ULONG)"finddevice", 0,1, 0,1, 0,0, 0,0}; 
    196 #else 
    197166        cell_t argarray[] = { (cell_t)"finddevice", 1,1,0,0}; 
    198 #endif 
    199167 
    200168        argarray[CIF_HANDLER_IN+LOW(0)] = (long)devicename; 
     
    209177OFOpen( char *devicename) 
    210178{ 
    211 #ifdef CIF64 
    212         ULONG argarray[] = { 0,(ULONG)"open", 0,1, 0,1, 0,0, 0,0}; 
    213 #else 
    214179        cell_t argarray[] = { (cell_t)"open", 1,1,0,0}; 
    215 #endif 
    216180 
    217181        argarray[CIF_HANDLER_IN+LOW(0)] = (long)devicename; 
     
    227191OFCreate( char *devicename) 
    228192{ 
    229 #ifdef CIF64 
    230         ULONG argarray[] = { 0,(ULONG)"firmworks,create", 0,1, 0,1, 0,0, 0,0}; 
    231 #else 
    232193        cell_t argarray[] = { (cell_t)"firmworks,create", 1,1,0,0}; 
    233 #endif 
    234194 
    235195        argarray[CIF_HANDLER_IN+LOW(0)] = (long)devicename; 
     
    244204OFClose(ihandle id) 
    245205{ 
    246 #ifdef CIF64 
    247         ULONG argarray[] = { 0,(ULONG)"close", 0,1, 0,1, 0,0, 0,0}; 
    248 #else 
    249206        cell_t argarray[] = { (cell_t)"close", 1,1,0,0}; 
    250 #endif 
    251207        argarray[CIF_HANDLER_IN+LOW(0)] = (long)id; 
    252208        if (call_firmware(argarray) != 0) 
     
    262218OFRead( 
    263219    ihandle instance_id, 
    264     char *addr, 
     220    UCHAR *addr, 
    265221    ULONG len 
    266222    ) 
    267223{ 
    268 #ifdef CIF64 
    269         ULONG argarray[] = { 0,(ULONG)"read", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    270 #else 
    271224        cell_t argarray[] = { (cell_t)"read", 3,1,0,0,0,0}; 
    272 #endif 
    273225 
    274226        argarray[CIF_HANDLER_IN+LOW(0)] = (long) instance_id; 
     
    285237OFWrite( 
    286238    ihandle instance_id, 
    287     char *addr, 
     239    UCHAR *addr, 
    288240    ULONG len 
    289241    ) 
    290242{ 
    291 #ifdef CIF64 
    292         ULONG argarray[] = { 0,(ULONG)"write", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    293 #else 
    294243        cell_t argarray[] = { (cell_t)"write", 3,1,0,0,0,0}; 
    295 #endif 
    296244 
    297245        argarray[CIF_HANDLER_IN+LOW(0)] = (long) instance_id; 
     
    312260    ) 
    313261{ 
    314 #ifdef CIF64 
    315         ULONG argarray[] = { 0,(ULONG)"seek", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    316 #else 
    317262        cell_t argarray[] = { (cell_t)"seek", 3,1,0,0,0,0}; 
    318 #endif 
    319263 
    320264        argarray[CIF_HANDLER_IN+LOW(0)] = (long) instance_id; 
     
    329273ULONG 
    330274OFClaim( 
    331     char *addr, 
     275    UCHAR *addr, 
    332276    ULONG size, 
    333277    ULONG align 
    334278    ) 
    335279{ 
    336 #ifdef CIF64 
    337         ULONG argarray[] = { 0,(ULONG)"claim", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    338 #else 
    339280        cell_t argarray[] = { (cell_t)"claim", 3,1,0,0,0,0}; 
    340 #endif 
    341281 
    342282        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)addr; 
     
    350290} 
    351291 
    352 VOID 
     292void 
    353293OFRelease( 
    354     char *addr, 
     294    UCHAR *addr, 
    355295    ULONG size 
    356296    ) 
    357297{ 
    358 #ifdef CIF64 
    359         ULONG argarray[] = { 0,(ULONG)"release", 0,2, 0,0, 0,0, 0,0}; 
    360 #else 
    361298        cell_t argarray[] = { (cell_t)"release", 2,0,0,0}; 
    362 #endif 
    363299        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)addr; 
    364300        argarray[CIF_HANDLER_IN+LOW(1)] = size; 
     
    369305OFPackageToPath( 
    370306    phandle device_id, 
    371     char *addr, 
     307    UCHAR *addr, 
    372308    ULONG buflen 
    373309    ) 
    374310{ 
    375 #ifdef CIF64 
    376         ULONG argarray[] = { 0,(ULONG)"package-to-path", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    377 #else 
    378311        cell_t argarray[] = { (cell_t)"package-to-path", 3,1,0,0,0,0}; 
    379 #endif 
    380312 
    381313        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)device_id; 
     
    386318                return (-1); 
    387319        } 
    388         return ((LONG)argarray[CIF_HANDLER_IN+LOW(3)]); 
     320        return ((ULONG)argarray[CIF_HANDLER_IN+LOW(3)]); 
    389321} 
    390322 
     
    392324OFInstanceToPackage(ihandle ih) 
    393325{ 
    394 #ifdef CIF64 
    395         ULONG argarray[] = { 0,(ULONG)"instance-to-package", 0,1, 0,1, 0,0, 0,0}; 
    396 #else 
    397326        cell_t argarray[] = { (cell_t)"instance-to-package", 1,1,0,0}; 
    398 #endif 
    399327 
    400328        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)ih; 
     
    403331                return (-1); 
    404332        } 
    405         return ((LONG)argarray[CIF_HANDLER_IN+LOW(1)]); 
     333        return ((ULONG)argarray[CIF_HANDLER_IN+LOW(1)]); 
    406334} 
    407335 
     
    413341    ) 
    414342{ 
    415 #ifdef CIF64 
    416         ULONG argarray[] = { 0,(ULONG)"call-method", 0,3, 0,1, 0,0, 0,0, 0,0, 0,0}; 
    417 #else 
    418343        cell_t argarray[] = { (cell_t)"call-method", 3,1,0,0,0,0}; 
    419 #endif 
    420344 
    421345        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)method; 
     
    426350                return (-1); 
    427351        } 
    428         return ((LONG)argarray[CIF_HANDLER_IN+LOW(3)]); 
     352        return ((ULONG)argarray[CIF_HANDLER_IN+LOW(3)]); 
    429353} 
    430354 
     
    441365    ) 
    442366{ 
    443 #ifdef CIF64 
    444         ULONG argarray[(MAXARGS+6)*2] = { 0 }; 
    445 #else 
    446367        cell_t argarray[MAXARGS+6] = { 0 }; 
    447 #endif 
    448368        va_list ap; 
    449369        int retval; 
    450370        int *intp; 
    451371        int argnum = 0; 
    452         unsigned long flags; 
    453372 
    454373        argarray[LOW(argnum++)] = (cell_t)"call-method"; 
     
    481400long 
    482401OFInterpret0( 
    483     char *cmd 
    484     ) 
    485 { 
    486 #ifdef CIF64 
    487         ULONG argarray[] = { 0,(ULONG)"interpret", 0,1, 0,1, 0,0, 0,0}; 
    488 #else 
     402    const char *cmd 
     403    ) 
     404{ 
    489405        cell_t argarray[] = { (cell_t)"interpret", 1,1,0,0}; 
    490 #endif 
    491406 
    492407        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)cmd; 
     
    495410                return (-1); 
    496411        } 
    497         return ((LONG)argarray[CIF_HANDLER_IN+LOW(1)]); 
     412        return ((ULONG)argarray[CIF_HANDLER_IN+LOW(1)]); 
    498413} 
    499414 
     
    506421    ) 
    507422{ 
    508 #ifdef CIF64 
    509         ULONG argarray[(MAXARGS+5)*2] = { 0 }; 
    510 #else 
    511423        cell_t argarray[MAXARGS+5] = { 0 }; 
    512 #endif 
    513424        va_list ap; 
    514425        int retval; 
    515426        int *intp; 
    516427        int argnum = 0; 
    517         unsigned long flags; 
    518428 
    519429        argarray[LOW(argnum++)] = (cell_t)"interpret"; 
     
    545455 
    546456ULONG 
    547 OFMilliseconds( VOID ) 
    548 { 
    549 #ifdef CIF64 
    550         ULONG argarray[] = { 0,(ULONG)"milliseconds", 0,0, 0,1, 0,0}; 
    551 #else 
     457OFMilliseconds( void ) 
     458{ 
    552459        cell_t argarray[] = { (cell_t)"milliseconds", 0,1,0}; 
    553 #endif 
    554460        if (call_firmware(argarray) != 0) 
    555461        { 
     
    561467void (*OFSetCallback(void (*func)(void)))(void) 
    562468{ 
    563 #ifdef CIF64 
    564         ULONG argarray[] = { 0,(ULONG)"set-callback", 0,1, 0,1, 0,0, 0,0}; 
    565 #else 
    566469        cell_t argarray[] = { (cell_t)"set-callback", 1,1,0,0}; 
    567 #endif 
    568470 
    569471        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)func; 
     
    575477} 
    576478 
    577 long 
     479void 
    578480OFBoot( 
    579481    char *bootspec 
    580482    ) 
    581483{ 
    582 #ifdef CIF64 
    583         ULONG argarray[] = { 0,(ULONG)"boot", 0,1, 0,0, 0,0}; 
    584 #else 
    585484        cell_t argarray[] = { (cell_t)"boot", 1,0,0}; 
    586 #endif 
    587485 
    588486        argarray[CIF_HANDLER_IN+LOW(0)] = (cell_t)bootspec; 
     
    590488} 
    591489 
    592 VOID 
    593 OFEnter( VOID ) 
    594 { 
    595 #ifdef CIF64 
    596         ULONG argarray[] = { 0,(ULONG)"enter", 0,0, 0,0}; 
    597 #else 
     490void 
     491OFEnter( void ) 
     492{ 
    598493        cell_t argarray[] = { (cell_t)"enter", 0,0}; 
    599 #endif 
    600494 
    601495        call_firmware(argarray); 
    602496} 
    603497 
    604 /* volatile VOID */ 
    605  VOID 
    606 OFExit( VOID ) 
    607 { 
    608 #ifdef CIF64 
    609         ULONG argarray[] = { 0,(ULONG)"exit", 0,0, 0,0}; 
    610 #else 
     498/* volatile void */ 
     499 void 
     500OFExit( void ) 
     501{ 
    611502        cell_t argarray[] = { (cell_t)"exit", 0,0}; 
    612 #endif 
    613503        call_firmware(argarray); 
     504        while (1); 
    614505} 
    615506 
  • clients/lib/x86/makefile

    r924 r2919  
    1 # This makefile has been tested on a FreeBSD 2.2.5 system with GCC 
     1# This makefile has been tested on OS X 10.6 with GCC 
    22 
    3 # -fno-builtin has the effect of suppressing some warnings about 
    4 # functions that conflict with gcc builtins 
    53CC=gcc 
    6 CFLAGS=-g -m32 -fno-builtin -fno-stack-limit -fno-stack-protector 
     4#CFLAGS=-g -m32 -fno-builtin -fno-stack-limit -fno-stack-protector 
     5CFLAGS=-g -m32 -nostdlib -nostartfiles -fno-builtin -ffreestanding -fno-stack-protector -I.. 
     6LFLAGS=-L. 
    77 
    8 all: libobp.a hello hello.elf start.o 
     8#all: libobp.a hello hello.elf start.o 
     9all: libobp.a hello start.o 
    910 
    1011# Create a library file containing all the library routines 
    1112 
    12 OBJS=lib.o printf.o wrappers.o malloc.o strings.o printf.o debug.o main.o intprop.o regprop.o strprop.o mem.o callofw.o 
     13OBJS=   callofw.o \ 
     14        cellprop.o \ 
     15        debug.o \ 
     16        intprop.o \ 
     17        lib.o \ 
     18        malloc.o \ 
     19        mem.o \ 
     20        printf.o \ 
     21        regprop.o \ 
     22        strings.o \ 
     23        strprop.o \ 
     24        wrappers.o 
    1325 
    1426libobp.a: ${OBJS} 
     
    2335# Build processor-specific startup code and call gateway 
    2436 
    25 start.o: start.s 
    26         ${CC} ${CFLAGS} -c start.s 
     37start.o: start.S 
     38        ${CC} ${CFLAGS} -c start.S 
    2739 
    2840# Hello is a demo program that uses the stdio library 
    2941 
    30 hello.elf: libobp.a start.o hello.o 
    31         ld -melf_i386 -Bstatic -N -Ttext 0x100000 -o $@ start.o hello.o libobp.a -lc 
    32         cp hello.elf hello.syms 
    33         strip hello.elf 
     42#hello.elf: libobp.a start.o hello.o 
     43#       ld -melf_i386 -Bstatic -N -Ttext 0x100000 -o $@ start.o hello.o libobp.a -lc 
     44#       cp hello.elf hello.syms 
     45#       strip hello.elf 
    3446 
    3547hello.o: ../../hello/hello.c 
    3648        ${CC} ${CFLAGS} -c ../../hello/hello.c 
    3749 
    38 hello: hello.o 
    39         ${CC} -m32 $< -o $@ 
     50hello: start.o hello.o libobp.a 
     51        ${CC} ${CFLAGS} ${LFLAGS} start.o hello.o -o $@ -lobp 
    4052 
    4153# Binary to ELF converter program 
  • clients/lib/x86/start.s

    r920 r2919  
     1# 1 "../../../clients/lib/x86/start.S" 
     2# 1 "<built-in>" 
     3# 1 "<command-line>" 
     4# 1 "../../../clients/lib/x86/start.S" 
    15# See license at end of file 
    26 
    3         .file   "start.s" 
     7 .file "start.s" 
    48.data 
    5         .align 2 
    6         .type    _cifentry,@object 
    7         .size    _cifentry,4 
     9 .align 2 
     10 
     11 .type _cifentry,@object 
     12  .size _cifentry,4 
     13 
    814_cifentry: 
    9         .long 0 
     15 .long 0 
    1016 
    1117LEB0: 
    12         .ascii "exit\0" 
     18 .ascii "exit\0" 
    1319 
    14         .type    _exitblock,@object 
    15         .size    _exitblock,12 
     20 
     21 .type _exitblock,@object 
     22 .size _exitblock,12 
     23 
    1624_exitblock: 
    17         .long LEB0 
    18         .long 0 
    19         .long 0 
     25 .long LEB0 
     26 .long 0 
     27 .long 0 
    2028 
    2129.text 
    22         .align 2 
    23 .globl _start 
    24         .type    _start,@function 
     30 .align 2 
     31 
     32 .globl _start 
    2533_start: 
    26 #       pushl %ebp 
    27 #       movl %esp,%ebp 
    28         movl %eax,_cifentry 
    29         call ofw_setup 
    30         lea  _exitblock, %eax 
    31         movl _cifentry,%ebx 
    32         call *%ebx 
    33 #       jmp L1 
    34 #       .align 2,0x90 
     34 
     35 
     36 
     37 
     38# pushl %ebp 
     39# movl %esp,%ebp 
     40 movl %eax,_cifentry 
     41 
     42 
     43 call ofw_setup 
     44 
     45 
     46 
     47 lea _exitblock, %eax 
     48 movl _cifentry,%ebx 
     49 call *%ebx 
     50# jmp L1 
     51# .align 2,0x90 
    3552#L1: 
    36 #       leave 
    37         ret 
     53# leave 
     54 ret 
    3855 
    39 .globl call_firmware 
    40         .type    call_firmware,@function 
     56 
     57 .globl call_firmware 
    4158call_firmware: 
    42         movl 4(%esp),%eax 
    43         push %ebx 
    44         movl _cifentry,%ebx 
    45         call *%ebx 
    46         pop %ebx 
    47         ret 
     59 
     60 
     61 
     62 
     63 movl 4(%esp),%eax 
     64 push %ebx 
     65 movl _cifentry,%ebx 
     66 call *%ebx 
     67 pop %ebx 
     68 ret 
    4869 
    4970# LICENSE_BEGIN 
    5071# Copyright (c) 2006 FirmWorks 
    51 #  
     72 
    5273# Permission is hereby granted, free of charge, to any person obtaining 
    5374# a copy of this software and associated documentation files (the 
     
    5778# permit persons to whom the Software is furnished to do so, subject to 
    5879# the following conditions: 
    59 #  
     80 
    6081# The above copyright notice and this permission notice shall be 
    6182# included in all copies or substantial portions of the Software. 
    62 #  
     83 
    6384# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
    6485# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
     
    6889# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 
    6990# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
    70 # 
     91 
    7192# LICENSE_END 
Note: See TracChangeset for help on using the changeset viewer.