Various cleanups to fix compiler warnings.
[rmac] / object.c
1 //
2 // RMAC - Reboot's Macro Assembler for the Atari Jaguar Console System
3 // OBJECT.C - Writing Object Files
4 // Copyright (C) 199x Landon Dyer, 2011 Reboot and Friends
5 // RMAC derived from MADMAC v1.07 Written by Landon Dyer, 1986
6 // Source Utilised with the Kind Permission of Landon Dyer
7 //
8
9 #include "object.h"
10 #include "sect.h"
11 #include "symbol.h"
12 #include "mark.h"
13 #include "error.h"
14 #include "risca.h"
15
16 LONG symsize = 0;                                           // Size of BSD symbol table
17 LONG strindx = 0x00000004;                                  // BSD string table index
18 char *strtable;                                             // Pointer to the symbol string table
19 char *objimage;                                             // Global object image pointer
20
21 //
22 // --- Add an entry to the BSD symbol table --------------------------------------------------------
23 //
24
25 char *constr_bsdsymtab(char *buf, SYM *sym, int globflag) {
26    LONG z;                                                  // Scratch long
27    WORD w1;                                                 // Scratch word
28    int w2;                                                  // Scratch long
29    
30    chptr = buf;                                             // Point to buffer for deposit longs
31    D_long(strindx);                                         // Deposit the symbol string index
32
33    w1 = sym->sattr;                                         // Obtain symbol attribute
34    w2 = sym->sattre;
35    z = 0;                                                   // Initialise resulting symbol flags
36    if(w1 & EQUATED) {                                       
37       z = 0x02000000;                                       // Set equated flag
38    } else {
39       switch(w1 & TDB) {
40          case TEXT: z = 0x04000000; break;                  // Set TEXT segment flag
41          case DATA: z = 0x06000000; break;                  // Set DATA segment flag
42          case BSS : z = 0x08000000; break;                  // Set BSS segment flag
43       }
44    }
45    if(globflag) z |= 0x01000000;                            // Set global flag if requested
46    D_long(z);                                               // Deposit symbol attribute
47
48    z = sym->svalue;                                         // Obtain symbol value
49    w1 &= DATA|BSS;                                          // Determine DATA or BSS flag
50    if(w1)                                                   
51       z += sect[TEXT].sloc;                                 // If DATA or BSS add TEXT segment size
52    if(w1 & BSS) 
53       z += sect[DATA].sloc;                                 // If BSS add DATA segment size
54    D_long(z);                                               // Deposit symbol value
55
56    strcpy(strtable + strindx, sym->sname);
57
58    strindx += strlen(sym->sname) + 1;                       // Incr string index incl null terminate
59    buf += 12;                                               // Increment buffer to next record
60    symsize += 12;                                           // Increment symbol table size
61
62    return(buf);
63 }
64
65 //
66 // --- Generate object file ------------------------------------------------------------------------
67 //
68
69 int object(WORD fd) {
70    LONG t;                                                  // Scratch long
71    LONG tds;                                                // TEXT & DATA segment size
72    int i;                                                   // Temporary int
73    CHUNK *cp;                                               // Chunk (for gather)
74    char *buf;                                               // Scratch area
75    char *p;                                                 // Temporary ptr
76    LONG ssize;                                              // Size of symbols
77    LONG trsize, drsize;                                     // Size of relocations
78
79    // Write requested object file...
80    switch(obj_format) {
81       case BSD:
82          ssize = ((LONG)sy_assign(NULL, NULL));             // Assign index numbers to the symbols
83          tds = sect[TEXT].sloc + sect[DATA].sloc;           // Get size of TEXT and DATA segment
84          buf = malloc(0x400000);                            // Allocate 4mb object file image memory
85          if(buf == NULL) {
86             error("cannot allocate object file memory (in BSD mode)");
87             return(ERROR);
88          }
89          memset(buf, 0, 0x400000);                          // Reset allocated memory
90          objimage = buf;                                    // Set global object image pointer
91          strtable = malloc(0x200000);                       // Allocate 2mb scratch buffer 
92          if(strtable == NULL) {
93             error("cannot allocate string table memory (in BSD mode)");
94             return(ERROR);
95          }
96          memset(strtable, 0, 0x200000);                     // Reset allocated memory
97
98          // Build object file header
99          chptr = buf;                                       // Base of header
100          t = 0x00000107;
101          D_long(t);                                         // Magic number
102          t = sect[TEXT].sloc;                               // TEXT size 
103          D_long(t);
104          t = sect[DATA].sloc;                               // DATA size 
105          D_long(t);
106          t = sect[BSS].sloc;                                // BSS size 
107          D_long(t);
108          t = 0x00000000;
109          D_long(t);                                         // Symbol size
110          D_long(t);                                         // First entry (0L)
111          D_long(t);                                         // TEXT relocation size
112          D_long(t);                                         // BSD relocation size
113
114          // Construct TEXT and DATA segments (without relocation changes)
115          p = buf + BSDHDRSIZE;
116          for(i = TEXT; i <= DATA; ++i)
117             for(cp = sect[i].sfcode; cp != NULL; cp = cp->chnext) {
118                copy(p, cp->chptr, cp->ch_size);
119                p += cp->ch_size;
120             }
121
122          // Do relocation tables (and make changes to segment data)
123          p = buf + (BSDHDRSIZE + tds);                      // Move obj image ptr to reloc info
124          trsize = bsdmarkimg(p, tds, sect[TEXT].sloc, TEXT);// Do TEXT relocation table
125          chptr = buf + 24;                                  // Point to relocation hdr entry
126          D_long(trsize);                                    // Write the relocation table size
127          p = buf + (BSDHDRSIZE + tds + trsize);             // Move obj image ptr to reloc info
128          drsize = bsdmarkimg(p, tds, sect[TEXT].sloc, DATA);// Do DATA relocation table
129          chptr = buf + 28;                                  // Point to relocation hdr entry
130          D_long(drsize);                                    // Write the relocation table size
131
132          p = buf + (BSDHDRSIZE + tds + trsize + drsize);    // Point to start of symbol table
133          sy_assign(p, constr_bsdsymtab);                    // Build symbol and string tables
134          chptr = buf + 16;                                  // Point to sym table size hdr entry
135          D_long(symsize);                                   // Write the symbol table size
136
137          // Point to string table
138          p = buf + (BSDHDRSIZE + tds + trsize + drsize + symsize);    
139
140          memcpy(p, strtable, strindx);                      // Copy string table to object image
141          if(buf) free(strtable);                            // Free allocated memory
142          chptr = p;                                         // Point to string table size long
143          D_long(strindx);                                   // Write string table size
144
145          // Write the BSD object file from the object image buffer
146          write(fd, buf, BSDHDRSIZE + tds + trsize + drsize + symsize + strindx + 4);
147
148          if(buf) free(buf);                                 // Free allocated memory
149          break;
150    }
151
152    return(0);
153 }
154
155
156
157
158
159