The Tor Browser / file comparison

comparison: intl/icu/source/tools/toolutil/pkg_genc.c

intl/icu/source/tools/toolutil/pkg_genc.c

branch
TOR_BUG_3246
changeset 4
fc2d59ddac77
equal deleted inserted replaced
-1:000000000000 0:a302acde8c06
1 /******************************************************************************
2 * Copyright (C) 2009-2013, International Business Machines
3 * Corporation and others. All Rights Reserved.
4 *******************************************************************************
5 */
6 #include "unicode/utypes.h"
7
8 #if U_PLATFORM_HAS_WIN32_API
9 # define VC_EXTRALEAN
10 # define WIN32_LEAN_AND_MEAN
11 # define NOUSER
12 # define NOSERVICE
13 # define NOIME
14 # define NOMCX
15 #include <windows.h>
16 #include <time.h>
17 # ifdef __GNUC__
18 # define WINDOWS_WITH_GNUC
19 # endif
20 #endif
21
22 #if U_PLATFORM_IS_LINUX_BASED && U_HAVE_ELF_H
23 # define U_ELF
24 #endif
25
26 #ifdef U_ELF
27 # include <elf.h>
28 # if defined(ELFCLASS64)
29 # define U_ELF64
30 # endif
31 /* Old elf.h headers may not have EM_X86_64, or have EM_X8664 instead. */
32 # ifndef EM_X86_64
33 # define EM_X86_64 62
34 # endif
35 # define ICU_ENTRY_OFFSET 0
36 #endif
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include "unicode/putil.h"
41 #include "cmemory.h"
42 #include "cstring.h"
43 #include "filestrm.h"
44 #include "toolutil.h"
45 #include "unicode/uclean.h"
46 #include "uoptions.h"
47 #include "pkg_genc.h"
48
49 #define MAX_COLUMN ((uint32_t)(0xFFFFFFFFU))
50
51 #define HEX_0X 0 /* 0x1234 */
52 #define HEX_0H 1 /* 01234h */
53
54 /* prototypes --------------------------------------------------------------- */
55 static void
56 getOutFilename(const char *inFilename, const char *destdir, char *outFilename, char *entryName, const char *newSuffix, const char *optFilename);
57
58 static uint32_t
59 write8(FileStream *out, uint8_t byte, uint32_t column);
60
61 static uint32_t
62 write32(FileStream *out, uint32_t byte, uint32_t column);
63
64 #if U_PLATFORM == U_PF_OS400
65 static uint32_t
66 write8str(FileStream *out, uint8_t byte, uint32_t column);
67 #endif
68 /* -------------------------------------------------------------------------- */
69
70 /*
71 Creating Template Files for New Platforms
72
73 Let the cc compiler help you get started.
74 Compile this program
75 const unsigned int x[5] = {1, 2, 0xdeadbeef, 0xffffffff, 16};
76 with the -S option to produce assembly output.
77
78 For example, this will generate array.s:
79 gcc -S array.c
80
81 This will produce a .s file that may look like this:
82
83 .file "array.c"
84 .version "01.01"
85 gcc2_compiled.:
86 .globl x
87 .section .rodata
88 .align 4
89 .type x,@object
90 .size x,20
91 x:
92 .long 1
93 .long 2
94 .long -559038737
95 .long -1
96 .long 16
97 .ident "GCC: (GNU) 2.96 20000731 (Red Hat Linux 7.1 2.96-85)"
98
99 which gives a starting point that will compile, and can be transformed
100 to become the template, generally with some consulting of as docs and
101 some experimentation.
102
103 If you want ICU to automatically use this assembly, you should
104 specify "GENCCODE_ASSEMBLY=-a name" in the specific config/mh-* file,
105 where the name is the compiler or platform that you used in this
106 assemblyHeader data structure.
107 */
108 static const struct AssemblyType {
109 const char *name;
110 const char *header;
111 const char *beginLine;
112 const char *footer;
113 int8_t hexType; /* HEX_0X or HEX_0h */
114 } assemblyHeader[] = {
115 // For gcc assemblers, the meaning of .align changes depending on the
116 // hardware, so we use .balign 16 which always means 16 bytes.
117 // https://sourceware.org/binutils/docs/as/Pseudo-Ops.html
118 {"gcc",
119 ".globl %s\n"
120 "\t.section .note.GNU-stack,\"\",%%progbits\n"
121 "\t.section .rodata\n"
122 "\t.balign 16\n"
123 "\t.type %s,%%object\n"
124 "%s:\n\n",
125
126 ".long ","",HEX_0X
127 },
128 {"gcc-darwin",
129 /*"\t.section __TEXT,__text,regular,pure_instructions\n"
130 "\t.section __TEXT,__picsymbolstub1,symbol_stubs,pure_instructions,32\n"*/
131 ".globl _%s\n"
132 "\t.data\n"
133 "\t.const\n"
134 "\t.balign 16\n"
135 "_%s:\n\n",
136
137 ".long ","",HEX_0X
138 },
139 {"gcc-cygwin",
140 ".globl _%s\n"
141 "\t.section .rodata\n"
142 "\t.balign 16\n"
143 "_%s:\n\n",
144
145 ".long ","",HEX_0X
146 },
147 {"gcc-mingw64",
148 ".globl %s\n"
149 "\t.section .rodata\n"
150 "\t.balign 16\n"
151 "%s:\n\n",
152
153 ".long ","",HEX_0X
154 },
155 // 16 bytes alignment.
156 // http://docs.oracle.com/cd/E19641-01/802-1947/802-1947.pdf
157 {"sun",
158 "\t.section \".rodata\"\n"
159 "\t.align 16\n"
160 ".globl %s\n"
161 "%s:\n",
162
163 ".word ","",HEX_0X
164 },
165 // 16 bytes alignment for sun-x86.
166 // http://docs.oracle.com/cd/E19963-01/html/821-1608/eoiyg.html
167 {"sun-x86",
168 "Drodata.rodata:\n"
169 "\t.type Drodata.rodata,@object\n"
170 "\t.size Drodata.rodata,0\n"
171 "\t.globl %s\n"
172 "\t.align 16\n"
173 "%s:\n",
174
175 ".4byte ","",HEX_0X
176 },
177 // 1<<4 bit alignment for aix.
178 // http://pic.dhe.ibm.com/infocenter/aix/v6r1/index.jsp?topic=%2Fcom.ibm.aix.aixassem%2Fdoc%2Falangref%2Fidalangref_csect_pseudoop.htm
179 {"xlc",
180 ".globl %s{RO}\n"
181 "\t.toc\n"
182 "%s:\n"
183 "\t.csect %s{RO}, 4\n",
184
185 ".long ","",HEX_0X
186 },
187 {"aCC-ia64",
188 "\t.file \"%s.s\"\n"
189 "\t.type %s,@object\n"
190 "\t.global %s\n"
191 "\t.secalias .abe$0.rodata, \".rodata\"\n"
192 "\t.section .abe$0.rodata = \"a\", \"progbits\"\n"
193 "\t.align 16\n"
194 "%s::\t",
195
196 "data4 ","",HEX_0X
197 },
198 {"aCC-parisc",
199 "\t.SPACE $TEXT$\n"
200 "\t.SUBSPA $LIT$\n"
201 "%s\n"
202 "\t.EXPORT %s\n"
203 "\t.ALIGN 16\n",
204
205 ".WORD ","",HEX_0X
206 },
207 // align 16 bytes
208 // http://msdn.microsoft.com/en-us/library/dwa9fwef.aspx
209 { "masm",
210 "\tTITLE %s\n"
211 "; generated by genccode\n"
212 ".386\n"
213 ".model flat\n"
214 "\tPUBLIC _%s\n"
215 "ICUDATA_%s\tSEGMENT READONLY PARA PUBLIC FLAT 'DATA'\n"
216 "\tALIGN 16\n"
217 "_%s\tLABEL DWORD\n",
218 "\tDWORD ","\nICUDATA_%s\tENDS\n\tEND\n",HEX_0H
219 }
220 };
221
222 static int32_t assemblyHeaderIndex = -1;
223 static int32_t hexType = HEX_0X;
224
225 U_CAPI UBool U_EXPORT2
226 checkAssemblyHeaderName(const char* optAssembly) {
227 int32_t idx;
228 assemblyHeaderIndex = -1;
229 for (idx = 0; idx < (int32_t)(sizeof(assemblyHeader)/sizeof(assemblyHeader[0])); idx++) {
230 if (uprv_strcmp(optAssembly, assemblyHeader[idx].name) == 0) {
231 assemblyHeaderIndex = idx;
232 hexType = assemblyHeader[idx].hexType; /* set the hex type */
233 return TRUE;
234 }
235 }
236
237 return FALSE;
238 }
239
240
241 U_CAPI void U_EXPORT2
242 printAssemblyHeadersToStdErr(void) {
243 int32_t idx;
244 fprintf(stderr, "%s", assemblyHeader[0].name);
245 for (idx = 1; idx < (int32_t)(sizeof(assemblyHeader)/sizeof(assemblyHeader[0])); idx++) {
246 fprintf(stderr, ", %s", assemblyHeader[idx].name);
247 }
248 fprintf(stderr,
249 ")\n");
250 }
251
252 U_CAPI void U_EXPORT2
253 writeAssemblyCode(const char *filename, const char *destdir, const char *optEntryPoint, const char *optFilename, char *outFilePath) {
254 uint32_t column = MAX_COLUMN;
255 char entry[64];
256 uint32_t buffer[1024];
257 char *bufferStr = (char *)buffer;
258 FileStream *in, *out;
259 size_t i, length;
260
261 in=T_FileStream_open(filename, "rb");
262 if(in==NULL) {
263 fprintf(stderr, "genccode: unable to open input file %s\n", filename);
264 exit(U_FILE_ACCESS_ERROR);
265 }
266
267 getOutFilename(filename, destdir, bufferStr, entry, ".s", optFilename);
268 out=T_FileStream_open(bufferStr, "w");
269 if(out==NULL) {
270 fprintf(stderr, "genccode: unable to open output file %s\n", bufferStr);
271 exit(U_FILE_ACCESS_ERROR);
272 }
273
274 if (outFilePath != NULL) {
275 uprv_strcpy(outFilePath, bufferStr);
276 }
277
278 #ifdef WINDOWS_WITH_GNUC
279 /* Need to fix the file seperator character when using MinGW. */
280 swapFileSepChar(outFilePath, U_FILE_SEP_CHAR, '/');
281 #endif
282
283 if(optEntryPoint != NULL) {
284 uprv_strcpy(entry, optEntryPoint);
285 uprv_strcat(entry, "_dat");
286 }
287
288 /* turn dashes or dots in the entry name into underscores */
289 length=uprv_strlen(entry);
290 for(i=0; i<length; ++i) {
291 if(entry[i]=='-' || entry[i]=='.') {
292 entry[i]='_';
293 }
294 }
295
296 sprintf(bufferStr, assemblyHeader[assemblyHeaderIndex].header,
297 entry, entry, entry, entry,
298 entry, entry, entry, entry);
299 T_FileStream_writeLine(out, bufferStr);
300 T_FileStream_writeLine(out, assemblyHeader[assemblyHeaderIndex].beginLine);
301
302 for(;;) {
303 length=T_FileStream_read(in, buffer, sizeof(buffer));
304 if(length==0) {
305 break;
306 }
307 if (length != sizeof(buffer)) {
308 /* pad with extra 0's when at the end of the file */
309 for(i=0; i < (length % sizeof(uint32_t)); ++i) {
310 buffer[length+i] = 0;
311 }
312 }
313 for(i=0; i<(length/sizeof(buffer[0])); i++) {
314 column = write32(out, buffer[i], column);
315 }
316 }
317
318 T_FileStream_writeLine(out, "\n");
319
320 sprintf(bufferStr, assemblyHeader[assemblyHeaderIndex].footer,
321 entry, entry, entry, entry,
322 entry, entry, entry, entry);
323 T_FileStream_writeLine(out, bufferStr);
324
325 if(T_FileStream_error(in)) {
326 fprintf(stderr, "genccode: file read error while generating from file %s\n", filename);
327 exit(U_FILE_ACCESS_ERROR);
328 }
329
330 if(T_FileStream_error(out)) {
331 fprintf(stderr, "genccode: file write error while generating from file %s\n", filename);
332 exit(U_FILE_ACCESS_ERROR);
333 }
334
335 T_FileStream_close(out);
336 T_FileStream_close(in);
337 }
338
339 U_CAPI void U_EXPORT2
340 writeCCode(const char *filename, const char *destdir, const char *optName, const char *optFilename, char *outFilePath) {
341 uint32_t column = MAX_COLUMN;
342 char buffer[4096], entry[64];
343 FileStream *in, *out;
344 size_t i, length;
345
346 in=T_FileStream_open(filename, "rb");
347 if(in==NULL) {
348 fprintf(stderr, "genccode: unable to open input file %s\n", filename);
349 exit(U_FILE_ACCESS_ERROR);
350 }
351
352 if(optName != NULL) { /* prepend 'icudt28_' */
353 strcpy(entry, optName);
354 strcat(entry, "_");
355 } else {
356 entry[0] = 0;
357 }
358
359 getOutFilename(filename, destdir, buffer, entry+uprv_strlen(entry), ".c", optFilename);
360 if (outFilePath != NULL) {
361 uprv_strcpy(outFilePath, buffer);
362 }
363 out=T_FileStream_open(buffer, "w");
364 if(out==NULL) {
365 fprintf(stderr, "genccode: unable to open output file %s\n", buffer);
366 exit(U_FILE_ACCESS_ERROR);
367 }
368
369 /* turn dashes or dots in the entry name into underscores */
370 length=uprv_strlen(entry);
371 for(i=0; i<length; ++i) {
372 if(entry[i]=='-' || entry[i]=='.') {
373 entry[i]='_';
374 }
375 }
376
377 #if U_PLATFORM == U_PF_OS400
378 /*
379 TODO: Fix this once the compiler implements this feature. Keep in sync with udatamem.c
380
381 This is here because this platform can't currently put
382 const data into the read-only pages of an object or
383 shared library (service program). Only strings are allowed in read-only
384 pages, so we use char * strings to store the data.
385
386 In order to prevent the beginning of the data from ever matching the
387 magic numbers we must still use the initial double.
388 [grhoten 4/24/2003]
389 */
390 sprintf(buffer,
391 "#ifndef IN_GENERATED_CCODE\n"
392 "#define IN_GENERATED_CCODE\n"
393 "#define U_DISABLE_RENAMING 1\n"
394 "#include \"unicode/umachine.h\"\n"
395 "#endif\n"
396 "U_CDECL_BEGIN\n"
397 "const struct {\n"
398 " double bogus;\n"
399 " const char *bytes; \n"
400 "} %s={ 0.0, \n",
401 entry);
402 T_FileStream_writeLine(out, buffer);
403
404 for(;;) {
405 length=T_FileStream_read(in, buffer, sizeof(buffer));
406 if(length==0) {
407 break;
408 }
409 for(i=0; i<length; ++i) {
410 column = write8str(out, (uint8_t)buffer[i], column);
411 }
412 }
413
414 T_FileStream_writeLine(out, "\"\n};\nU_CDECL_END\n");
415 #else
416 /* Function renaming shouldn't be done in data */
417 sprintf(buffer,
418 "#ifndef IN_GENERATED_CCODE\n"
419 "#define IN_GENERATED_CCODE\n"
420 "#define U_DISABLE_RENAMING 1\n"
421 "#include \"unicode/umachine.h\"\n"
422 "#endif\n"
423 "U_CDECL_BEGIN\n"
424 "const struct {\n"
425 " double bogus;\n"
426 " uint8_t bytes[%ld]; \n"
427 "} %s={ 0.0, {\n",
428 (long)T_FileStream_size(in), entry);
429 T_FileStream_writeLine(out, buffer);
430
431 for(;;) {
432 length=T_FileStream_read(in, buffer, sizeof(buffer));
433 if(length==0) {
434 break;
435 }
436 for(i=0; i<length; ++i) {
437 column = write8(out, (uint8_t)buffer[i], column);
438 }
439 }
440
441 T_FileStream_writeLine(out, "\n}\n};\nU_CDECL_END\n");
442 #endif
443
444 if(T_FileStream_error(in)) {
445 fprintf(stderr, "genccode: file read error while generating from file %s\n", filename);
446 exit(U_FILE_ACCESS_ERROR);
447 }
448
449 if(T_FileStream_error(out)) {
450 fprintf(stderr, "genccode: file write error while generating from file %s\n", filename);
451 exit(U_FILE_ACCESS_ERROR);
452 }
453
454 T_FileStream_close(out);
455 T_FileStream_close(in);
456 }
457
458 static uint32_t
459 write32(FileStream *out, uint32_t bitField, uint32_t column) {
460 int32_t i;
461 char bitFieldStr[64]; /* This is more bits than needed for a 32-bit number */
462 char *s = bitFieldStr;
463 uint8_t *ptrIdx = (uint8_t *)&bitField;
464 static const char hexToStr[16] = {
465 '0','1','2','3',
466 '4','5','6','7',
467 '8','9','A','B',
468 'C','D','E','F'
469 };
470
471 /* write the value, possibly with comma and newline */
472 if(column==MAX_COLUMN) {
473 /* first byte */
474 column=1;
475 } else if(column<32) {
476 *(s++)=',';
477 ++column;
478 } else {
479 *(s++)='\n';
480 uprv_strcpy(s, assemblyHeader[assemblyHeaderIndex].beginLine);
481 s+=uprv_strlen(s);
482 column=1;
483 }
484
485 if (bitField < 10) {
486 /* It's a small number. Don't waste the space for 0x */
487 *(s++)=hexToStr[bitField];
488 }
489 else {
490 int seenNonZero = 0; /* This is used to remove leading zeros */
491
492 if(hexType==HEX_0X) {
493 *(s++)='0';
494 *(s++)='x';
495 } else if(hexType==HEX_0H) {
496 *(s++)='0';
497 }
498
499 /* This creates a 32-bit field */
500 #if U_IS_BIG_ENDIAN
501 for (i = 0; i < sizeof(uint32_t); i++)
502 #else
503 for (i = sizeof(uint32_t)-1; i >= 0 ; i--)
504 #endif
505 {
506 uint8_t value = ptrIdx[i];
507 if (value || seenNonZero) {
508 *(s++)=hexToStr[value>>4];
509 *(s++)=hexToStr[value&0xF];
510 seenNonZero = 1;
511 }
512 }
513 if(hexType==HEX_0H) {
514 *(s++)='h';
515 }
516 }
517
518 *(s++)=0;
519 T_FileStream_writeLine(out, bitFieldStr);
520 return column;
521 }
522
523 static uint32_t
524 write8(FileStream *out, uint8_t byte, uint32_t column) {
525 char s[4];
526 int i=0;
527
528 /* convert the byte value to a string */
529 if(byte>=100) {
530 s[i++]=(char)('0'+byte/100);
531 byte%=100;
532 }
533 if(i>0 || byte>=10) {
534 s[i++]=(char)('0'+byte/10);
535 byte%=10;
536 }
537 s[i++]=(char)('0'+byte);
538 s[i]=0;
539
540 /* write the value, possibly with comma and newline */
541 if(column==MAX_COLUMN) {
542 /* first byte */
543 column=1;
544 } else if(column<16) {
545 T_FileStream_writeLine(out, ",");
546 ++column;
547 } else {
548 T_FileStream_writeLine(out, ",\n");
549 column=1;
550 }
551 T_FileStream_writeLine(out, s);
552 return column;
553 }
554
555 #if U_PLATFORM == U_PF_OS400
556 static uint32_t
557 write8str(FileStream *out, uint8_t byte, uint32_t column) {
558 char s[8];
559
560 if (byte > 7)
561 sprintf(s, "\\x%X", byte);
562 else
563 sprintf(s, "\\%X", byte);
564
565 /* write the value, possibly with comma and newline */
566 if(column==MAX_COLUMN) {
567 /* first byte */
568 column=1;
569 T_FileStream_writeLine(out, "\"");
570 } else if(column<24) {
571 ++column;
572 } else {
573 T_FileStream_writeLine(out, "\"\n\"");
574 column=1;
575 }
576 T_FileStream_writeLine(out, s);
577 return column;
578 }
579 #endif
580
581 static void
582 getOutFilename(const char *inFilename, const char *destdir, char *outFilename, char *entryName, const char *newSuffix, const char *optFilename) {
583 const char *basename=findBasename(inFilename), *suffix=uprv_strrchr(basename, '.');
584
585 /* copy path */
586 if(destdir!=NULL && *destdir!=0) {
587 do {
588 *outFilename++=*destdir++;
589 } while(*destdir!=0);
590 if(*(outFilename-1)!=U_FILE_SEP_CHAR) {
591 *outFilename++=U_FILE_SEP_CHAR;
592 }
593 inFilename=basename;
594 } else {
595 while(inFilename<basename) {
596 *outFilename++=*inFilename++;
597 }
598 }
599
600 if(suffix==NULL) {
601 /* the filename does not have a suffix */
602 uprv_strcpy(entryName, inFilename);
603 if(optFilename != NULL) {
604 uprv_strcpy(outFilename, optFilename);
605 } else {
606 uprv_strcpy(outFilename, inFilename);
607 }
608 uprv_strcat(outFilename, newSuffix);
609 } else {
610 char *saveOutFilename = outFilename;
611 /* copy basename */
612 while(inFilename<suffix) {
613 if(*inFilename=='-') {
614 /* iSeries cannot have '-' in the .o objects. */
615 *outFilename++=*entryName++='_';
616 inFilename++;
617 }
618 else {
619 *outFilename++=*entryName++=*inFilename++;
620 }
621 }
622
623 /* replace '.' by '_' */
624 *outFilename++=*entryName++='_';
625 ++inFilename;
626
627 /* copy suffix */
628 while(*inFilename!=0) {
629 *outFilename++=*entryName++=*inFilename++;
630 }
631
632 *entryName=0;
633
634 if(optFilename != NULL) {
635 uprv_strcpy(saveOutFilename, optFilename);
636 uprv_strcat(saveOutFilename, newSuffix);
637 } else {
638 /* add ".c" */
639 uprv_strcpy(outFilename, newSuffix);
640 }
641 }
642 }
643
644 #ifdef CAN_GENERATE_OBJECTS
645 static void
646 getArchitecture(uint16_t *pCPU, uint16_t *pBits, UBool *pIsBigEndian, const char *optMatchArch) {
647 union {
648 char bytes[2048];
649 #ifdef U_ELF
650 Elf32_Ehdr header32;
651 /* Elf32_Ehdr and ELF64_Ehdr are identical for the necessary fields. */
652 #elif U_PLATFORM_HAS_WIN32_API
653 IMAGE_FILE_HEADER header;
654 #endif
655 } buffer;
656
657 const char *filename;
658 FileStream *in;
659 int32_t length;
660
661 #ifdef U_ELF
662
663 #elif U_PLATFORM_HAS_WIN32_API
664 const IMAGE_FILE_HEADER *pHeader;
665 #else
666 # error "Unknown platform for CAN_GENERATE_OBJECTS."
667 #endif
668
669 if(optMatchArch != NULL) {
670 filename=optMatchArch;
671 } else {
672 /* set defaults */
673 #ifdef U_ELF
674 /* set EM_386 because elf.h does not provide better defaults */
675 *pCPU=EM_386;
676 *pBits=32;
677 *pIsBigEndian=(UBool)(U_IS_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB);
678 #elif U_PLATFORM_HAS_WIN32_API
679 /* _M_IA64 should be defined in windows.h */
680 # if defined(_M_IA64)
681 *pCPU=IMAGE_FILE_MACHINE_IA64;
682 # elif defined(_M_AMD64)
683 *pCPU=IMAGE_FILE_MACHINE_AMD64;
684 # else
685 *pCPU=IMAGE_FILE_MACHINE_I386;
686 # endif
687 *pBits= *pCPU==IMAGE_FILE_MACHINE_I386 ? 32 : 64;
688 *pIsBigEndian=FALSE;
689 #else
690 # error "Unknown platform for CAN_GENERATE_OBJECTS."
691 #endif
692 return;
693 }
694
695 in=T_FileStream_open(filename, "rb");
696 if(in==NULL) {
697 fprintf(stderr, "genccode: unable to open match-arch file %s\n", filename);
698 exit(U_FILE_ACCESS_ERROR);
699 }
700 length=T_FileStream_read(in, buffer.bytes, sizeof(buffer.bytes));
701
702 #ifdef U_ELF
703 if(length<sizeof(Elf32_Ehdr)) {
704 fprintf(stderr, "genccode: match-arch file %s is too short\n", filename);
705 exit(U_UNSUPPORTED_ERROR);
706 }
707 if(
708 buffer.header32.e_ident[0]!=ELFMAG0 ||
709 buffer.header32.e_ident[1]!=ELFMAG1 ||
710 buffer.header32.e_ident[2]!=ELFMAG2 ||
711 buffer.header32.e_ident[3]!=ELFMAG3 ||
712 buffer.header32.e_ident[EI_CLASS]<ELFCLASS32 || buffer.header32.e_ident[EI_CLASS]>ELFCLASS64
713 ) {
714 fprintf(stderr, "genccode: match-arch file %s is not an ELF object file, or not supported\n", filename);
715 exit(U_UNSUPPORTED_ERROR);
716 }
717
718 *pBits= buffer.header32.e_ident[EI_CLASS]==ELFCLASS32 ? 32 : 64; /* only 32 or 64: see check above */
719 #ifdef U_ELF64
720 if(*pBits!=32 && *pBits!=64) {
721 fprintf(stderr, "genccode: currently only supports 32-bit and 64-bit ELF format\n");
722 exit(U_UNSUPPORTED_ERROR);
723 }
724 #else
725 if(*pBits!=32) {
726 fprintf(stderr, "genccode: built with elf.h missing 64-bit definitions\n");
727 exit(U_UNSUPPORTED_ERROR);
728 }
729 #endif
730
731 *pIsBigEndian=(UBool)(buffer.header32.e_ident[EI_DATA]==ELFDATA2MSB);
732 if(*pIsBigEndian!=U_IS_BIG_ENDIAN) {
733 fprintf(stderr, "genccode: currently only same-endianness ELF formats are supported\n");
734 exit(U_UNSUPPORTED_ERROR);
735 }
736 /* TODO: Support byte swapping */
737
738 *pCPU=buffer.header32.e_machine;
739 #elif U_PLATFORM_HAS_WIN32_API
740 if(length<sizeof(IMAGE_FILE_HEADER)) {
741 fprintf(stderr, "genccode: match-arch file %s is too short\n", filename);
742 exit(U_UNSUPPORTED_ERROR);
743 }
744 /* TODO: Use buffer.header. Keep aliasing legal. */
745 pHeader=(const IMAGE_FILE_HEADER *)buffer.bytes;
746 *pCPU=pHeader->Machine;
747 /*
748 * The number of bits is implicit with the Machine value.
749 * *pBits is ignored in the calling code, so this need not be precise.
750 */
751 *pBits= *pCPU==IMAGE_FILE_MACHINE_I386 ? 32 : 64;
752 /* Windows always runs on little-endian CPUs. */
753 *pIsBigEndian=FALSE;
754 #else
755 # error "Unknown platform for CAN_GENERATE_OBJECTS."
756 #endif
757
758 T_FileStream_close(in);
759 }
760
761 U_CAPI void U_EXPORT2
762 writeObjectCode(const char *filename, const char *destdir, const char *optEntryPoint, const char *optMatchArch, const char *optFilename, char *outFilePath) {
763 /* common variables */
764 char buffer[4096], entry[40]={ 0 };
765 FileStream *in, *out;
766 const char *newSuffix;
767 int32_t i, entryLength, length, size, entryOffset=0, entryLengthOffset=0;
768
769 uint16_t cpu, bits;
770 UBool makeBigEndian;
771
772 /* platform-specific variables and initialization code */
773 #ifdef U_ELF
774 /* 32-bit Elf file header */
775 static Elf32_Ehdr header32={
776 {
777 /* e_ident[] */
778 ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3,
779 ELFCLASS32,
780 U_IS_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB,
781 EV_CURRENT /* EI_VERSION */
782 },
783 ET_REL,
784 EM_386,
785 EV_CURRENT, /* e_version */
786 0, /* e_entry */
787 0, /* e_phoff */
788 (Elf32_Off)sizeof(Elf32_Ehdr), /* e_shoff */
789 0, /* e_flags */
790 (Elf32_Half)sizeof(Elf32_Ehdr), /* eh_size */
791 0, /* e_phentsize */
792 0, /* e_phnum */
793 (Elf32_Half)sizeof(Elf32_Shdr), /* e_shentsize */
794 5, /* e_shnum */
795 2 /* e_shstrndx */
796 };
797
798 /* 32-bit Elf section header table */
799 static Elf32_Shdr sectionHeaders32[5]={
800 { /* SHN_UNDEF */
801 0
802 },
803 { /* .symtab */
804 1, /* sh_name */
805 SHT_SYMTAB,
806 0, /* sh_flags */
807 0, /* sh_addr */
808 (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)), /* sh_offset */
809 (Elf32_Word)(2*sizeof(Elf32_Sym)), /* sh_size */
810 3, /* sh_link=sect hdr index of .strtab */
811 1, /* sh_info=One greater than the symbol table index of the last
812 * local symbol (with STB_LOCAL). */
813 4, /* sh_addralign */
814 (Elf32_Word)(sizeof(Elf32_Sym)) /* sh_entsize */
815 },
816 { /* .shstrtab */
817 9, /* sh_name */
818 SHT_STRTAB,
819 0, /* sh_flags */
820 0, /* sh_addr */
821 (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)+2*sizeof(Elf32_Sym)), /* sh_offset */
822 40, /* sh_size */
823 0, /* sh_link */
824 0, /* sh_info */
825 1, /* sh_addralign */
826 0 /* sh_entsize */
827 },
828 { /* .strtab */
829 19, /* sh_name */
830 SHT_STRTAB,
831 0, /* sh_flags */
832 0, /* sh_addr */
833 (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)+2*sizeof(Elf32_Sym)+40), /* sh_offset */
834 (Elf32_Word)sizeof(entry), /* sh_size */
835 0, /* sh_link */
836 0, /* sh_info */
837 1, /* sh_addralign */
838 0 /* sh_entsize */
839 },
840 { /* .rodata */
841 27, /* sh_name */
842 SHT_PROGBITS,
843 SHF_ALLOC, /* sh_flags */
844 0, /* sh_addr */
845 (Elf32_Off)(sizeof(header32)+sizeof(sectionHeaders32)+2*sizeof(Elf32_Sym)+40+sizeof(entry)), /* sh_offset */
846 0, /* sh_size */
847 0, /* sh_link */
848 0, /* sh_info */
849 16, /* sh_addralign */
850 0 /* sh_entsize */
851 }
852 };
853
854 /* symbol table */
855 static Elf32_Sym symbols32[2]={
856 { /* STN_UNDEF */
857 0
858 },
859 { /* data entry point */
860 1, /* st_name */
861 0, /* st_value */
862 0, /* st_size */
863 ELF64_ST_INFO(STB_GLOBAL, STT_OBJECT),
864 0, /* st_other */
865 4 /* st_shndx=index of related section table entry */
866 }
867 };
868
869 /* section header string table, with decimal string offsets */
870 static const char sectionStrings[40]=
871 /* 0 */ "\0"
872 /* 1 */ ".symtab\0"
873 /* 9 */ ".shstrtab\0"
874 /* 19 */ ".strtab\0"
875 /* 27 */ ".rodata\0"
876 /* 35 */ "\0\0\0\0"; /* contains terminating NUL */
877 /* 40: padded to multiple of 8 bytes */
878
879 /*
880 * Use entry[] for the string table which will contain only the
881 * entry point name.
882 * entry[0] must be 0 (NUL)
883 * The entry point name can be up to 38 characters long (sizeof(entry)-2).
884 */
885
886 /* 16-align .rodata in the .o file, just in case */
887 static const char padding[16]={ 0 };
888 int32_t paddingSize;
889
890 #ifdef U_ELF64
891 /* 64-bit Elf file header */
892 static Elf64_Ehdr header64={
893 {
894 /* e_ident[] */
895 ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3,
896 ELFCLASS64,
897 U_IS_BIG_ENDIAN ? ELFDATA2MSB : ELFDATA2LSB,
898 EV_CURRENT /* EI_VERSION */
899 },
900 ET_REL,
901 EM_X86_64,
902 EV_CURRENT, /* e_version */
903 0, /* e_entry */
904 0, /* e_phoff */
905 (Elf64_Off)sizeof(Elf64_Ehdr), /* e_shoff */
906 0, /* e_flags */
907 (Elf64_Half)sizeof(Elf64_Ehdr), /* eh_size */
908 0, /* e_phentsize */
909 0, /* e_phnum */
910 (Elf64_Half)sizeof(Elf64_Shdr), /* e_shentsize */
911 5, /* e_shnum */
912 2 /* e_shstrndx */
913 };
914
915 /* 64-bit Elf section header table */
916 static Elf64_Shdr sectionHeaders64[5]={
917 { /* SHN_UNDEF */
918 0
919 },
920 { /* .symtab */
921 1, /* sh_name */
922 SHT_SYMTAB,
923 0, /* sh_flags */
924 0, /* sh_addr */
925 (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)), /* sh_offset */
926 (Elf64_Xword)(2*sizeof(Elf64_Sym)), /* sh_size */
927 3, /* sh_link=sect hdr index of .strtab */
928 1, /* sh_info=One greater than the symbol table index of the last
929 * local symbol (with STB_LOCAL). */
930 4, /* sh_addralign */
931 (Elf64_Xword)(sizeof(Elf64_Sym)) /* sh_entsize */
932 },
933 { /* .shstrtab */
934 9, /* sh_name */
935 SHT_STRTAB,
936 0, /* sh_flags */
937 0, /* sh_addr */
938 (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)+2*sizeof(Elf64_Sym)), /* sh_offset */
939 40, /* sh_size */
940 0, /* sh_link */
941 0, /* sh_info */
942 1, /* sh_addralign */
943 0 /* sh_entsize */
944 },
945 { /* .strtab */
946 19, /* sh_name */
947 SHT_STRTAB,
948 0, /* sh_flags */
949 0, /* sh_addr */
950 (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)+2*sizeof(Elf64_Sym)+40), /* sh_offset */
951 (Elf64_Xword)sizeof(entry), /* sh_size */
952 0, /* sh_link */
953 0, /* sh_info */
954 1, /* sh_addralign */
955 0 /* sh_entsize */
956 },
957 { /* .rodata */
958 27, /* sh_name */
959 SHT_PROGBITS,
960 SHF_ALLOC, /* sh_flags */
961 0, /* sh_addr */
962 (Elf64_Off)(sizeof(header64)+sizeof(sectionHeaders64)+2*sizeof(Elf64_Sym)+40+sizeof(entry)), /* sh_offset */
963 0, /* sh_size */
964 0, /* sh_link */
965 0, /* sh_info */
966 16, /* sh_addralign */
967 0 /* sh_entsize */
968 }
969 };
970
971 /*
972 * 64-bit symbol table
973 * careful: different order of items compared with Elf32_sym!
974 */
975 static Elf64_Sym symbols64[2]={
976 { /* STN_UNDEF */
977 0
978 },
979 { /* data entry point */
980 1, /* st_name */
981 ELF64_ST_INFO(STB_GLOBAL, STT_OBJECT),
982 0, /* st_other */
983 4, /* st_shndx=index of related section table entry */
984 0, /* st_value */
985 0 /* st_size */
986 }
987 };
988
989 #endif /* U_ELF64 */
990
991 /* entry[] have a leading NUL */
992 entryOffset=1;
993
994 /* in the common code, count entryLength from after the NUL */
995 entryLengthOffset=1;
996
997 newSuffix=".o";
998
999 #elif U_PLATFORM_HAS_WIN32_API
1000 struct {
1001 IMAGE_FILE_HEADER fileHeader;
1002 IMAGE_SECTION_HEADER sections[2];
1003 char linkerOptions[100];
1004 } objHeader;
1005 IMAGE_SYMBOL symbols[1];
1006 struct {
1007 DWORD sizeofLongNames;
1008 char longNames[100];
1009 } symbolNames;
1010
1011 /*
1012 * entry sometimes have a leading '_'
1013 * overwritten if entryOffset==0 depending on the target platform
1014 * see check for cpu below
1015 */
1016 entry[0]='_';
1017
1018 newSuffix=".obj";
1019 #else
1020 # error "Unknown platform for CAN_GENERATE_OBJECTS."
1021 #endif
1022
1023 /* deal with options, files and the entry point name */
1024 getArchitecture(&cpu, &bits, &makeBigEndian, optMatchArch);
1025 printf("genccode: --match-arch cpu=%hu bits=%hu big-endian=%d\n", cpu, bits, makeBigEndian);
1026 #if U_PLATFORM_HAS_WIN32_API
1027 if(cpu==IMAGE_FILE_MACHINE_I386) {
1028 entryOffset=1;
1029 }
1030 #endif
1031
1032 in=T_FileStream_open(filename, "rb");
1033 if(in==NULL) {
1034 fprintf(stderr, "genccode: unable to open input file %s\n", filename);
1035 exit(U_FILE_ACCESS_ERROR);
1036 }
1037 size=T_FileStream_size(in);
1038
1039 getOutFilename(filename, destdir, buffer, entry+entryOffset, newSuffix, optFilename);
1040 if (outFilePath != NULL) {
1041 uprv_strcpy(outFilePath, buffer);
1042 }
1043
1044 if(optEntryPoint != NULL) {
1045 uprv_strcpy(entry+entryOffset, optEntryPoint);
1046 uprv_strcat(entry+entryOffset, "_dat");
1047 }
1048 /* turn dashes in the entry name into underscores */
1049 entryLength=(int32_t)uprv_strlen(entry+entryLengthOffset);
1050 for(i=0; i<entryLength; ++i) {
1051 if(entry[entryLengthOffset+i]=='-') {
1052 entry[entryLengthOffset+i]='_';
1053 }
1054 }
1055
1056 /* open the output file */
1057 out=T_FileStream_open(buffer, "wb");
1058 if(out==NULL) {
1059 fprintf(stderr, "genccode: unable to open output file %s\n", buffer);
1060 exit(U_FILE_ACCESS_ERROR);
1061 }
1062
1063 #ifdef U_ELF
1064 if(bits==32) {
1065 header32.e_ident[EI_DATA]= makeBigEndian ? ELFDATA2MSB : ELFDATA2LSB;
1066 header32.e_machine=cpu;
1067
1068 /* 16-align .rodata in the .o file, just in case */
1069 paddingSize=sectionHeaders32[4].sh_offset & 0xf;
1070 if(paddingSize!=0) {
1071 paddingSize=0x10-paddingSize;
1072 sectionHeaders32[4].sh_offset+=paddingSize;
1073 }
1074
1075 sectionHeaders32[4].sh_size=(Elf32_Word)size;
1076
1077 symbols32[1].st_size=(Elf32_Word)size;
1078
1079 /* write .o headers */
1080 T_FileStream_write(out, &header32, (int32_t)sizeof(header32));
1081 T_FileStream_write(out, sectionHeaders32, (int32_t)sizeof(sectionHeaders32));
1082 T_FileStream_write(out, symbols32, (int32_t)sizeof(symbols32));
1083 } else /* bits==64 */ {
1084 #ifdef U_ELF64
1085 header64.e_ident[EI_DATA]= makeBigEndian ? ELFDATA2MSB : ELFDATA2LSB;
1086 header64.e_machine=cpu;
1087
1088 /* 16-align .rodata in the .o file, just in case */
1089 paddingSize=sectionHeaders64[4].sh_offset & 0xf;
1090 if(paddingSize!=0) {
1091 paddingSize=0x10-paddingSize;
1092 sectionHeaders64[4].sh_offset+=paddingSize;
1093 }
1094
1095 sectionHeaders64[4].sh_size=(Elf64_Xword)size;
1096
1097 symbols64[1].st_size=(Elf64_Xword)size;
1098
1099 /* write .o headers */
1100 T_FileStream_write(out, &header64, (int32_t)sizeof(header64));
1101 T_FileStream_write(out, sectionHeaders64, (int32_t)sizeof(sectionHeaders64));
1102 T_FileStream_write(out, symbols64, (int32_t)sizeof(symbols64));
1103 #endif
1104 }
1105
1106 T_FileStream_write(out, sectionStrings, (int32_t)sizeof(sectionStrings));
1107 T_FileStream_write(out, entry, (int32_t)sizeof(entry));
1108 if(paddingSize!=0) {
1109 T_FileStream_write(out, padding, paddingSize);
1110 }
1111 #elif U_PLATFORM_HAS_WIN32_API
1112 /* populate the .obj headers */
1113 uprv_memset(&objHeader, 0, sizeof(objHeader));
1114 uprv_memset(&symbols, 0, sizeof(symbols));
1115 uprv_memset(&symbolNames, 0, sizeof(symbolNames));
1116
1117 /* write the linker export directive */
1118 uprv_strcpy(objHeader.linkerOptions, "-export:");
1119 length=8;
1120 uprv_strcpy(objHeader.linkerOptions+length, entry);
1121 length+=entryLength;
1122 uprv_strcpy(objHeader.linkerOptions+length, ",data ");
1123 length+=6;
1124
1125 /* set the file header */
1126 objHeader.fileHeader.Machine=cpu;
1127 objHeader.fileHeader.NumberOfSections=2;
1128 objHeader.fileHeader.TimeDateStamp=(DWORD)time(NULL);
1129 objHeader.fileHeader.PointerToSymbolTable=IMAGE_SIZEOF_FILE_HEADER+2*IMAGE_SIZEOF_SECTION_HEADER+length+size; /* start of symbol table */
1130 objHeader.fileHeader.NumberOfSymbols=1;
1131
1132 /* set the section for the linker options */
1133 uprv_strncpy((char *)objHeader.sections[0].Name, ".drectve", 8);
1134 objHeader.sections[0].SizeOfRawData=length;
1135 objHeader.sections[0].PointerToRawData=IMAGE_SIZEOF_FILE_HEADER+2*IMAGE_SIZEOF_SECTION_HEADER;
1136 objHeader.sections[0].Characteristics=IMAGE_SCN_LNK_INFO|IMAGE_SCN_LNK_REMOVE|IMAGE_SCN_ALIGN_1BYTES;
1137
1138 /* set the data section */
1139 uprv_strncpy((char *)objHeader.sections[1].Name, ".rdata", 6);
1140 objHeader.sections[1].SizeOfRawData=size;
1141 objHeader.sections[1].PointerToRawData=IMAGE_SIZEOF_FILE_HEADER+2*IMAGE_SIZEOF_SECTION_HEADER+length;
1142 objHeader.sections[1].Characteristics=IMAGE_SCN_CNT_INITIALIZED_DATA|IMAGE_SCN_ALIGN_16BYTES|IMAGE_SCN_MEM_READ;
1143
1144 /* set the symbol table */
1145 if(entryLength<=8) {
1146 uprv_strncpy((char *)symbols[0].N.ShortName, entry, entryLength);
1147 symbolNames.sizeofLongNames=4;
1148 } else {
1149 symbols[0].N.Name.Short=0;
1150 symbols[0].N.Name.Long=4;
1151 symbolNames.sizeofLongNames=4+entryLength+1;
1152 uprv_strcpy(symbolNames.longNames, entry);
1153 }
1154 symbols[0].SectionNumber=2;
1155 symbols[0].StorageClass=IMAGE_SYM_CLASS_EXTERNAL;
1156
1157 /* write the file header and the linker options section */
1158 T_FileStream_write(out, &objHeader, objHeader.sections[1].PointerToRawData);
1159 #else
1160 # error "Unknown platform for CAN_GENERATE_OBJECTS."
1161 #endif
1162
1163 /* copy the data file into section 2 */
1164 for(;;) {
1165 length=T_FileStream_read(in, buffer, sizeof(buffer));
1166 if(length==0) {
1167 break;
1168 }
1169 T_FileStream_write(out, buffer, (int32_t)length);
1170 }
1171
1172 #if U_PLATFORM_HAS_WIN32_API
1173 /* write the symbol table */
1174 T_FileStream_write(out, symbols, IMAGE_SIZEOF_SYMBOL);
1175 T_FileStream_write(out, &symbolNames, symbolNames.sizeofLongNames);
1176 #endif
1177
1178 if(T_FileStream_error(in)) {
1179 fprintf(stderr, "genccode: file read error while generating from file %s\n", filename);
1180 exit(U_FILE_ACCESS_ERROR);
1181 }
1182
1183 if(T_FileStream_error(out)) {
1184 fprintf(stderr, "genccode: file write error while generating from file %s\n", filename);
1185 exit(U_FILE_ACCESS_ERROR);
1186 }
1187
1188 T_FileStream_close(out);
1189 T_FileStream_close(in);
1190 }
1191 #endif

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial