diff options
author | David Walter Seikel | 2014-01-13 21:08:31 +1000 |
---|---|---|
committer | David Walter Seikel | 2014-01-13 21:08:31 +1000 |
commit | 637177eb1397ef1800027bccd50dbdc1af29a15b (patch) | |
tree | 3670a48303d05fceb8bf3ec4ee2901b72fe62d4d /libraries/luajit-2.0/src/buildvm_peobj.c | |
parent | Update Irrlicht to 1.8.1. Include actual change markers this time. lol (diff) | |
download | SledjHamr-637177eb1397ef1800027bccd50dbdc1af29a15b.zip SledjHamr-637177eb1397ef1800027bccd50dbdc1af29a15b.tar.gz SledjHamr-637177eb1397ef1800027bccd50dbdc1af29a15b.tar.bz2 SledjHamr-637177eb1397ef1800027bccd50dbdc1af29a15b.tar.xz |
Remove LuaJIT source, we can use packaged LuaJIT 2.0 release now.
Also some cleanups related to the other library removals.
Diffstat (limited to 'libraries/luajit-2.0/src/buildvm_peobj.c')
-rw-r--r-- | libraries/luajit-2.0/src/buildvm_peobj.c | 352 |
1 files changed, 0 insertions, 352 deletions
diff --git a/libraries/luajit-2.0/src/buildvm_peobj.c b/libraries/luajit-2.0/src/buildvm_peobj.c deleted file mode 100644 index eb1d345..0000000 --- a/libraries/luajit-2.0/src/buildvm_peobj.c +++ /dev/null | |||
@@ -1,352 +0,0 @@ | |||
1 | /* | ||
2 | ** LuaJIT VM builder: PE object emitter. | ||
3 | ** Copyright (C) 2005-2011 Mike Pall. See Copyright Notice in luajit.h | ||
4 | ** | ||
5 | ** Only used for building on Windows, since we cannot assume the presence | ||
6 | ** of a suitable assembler. The host and target byte order must match. | ||
7 | */ | ||
8 | |||
9 | #include "buildvm.h" | ||
10 | #include "lj_bc.h" | ||
11 | |||
12 | #if LJ_TARGET_X86ORX64 | ||
13 | |||
14 | /* Context for PE object emitter. */ | ||
15 | static char *strtab; | ||
16 | static size_t strtabofs; | ||
17 | |||
18 | /* -- PE object definitions ----------------------------------------------- */ | ||
19 | |||
20 | /* PE header. */ | ||
21 | typedef struct PEheader { | ||
22 | uint16_t arch; | ||
23 | uint16_t nsects; | ||
24 | uint32_t time; | ||
25 | uint32_t symtabofs; | ||
26 | uint32_t nsyms; | ||
27 | uint16_t opthdrsz; | ||
28 | uint16_t flags; | ||
29 | } PEheader; | ||
30 | |||
31 | /* PE section. */ | ||
32 | typedef struct PEsection { | ||
33 | char name[8]; | ||
34 | uint32_t vsize; | ||
35 | uint32_t vaddr; | ||
36 | uint32_t size; | ||
37 | uint32_t ofs; | ||
38 | uint32_t relocofs; | ||
39 | uint32_t lineofs; | ||
40 | uint16_t nreloc; | ||
41 | uint16_t nline; | ||
42 | uint32_t flags; | ||
43 | } PEsection; | ||
44 | |||
45 | /* PE relocation. */ | ||
46 | typedef struct PEreloc { | ||
47 | uint32_t vaddr; | ||
48 | uint32_t symidx; | ||
49 | uint16_t type; | ||
50 | } PEreloc; | ||
51 | |||
52 | /* Cannot use sizeof, because it pads up to the max. alignment. */ | ||
53 | #define PEOBJ_RELOC_SIZE (4+4+2) | ||
54 | |||
55 | /* PE symbol table entry. */ | ||
56 | typedef struct PEsym { | ||
57 | union { | ||
58 | char name[8]; | ||
59 | uint32_t nameref[2]; | ||
60 | } n; | ||
61 | uint32_t value; | ||
62 | int16_t sect; | ||
63 | uint16_t type; | ||
64 | uint8_t scl; | ||
65 | uint8_t naux; | ||
66 | } PEsym; | ||
67 | |||
68 | /* PE symbol table auxiliary entry for a section. */ | ||
69 | typedef struct PEsymaux { | ||
70 | uint32_t size; | ||
71 | uint16_t nreloc; | ||
72 | uint16_t nline; | ||
73 | uint32_t cksum; | ||
74 | uint16_t assoc; | ||
75 | uint8_t comdatsel; | ||
76 | uint8_t unused[3]; | ||
77 | } PEsymaux; | ||
78 | |||
79 | /* Cannot use sizeof, because it pads up to the max. alignment. */ | ||
80 | #define PEOBJ_SYM_SIZE (8+4+2+2+1+1) | ||
81 | |||
82 | /* PE object CPU specific defines. */ | ||
83 | #if LJ_TARGET_X86 | ||
84 | #define PEOBJ_ARCH_TARGET 0x014c | ||
85 | #define PEOBJ_RELOC_REL32 0x14 /* MS: REL32, GNU: DISP32. */ | ||
86 | #define PEOBJ_RELOC_DIR32 0x06 | ||
87 | #elif LJ_TARGET_X64 | ||
88 | #define PEOBJ_ARCH_TARGET 0x8664 | ||
89 | #define PEOBJ_RELOC_REL32 0x04 /* MS: REL32, GNU: DISP32. */ | ||
90 | #define PEOBJ_RELOC_DIR32 0x02 | ||
91 | #define PEOBJ_RELOC_ADDR32NB 0x03 | ||
92 | #endif | ||
93 | |||
94 | /* Section numbers (0-based). */ | ||
95 | enum { | ||
96 | PEOBJ_SECT_ABS = -2, | ||
97 | PEOBJ_SECT_UNDEF = -1, | ||
98 | PEOBJ_SECT_TEXT, | ||
99 | #if LJ_TARGET_X64 | ||
100 | PEOBJ_SECT_PDATA, | ||
101 | PEOBJ_SECT_XDATA, | ||
102 | #endif | ||
103 | PEOBJ_SECT_RDATA_Z, | ||
104 | PEOBJ_NSECTIONS | ||
105 | }; | ||
106 | |||
107 | /* Symbol types. */ | ||
108 | #define PEOBJ_TYPE_NULL 0 | ||
109 | #define PEOBJ_TYPE_FUNC 0x20 | ||
110 | |||
111 | /* Symbol storage class. */ | ||
112 | #define PEOBJ_SCL_EXTERN 2 | ||
113 | #define PEOBJ_SCL_STATIC 3 | ||
114 | |||
115 | /* -- PE object emitter --------------------------------------------------- */ | ||
116 | |||
117 | /* Emit PE object symbol. */ | ||
118 | static void emit_peobj_sym(BuildCtx *ctx, const char *name, uint32_t value, | ||
119 | int sect, int type, int scl) | ||
120 | { | ||
121 | PEsym sym; | ||
122 | size_t len = strlen(name); | ||
123 | if (!strtab) { /* Pass 1: only calculate string table length. */ | ||
124 | if (len > 8) strtabofs += len+1; | ||
125 | return; | ||
126 | } | ||
127 | if (len <= 8) { | ||
128 | memcpy(sym.n.name, name, len); | ||
129 | memset(sym.n.name+len, 0, 8-len); | ||
130 | } else { | ||
131 | sym.n.nameref[0] = 0; | ||
132 | sym.n.nameref[1] = (uint32_t)strtabofs; | ||
133 | memcpy(strtab + strtabofs, name, len); | ||
134 | strtab[strtabofs+len] = 0; | ||
135 | strtabofs += len+1; | ||
136 | } | ||
137 | sym.value = value; | ||
138 | sym.sect = (int16_t)(sect+1); /* 1-based section number. */ | ||
139 | sym.type = (uint16_t)type; | ||
140 | sym.scl = (uint8_t)scl; | ||
141 | sym.naux = 0; | ||
142 | owrite(ctx, &sym, PEOBJ_SYM_SIZE); | ||
143 | } | ||
144 | |||
145 | /* Emit PE object section symbol. */ | ||
146 | static void emit_peobj_sym_sect(BuildCtx *ctx, PEsection *pesect, int sect) | ||
147 | { | ||
148 | PEsym sym; | ||
149 | PEsymaux aux; | ||
150 | if (!strtab) return; /* Pass 1: no output. */ | ||
151 | memcpy(sym.n.name, pesect[sect].name, 8); | ||
152 | sym.value = 0; | ||
153 | sym.sect = (int16_t)(sect+1); /* 1-based section number. */ | ||
154 | sym.type = PEOBJ_TYPE_NULL; | ||
155 | sym.scl = PEOBJ_SCL_STATIC; | ||
156 | sym.naux = 1; | ||
157 | owrite(ctx, &sym, PEOBJ_SYM_SIZE); | ||
158 | memset(&aux, 0, sizeof(PEsymaux)); | ||
159 | aux.size = pesect[sect].size; | ||
160 | aux.nreloc = pesect[sect].nreloc; | ||
161 | owrite(ctx, &aux, PEOBJ_SYM_SIZE); | ||
162 | } | ||
163 | |||
164 | /* Emit Windows PE object file. */ | ||
165 | void emit_peobj(BuildCtx *ctx) | ||
166 | { | ||
167 | PEheader pehdr; | ||
168 | PEsection pesect[PEOBJ_NSECTIONS]; | ||
169 | uint32_t sofs; | ||
170 | int i, nrsym; | ||
171 | union { uint8_t b; uint32_t u; } host_endian; | ||
172 | |||
173 | host_endian.u = 1; | ||
174 | if (host_endian.b != LJ_ENDIAN_SELECT(1, 0)) { | ||
175 | fprintf(stderr, "Error: different byte order for host and target\n"); | ||
176 | exit(1); | ||
177 | } | ||
178 | |||
179 | sofs = sizeof(PEheader) + PEOBJ_NSECTIONS*sizeof(PEsection); | ||
180 | |||
181 | /* Fill in PE sections. */ | ||
182 | memset(&pesect, 0, PEOBJ_NSECTIONS*sizeof(PEsection)); | ||
183 | memcpy(pesect[PEOBJ_SECT_TEXT].name, ".text", sizeof(".text")-1); | ||
184 | pesect[PEOBJ_SECT_TEXT].ofs = sofs; | ||
185 | sofs += (pesect[PEOBJ_SECT_TEXT].size = (uint32_t)ctx->codesz); | ||
186 | pesect[PEOBJ_SECT_TEXT].relocofs = sofs; | ||
187 | sofs += (pesect[PEOBJ_SECT_TEXT].nreloc = (uint16_t)ctx->nreloc) * PEOBJ_RELOC_SIZE; | ||
188 | /* Flags: 60 = read+execute, 50 = align16, 20 = code. */ | ||
189 | pesect[PEOBJ_SECT_TEXT].flags = 0x60500020; | ||
190 | |||
191 | #if LJ_TARGET_X64 | ||
192 | memcpy(pesect[PEOBJ_SECT_PDATA].name, ".pdata", sizeof(".pdata")-1); | ||
193 | pesect[PEOBJ_SECT_PDATA].ofs = sofs; | ||
194 | sofs += (pesect[PEOBJ_SECT_PDATA].size = 6*4); | ||
195 | pesect[PEOBJ_SECT_PDATA].relocofs = sofs; | ||
196 | sofs += (pesect[PEOBJ_SECT_PDATA].nreloc = 6) * PEOBJ_RELOC_SIZE; | ||
197 | /* Flags: 40 = read, 30 = align4, 40 = initialized data. */ | ||
198 | pesect[PEOBJ_SECT_PDATA].flags = 0x40300040; | ||
199 | |||
200 | memcpy(pesect[PEOBJ_SECT_XDATA].name, ".xdata", sizeof(".xdata")-1); | ||
201 | pesect[PEOBJ_SECT_XDATA].ofs = sofs; | ||
202 | sofs += (pesect[PEOBJ_SECT_XDATA].size = 8*2+4+6*2); /* See below. */ | ||
203 | pesect[PEOBJ_SECT_XDATA].relocofs = sofs; | ||
204 | sofs += (pesect[PEOBJ_SECT_XDATA].nreloc = 1) * PEOBJ_RELOC_SIZE; | ||
205 | /* Flags: 40 = read, 30 = align4, 40 = initialized data. */ | ||
206 | pesect[PEOBJ_SECT_XDATA].flags = 0x40300040; | ||
207 | #endif | ||
208 | |||
209 | memcpy(pesect[PEOBJ_SECT_RDATA_Z].name, ".rdata$Z", sizeof(".rdata$Z")-1); | ||
210 | pesect[PEOBJ_SECT_RDATA_Z].ofs = sofs; | ||
211 | sofs += (pesect[PEOBJ_SECT_RDATA_Z].size = (uint32_t)strlen(ctx->dasm_ident)+1); | ||
212 | /* Flags: 40 = read, 30 = align4, 40 = initialized data. */ | ||
213 | pesect[PEOBJ_SECT_RDATA_Z].flags = 0x40300040; | ||
214 | |||
215 | /* Fill in PE header. */ | ||
216 | pehdr.arch = PEOBJ_ARCH_TARGET; | ||
217 | pehdr.nsects = PEOBJ_NSECTIONS; | ||
218 | pehdr.time = 0; /* Timestamp is optional. */ | ||
219 | pehdr.symtabofs = sofs; | ||
220 | pehdr.opthdrsz = 0; | ||
221 | pehdr.flags = 0; | ||
222 | |||
223 | /* Compute the size of the symbol table: | ||
224 | ** @feat.00 + nsections*2 | ||
225 | ** + asm_start + nsym | ||
226 | ** + nrsym | ||
227 | */ | ||
228 | nrsym = ctx->nrelocsym; | ||
229 | pehdr.nsyms = 1+PEOBJ_NSECTIONS*2 + 1+ctx->nsym + nrsym; | ||
230 | #if LJ_TARGET_X64 | ||
231 | pehdr.nsyms += 1; /* Symbol for lj_err_unwind_win64. */ | ||
232 | #endif | ||
233 | |||
234 | /* Write PE object header and all sections. */ | ||
235 | owrite(ctx, &pehdr, sizeof(PEheader)); | ||
236 | owrite(ctx, &pesect, sizeof(PEsection)*PEOBJ_NSECTIONS); | ||
237 | |||
238 | /* Write .text section. */ | ||
239 | owrite(ctx, ctx->code, ctx->codesz); | ||
240 | for (i = 0; i < ctx->nreloc; i++) { | ||
241 | PEreloc reloc; | ||
242 | reloc.vaddr = (uint32_t)ctx->reloc[i].ofs; | ||
243 | reloc.symidx = 1+2+ctx->reloc[i].sym; /* Reloc syms are after .text sym. */ | ||
244 | reloc.type = ctx->reloc[i].type ? PEOBJ_RELOC_REL32 : PEOBJ_RELOC_DIR32; | ||
245 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
246 | } | ||
247 | |||
248 | #if LJ_TARGET_X64 | ||
249 | { /* Write .pdata section. */ | ||
250 | uint32_t fcofs = (uint32_t)ctx->sym[ctx->nsym-1].ofs; | ||
251 | uint32_t pdata[3]; /* Start of .text, end of .text and .xdata. */ | ||
252 | PEreloc reloc; | ||
253 | pdata[0] = 0; pdata[1] = fcofs; pdata[2] = 0; | ||
254 | owrite(ctx, &pdata, sizeof(pdata)); | ||
255 | pdata[0] = fcofs; pdata[1] = (uint32_t)ctx->codesz; pdata[2] = 20; | ||
256 | owrite(ctx, &pdata, sizeof(pdata)); | ||
257 | reloc.vaddr = 0; reloc.symidx = 1+2+nrsym+2+2+1; | ||
258 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
259 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
260 | reloc.vaddr = 4; reloc.symidx = 1+2+nrsym+2+2+1; | ||
261 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
262 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
263 | reloc.vaddr = 8; reloc.symidx = 1+2+nrsym+2; | ||
264 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
265 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
266 | reloc.vaddr = 12; reloc.symidx = 1+2+nrsym+2+2+1; | ||
267 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
268 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
269 | reloc.vaddr = 16; reloc.symidx = 1+2+nrsym+2+2+1; | ||
270 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
271 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
272 | reloc.vaddr = 20; reloc.symidx = 1+2+nrsym+2; | ||
273 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
274 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
275 | } | ||
276 | { /* Write .xdata section. */ | ||
277 | uint16_t xdata[8+2+6]; | ||
278 | PEreloc reloc; | ||
279 | xdata[0] = 0x01|0x08|0x10; /* Ver. 1, uhandler/ehandler, prolog size 0. */ | ||
280 | xdata[1] = 0x0005; /* Number of unwind codes, no frame pointer. */ | ||
281 | xdata[2] = 0x4200; /* Stack offset 4*8+8 = aword*5. */ | ||
282 | xdata[3] = 0x3000; /* Push rbx. */ | ||
283 | xdata[4] = 0x6000; /* Push rsi. */ | ||
284 | xdata[5] = 0x7000; /* Push rdi. */ | ||
285 | xdata[6] = 0x5000; /* Push rbp. */ | ||
286 | xdata[7] = 0; /* Alignment. */ | ||
287 | xdata[8] = xdata[9] = 0; /* Relocated address of exception handler. */ | ||
288 | xdata[10] = 0x01; /* Ver. 1, no handler, prolog size 0. */ | ||
289 | xdata[11] = 0x1504; /* Number of unwind codes, fp = rbp, fpofs = 16. */ | ||
290 | xdata[12] = 0x0300; /* set_fpreg. */ | ||
291 | xdata[13] = 0x0200; /* stack offset 0*8+8 = aword*1. */ | ||
292 | xdata[14] = 0x3000; /* Push rbx. */ | ||
293 | xdata[15] = 0x5000; /* Push rbp. */ | ||
294 | owrite(ctx, &xdata, sizeof(xdata)); | ||
295 | reloc.vaddr = 2*8; reloc.symidx = 1+2+nrsym+2+2; | ||
296 | reloc.type = PEOBJ_RELOC_ADDR32NB; | ||
297 | owrite(ctx, &reloc, PEOBJ_RELOC_SIZE); | ||
298 | } | ||
299 | #endif | ||
300 | |||
301 | /* Write .rdata$Z section. */ | ||
302 | owrite(ctx, ctx->dasm_ident, strlen(ctx->dasm_ident)+1); | ||
303 | |||
304 | /* Write symbol table. */ | ||
305 | strtab = NULL; /* 1st pass: collect string sizes. */ | ||
306 | for (;;) { | ||
307 | strtabofs = 4; | ||
308 | /* Mark as SafeSEH compliant. */ | ||
309 | emit_peobj_sym(ctx, "@feat.00", 1, | ||
310 | PEOBJ_SECT_ABS, PEOBJ_TYPE_NULL, PEOBJ_SCL_STATIC); | ||
311 | |||
312 | emit_peobj_sym_sect(ctx, pesect, PEOBJ_SECT_TEXT); | ||
313 | for (i = 0; i < nrsym; i++) | ||
314 | emit_peobj_sym(ctx, ctx->relocsym[i], 0, | ||
315 | PEOBJ_SECT_UNDEF, PEOBJ_TYPE_FUNC, PEOBJ_SCL_EXTERN); | ||
316 | |||
317 | #if LJ_TARGET_X64 | ||
318 | emit_peobj_sym_sect(ctx, pesect, PEOBJ_SECT_PDATA); | ||
319 | emit_peobj_sym_sect(ctx, pesect, PEOBJ_SECT_XDATA); | ||
320 | emit_peobj_sym(ctx, "lj_err_unwind_win64", 0, | ||
321 | PEOBJ_SECT_UNDEF, PEOBJ_TYPE_FUNC, PEOBJ_SCL_EXTERN); | ||
322 | #endif | ||
323 | |||
324 | emit_peobj_sym(ctx, ctx->beginsym, 0, | ||
325 | PEOBJ_SECT_TEXT, PEOBJ_TYPE_NULL, PEOBJ_SCL_EXTERN); | ||
326 | for (i = 0; i < ctx->nsym; i++) | ||
327 | emit_peobj_sym(ctx, ctx->sym[i].name, (uint32_t)ctx->sym[i].ofs, | ||
328 | PEOBJ_SECT_TEXT, PEOBJ_TYPE_FUNC, PEOBJ_SCL_EXTERN); | ||
329 | |||
330 | emit_peobj_sym_sect(ctx, pesect, PEOBJ_SECT_RDATA_Z); | ||
331 | |||
332 | if (strtab) | ||
333 | break; | ||
334 | /* 2nd pass: alloc strtab, write syms and copy strings. */ | ||
335 | strtab = (char *)malloc(strtabofs); | ||
336 | *(uint32_t *)strtab = (uint32_t)strtabofs; | ||
337 | } | ||
338 | |||
339 | /* Write string table. */ | ||
340 | owrite(ctx, strtab, strtabofs); | ||
341 | } | ||
342 | |||
343 | #else | ||
344 | |||
345 | void emit_peobj(BuildCtx *ctx) | ||
346 | { | ||
347 | UNUSED(ctx); | ||
348 | fprintf(stderr, "Error: no PE object support for this target\n"); | ||
349 | exit(1); | ||
350 | } | ||
351 | |||
352 | #endif | ||