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 1192
