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.