2 * Small utility functions for winebuild
4 * Copyright 2000 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
33 #ifdef HAVE_SYS_STAT_H
34 # include <sys/stat.h>
36 #ifdef HAVE_SYS_MMAN_H
42 static const char **tmp_files
;
43 static unsigned int nb_tmp_files
;
44 static unsigned int max_tmp_files
;
57 { "amd64", CPU_x86_64
},
58 { "x86_64", CPU_x86_64
},
59 { "sparc", CPU_SPARC
},
60 { "powerpc", CPU_POWERPC
},
62 { "arm64", CPU_ARM64
},
63 { "aarch64", CPU_ARM64
},
66 /* atexit handler to clean tmp files */
67 static void cleanup_tmp_files(void)
70 for (i
= 0; i
< nb_tmp_files
; i
++) if (tmp_files
[i
]) unlink( tmp_files
[i
] );
74 void *xmalloc (size_t size
)
78 res
= malloc (size
? size
: 1);
81 fprintf (stderr
, "Virtual memory exhausted.\n");
87 void *xrealloc (void *ptr
, size_t size
)
89 void *res
= realloc (ptr
, size
);
90 if (size
&& res
== NULL
)
92 fprintf (stderr
, "Virtual memory exhausted.\n");
98 char *xstrdup( const char *str
)
100 char *res
= strdup( str
);
103 fprintf (stderr
, "Virtual memory exhausted.\n");
109 char *strupper(char *s
)
112 for (p
= s
; *p
; p
++) *p
= toupper(*p
);
116 int strendswith(const char* str
, const char* end
)
120 return l
>= m
&& strcmp(str
+ l
- m
, end
) == 0;
123 char *strmake( const char* fmt
, ... )
131 char *p
= xmalloc( size
);
133 n
= vsnprintf( p
, size
, fmt
, ap
);
135 if (n
== -1) size
*= 2;
136 else if ((size_t)n
>= size
) size
= n
+ 1;
142 struct strarray
*strarray_init(void)
144 struct strarray
*array
= xmalloc( sizeof(*array
) );
147 array
->str
= xmalloc( array
->max
* sizeof(*array
->str
) );
151 static void strarray_add_one( struct strarray
*array
, const char *str
)
153 if (array
->count
== array
->max
)
156 array
->str
= xrealloc( array
->str
, array
->max
* sizeof(*array
->str
) );
158 array
->str
[array
->count
++] = str
;
161 void strarray_add( struct strarray
*array
, ... )
166 va_start( valist
, array
);
167 while ((str
= va_arg( valist
, const char *))) strarray_add_one( array
, str
);
171 void strarray_addv( struct strarray
*array
, char * const *argv
)
173 while (*argv
) strarray_add_one( array
, *argv
++ );
176 void strarray_free( struct strarray
*array
)
182 void fatal_error( const char *msg
, ... )
185 va_start( valist
, msg
);
188 fprintf( stderr
, "%s:", input_file_name
);
190 fprintf( stderr
, "%d:", current_line
);
191 fputc( ' ', stderr
);
193 else fprintf( stderr
, "winebuild: " );
194 vfprintf( stderr
, msg
, valist
);
199 void fatal_perror( const char *msg
, ... )
202 va_start( valist
, msg
);
205 fprintf( stderr
, "%s:", input_file_name
);
207 fprintf( stderr
, "%d:", current_line
);
208 fputc( ' ', stderr
);
210 vfprintf( stderr
, msg
, valist
);
216 void error( const char *msg
, ... )
219 va_start( valist
, msg
);
222 fprintf( stderr
, "%s:", input_file_name
);
224 fprintf( stderr
, "%d:", current_line
);
225 fputc( ' ', stderr
);
227 vfprintf( stderr
, msg
, valist
);
232 void warning( const char *msg
, ... )
236 if (!display_warnings
) return;
237 va_start( valist
, msg
);
240 fprintf( stderr
, "%s:", input_file_name
);
242 fprintf( stderr
, "%d:", current_line
);
243 fputc( ' ', stderr
);
245 fprintf( stderr
, "warning: " );
246 vfprintf( stderr
, msg
, valist
);
250 int output( const char *format
, ... )
255 va_start( valist
, format
);
256 ret
= vfprintf( output_file
, format
, valist
);
258 if (ret
< 0) fatal_perror( "Output error" );
262 void spawn( struct strarray
*args
)
267 strarray_add_one( args
, NULL
);
269 for (i
= 0; args
->str
[i
]; i
++)
270 fprintf( stderr
, "%s%c", args
->str
[i
], args
->str
[i
+1] ? ' ' : '\n' );
272 if ((status
= spawnvp( _P_WAIT
, args
->str
[0], args
->str
)))
274 if (status
> 0) fatal_error( "%s failed with status %u\n", args
->str
[0], status
);
275 else fatal_perror( "winebuild" );
280 /* find a build tool in the path, trying the various names */
281 char *find_tool( const char *name
, const char * const *names
)
284 static unsigned int count
, maxlen
;
287 const char *alt_names
[2];
295 /* split the path in directories */
297 if (!getenv( "PATH" )) return NULL
;
298 path
= xstrdup( getenv( "PATH" ));
299 for (p
= path
, count
= 2; *p
; p
++) if (*p
== ':') count
++;
300 dirs
= xmalloc( count
* sizeof(*dirs
) );
302 dirs
[count
++] = p
= path
;
305 while (*p
&& *p
!= ':') p
++;
310 for (i
= 0; i
< count
; i
++) maxlen
= max( maxlen
, strlen(dirs
[i
])+2 );
322 len
= strlen(*names
) + sizeof(EXEEXT
) + 1;
324 len
+= strlen(target_alias
) + 1;
325 file
= xmalloc( maxlen
+ len
);
327 for (i
= 0; i
< count
; i
++)
329 strcpy( file
, dirs
[i
] );
330 p
= file
+ strlen(file
);
331 if (p
== file
) *p
++ = '.';
332 if (p
[-1] != '/') *p
++ = '/';
335 strcpy( p
, target_alias
);
342 if (!stat( file
, &st
) && S_ISREG(st
.st_mode
) && (st
.st_mode
& 0111)) return file
;
350 struct strarray
*get_as_command(void)
352 static int as_is_clang
= 0;
353 struct strarray
*args
= strarray_init();
357 as_command
= find_tool( "clang", NULL
);
358 if (as_command
) as_is_clang
= 1;
363 static const char * const commands
[] = { "gas", "as", NULL
};
364 as_command
= find_tool( "as", commands
);
368 fatal_error( "cannot find suitable assembler\n" );
370 strarray_add_one( args
, as_command
);
374 strarray_add( args
, "-xassembler", "-c", NULL
);
375 if (force_pointer_size
)
376 strarray_add_one( args
, (force_pointer_size
== 8) ? "-m64" : "-m32" );
378 else if (force_pointer_size
)
380 switch (target_platform
)
383 strarray_add( args
, "-arch", (force_pointer_size
== 8) ? "x86_64" : "i386", NULL
);
389 strarray_add_one( args
, (force_pointer_size
== 8) ? "-a64" : "-a32" );
392 strarray_add_one( args
, (force_pointer_size
== 8) ? "--64" : "--32" );
399 if (cpu_option
) strarray_add_one( args
, strmake("-mcpu=%s", cpu_option
) );
403 struct strarray
*get_ld_command(void)
405 struct strarray
*args
= strarray_init();
409 static const char * const commands
[] = { "ld", "gld", NULL
};
410 ld_command
= find_tool( "ld", commands
);
414 fatal_error( "cannot find suitable linker\n" );
416 strarray_add_one( args
, ld_command
);
418 if (force_pointer_size
)
420 switch (target_platform
)
423 strarray_add( args
, "-arch", (force_pointer_size
== 8) ? "x86_64" : "i386", NULL
);
425 case PLATFORM_FREEBSD
:
426 strarray_add( args
, "-m", (force_pointer_size
== 8) ? "elf_x86_64_fbsd" : "elf_i386_fbsd", NULL
);
432 strarray_add( args
, "-m", (force_pointer_size
== 8) ? "elf64ppc" : "elf32ppc", NULL
);
435 strarray_add( args
, "-m", (force_pointer_size
== 8) ? "elf_x86_64" : "elf_i386", NULL
);
444 const char *get_nm_command(void)
448 static const char * const commands
[] = { "nm", "gnm", NULL
};
449 nm_command
= find_tool( "nm", commands
);
453 fatal_error( "cannot find suitable name lister\n" );
457 /* get a name for a temp file, automatically cleaned up on exit */
458 char *get_temp_file_name( const char *prefix
, const char *suffix
)
461 const char *ext
, *basename
;
464 if (!nb_tmp_files
&& !save_temps
) atexit( cleanup_tmp_files
);
466 if (!prefix
|| !prefix
[0]) prefix
= "winebuild";
467 if (!suffix
) suffix
= "";
468 if ((basename
= strrchr( prefix
, '/' ))) basename
++;
469 else basename
= prefix
;
470 if (!(ext
= strchr( basename
, '.' ))) ext
= prefix
+ strlen(prefix
);
471 name
= xmalloc( sizeof("/tmp/") + (ext
- prefix
) + sizeof(".XXXXXX") + strlen(suffix
) );
472 memcpy( name
, prefix
, ext
- prefix
);
473 strcpy( name
+ (ext
- prefix
), ".XXXXXX" );
474 strcat( name
, suffix
);
476 if ((fd
= mkstemps( name
, strlen(suffix
) )) == -1)
478 strcpy( name
, "/tmp/" );
479 memcpy( name
+ 5, basename
, ext
- basename
);
480 strcpy( name
+ 5 + (ext
- basename
), ".XXXXXX" );
481 strcat( name
, suffix
);
482 if ((fd
= mkstemps( name
, strlen(suffix
) )) == -1)
483 fatal_error( "could not generate a temp file\n" );
487 if (nb_tmp_files
>= max_tmp_files
)
489 max_tmp_files
= max( 2 * max_tmp_files
, 8 );
490 tmp_files
= xrealloc( tmp_files
, max_tmp_files
* sizeof(tmp_files
[0]) );
492 tmp_files
[nb_tmp_files
++] = name
;
496 /*******************************************************************
499 * Function for reading from/writing to a memory buffer.
502 int byte_swapped
= 0;
503 const char *input_buffer_filename
;
504 const unsigned char *input_buffer
;
505 size_t input_buffer_pos
;
506 size_t input_buffer_size
;
507 unsigned char *output_buffer
;
508 size_t output_buffer_pos
;
509 size_t output_buffer_size
;
511 static void check_output_buffer_space( size_t size
)
513 if (output_buffer_pos
+ size
>= output_buffer_size
)
515 output_buffer_size
= max( output_buffer_size
* 2, output_buffer_pos
+ size
);
516 output_buffer
= xrealloc( output_buffer
, output_buffer_size
);
520 void init_input_buffer( const char *file
)
525 if ((fd
= open( file
, O_RDONLY
| O_BINARY
)) == -1) fatal_perror( "Cannot open %s", file
);
526 if ((fstat( fd
, &st
) == -1)) fatal_perror( "Cannot stat %s", file
);
527 if (!st
.st_size
) fatal_error( "%s is an empty file\n", file
);
529 if ((input_buffer
= mmap( NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0 )) == (void*)-1)
532 unsigned char *buffer
= xmalloc( st
.st_size
);
533 if (read( fd
, buffer
, st
.st_size
) != st
.st_size
) fatal_error( "Cannot read %s\n", file
);
534 input_buffer
= buffer
;
537 input_buffer_filename
= xstrdup( file
);
538 input_buffer_size
= st
.st_size
;
539 input_buffer_pos
= 0;
543 void init_output_buffer(void)
545 output_buffer_size
= 1024;
546 output_buffer_pos
= 0;
547 output_buffer
= xmalloc( output_buffer_size
);
550 void flush_output_buffer(void)
552 if (fwrite( output_buffer
, 1, output_buffer_pos
, output_file
) != output_buffer_pos
)
553 fatal_error( "Error writing to %s\n", output_file_name
);
554 free( output_buffer
);
557 unsigned char get_byte(void)
559 if (input_buffer_pos
>= input_buffer_size
)
560 fatal_error( "%s is a truncated file\n", input_buffer_filename
);
561 return input_buffer
[input_buffer_pos
++];
564 unsigned short get_word(void)
568 if (input_buffer_pos
+ sizeof(ret
) > input_buffer_size
)
569 fatal_error( "%s is a truncated file\n", input_buffer_filename
);
570 memcpy( &ret
, input_buffer
+ input_buffer_pos
, sizeof(ret
) );
571 if (byte_swapped
) ret
= (ret
<< 8) | (ret
>> 8);
572 input_buffer_pos
+= sizeof(ret
);
576 unsigned int get_dword(void)
580 if (input_buffer_pos
+ sizeof(ret
) > input_buffer_size
)
581 fatal_error( "%s is a truncated file\n", input_buffer_filename
);
582 memcpy( &ret
, input_buffer
+ input_buffer_pos
, sizeof(ret
) );
584 ret
= ((ret
<< 24) | ((ret
<< 8) & 0x00ff0000) | ((ret
>> 8) & 0x0000ff00) | (ret
>> 24));
585 input_buffer_pos
+= sizeof(ret
);
589 void put_data( const void *data
, size_t size
)
591 check_output_buffer_space( size
);
592 memcpy( output_buffer
+ output_buffer_pos
, data
, size
);
593 output_buffer_pos
+= size
;
596 void put_byte( unsigned char val
)
598 check_output_buffer_space( 1 );
599 output_buffer
[output_buffer_pos
++] = val
;
602 void put_word( unsigned short val
)
604 if (byte_swapped
) val
= (val
<< 8) | (val
>> 8);
605 put_data( &val
, sizeof(val
) );
608 void put_dword( unsigned int val
)
611 val
= ((val
<< 24) | ((val
<< 8) & 0x00ff0000) | ((val
>> 8) & 0x0000ff00) | (val
>> 24));
612 put_data( &val
, sizeof(val
) );
615 void put_qword( unsigned int val
)
629 /* pointer-sized word */
630 void put_pword( unsigned int val
)
632 if (get_ptr_size() == 8) put_qword( val
);
633 else put_dword( val
);
636 void align_output( unsigned int align
)
638 size_t size
= align
- (output_buffer_pos
% align
);
640 if (size
== align
) return;
641 check_output_buffer_space( size
);
642 memset( output_buffer
+ output_buffer_pos
, 0, size
);
643 output_buffer_pos
+= size
;
646 /* output a standard header for generated files */
647 void output_standard_file_header(void)
650 output( "/* File generated automatically from %s; do not edit! */\n", spec_file_name
);
652 output( "/* File generated automatically; do not edit! */\n" );
653 output( "/* This file can be copied, modified and distributed without restriction. */\n\n" );
656 /* dump a byte stream into the assembly code */
657 void dump_bytes( const void *buffer
, unsigned int size
)
660 const unsigned char *ptr
= buffer
;
663 output( "\t.byte " );
664 for (i
= 0; i
< size
- 1; i
++, ptr
++)
666 if ((i
% 16) == 15) output( "0x%02x\n\t.byte ", *ptr
);
667 else output( "0x%02x,", *ptr
);
669 output( "0x%02x\n", *ptr
);
673 /*******************************************************************
676 * Open a file in the given srcdir and set the input_file_name global variable.
678 FILE *open_input_file( const char *srcdir
, const char *name
)
681 FILE *file
= fopen( name
, "r" );
685 fullname
= strmake( "%s/%s", srcdir
, name
);
686 file
= fopen( fullname
, "r" );
688 else fullname
= xstrdup( name
);
690 if (!file
) fatal_error( "Cannot open file '%s'\n", fullname
);
691 input_file_name
= fullname
;
697 /*******************************************************************
700 * Close the current input file (must have been opened with open_input_file).
702 void close_input_file( FILE *file
)
705 free( input_file_name
);
706 input_file_name
= NULL
;
711 /*******************************************************************
712 * remove_stdcall_decoration
714 * Remove a possible @xx suffix from a function name.
715 * Return the numerical value of the suffix, or -1 if none.
717 int remove_stdcall_decoration( char *name
)
719 char *p
, *end
= strrchr( name
, '@' );
720 if (!end
|| !end
[1] || end
== name
) return -1;
721 if (target_cpu
!= CPU_x86
) return -1;
722 /* make sure all the rest is digits */
723 for (p
= end
+ 1; *p
; p
++) if (!isdigit(*p
)) return -1;
725 return atoi( end
+ 1 );
729 /*******************************************************************
732 * Run a file through the assembler.
734 void assemble_file( const char *src_file
, const char *obj_file
)
736 struct strarray
*args
= get_as_command();
737 strarray_add( args
, "-o", obj_file
, src_file
, NULL
);
739 strarray_free( args
);
743 /*******************************************************************
746 * Create a new dll spec file descriptor
748 DLLSPEC
*alloc_dll_spec(void)
752 spec
= xmalloc( sizeof(*spec
) );
753 spec
->file_name
= NULL
;
754 spec
->dll_name
= NULL
;
755 spec
->init_func
= NULL
;
756 spec
->main_module
= NULL
;
757 spec
->type
= SPEC_WIN32
;
758 spec
->base
= MAX_ORDINALS
;
760 spec
->stack_size
= 0;
762 spec
->nb_entry_points
= 0;
763 spec
->alloc_entry_points
= 0;
765 spec
->nb_resources
= 0;
766 spec
->characteristics
= IMAGE_FILE_EXECUTABLE_IMAGE
;
767 if (get_ptr_size() > 4)
768 spec
->characteristics
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
770 spec
->characteristics
|= IMAGE_FILE_32BIT_MACHINE
;
771 spec
->dll_characteristics
= IMAGE_DLLCHARACTERISTICS_NX_COMPAT
;
773 spec
->subsystem_major
= 4;
774 spec
->subsystem_minor
= 0;
775 spec
->entry_points
= NULL
;
777 spec
->ordinals
= NULL
;
778 spec
->resources
= NULL
;
783 /*******************************************************************
786 * Free dll spec file descriptor
788 void free_dll_spec( DLLSPEC
*spec
)
792 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
794 ORDDEF
*odp
= &spec
->entry_points
[i
];
796 free( odp
->export_name
);
797 free( odp
->link_name
);
799 free( spec
->file_name
);
800 free( spec
->dll_name
);
801 free( spec
->init_func
);
802 free( spec
->entry_points
);
804 free( spec
->ordinals
);
805 free( spec
->resources
);
810 /*******************************************************************
813 * Map a string to a valid C identifier.
815 const char *make_c_identifier( const char *str
)
817 static char buffer
[256];
820 for (p
= buffer
; *str
&& p
< buffer
+sizeof(buffer
)-1; p
++, str
++)
822 if (isalnum(*str
)) *p
= *str
;
830 /*******************************************************************
833 * Generate an internal name for a stub entry point.
835 const char *get_stub_name( const ORDDEF
*odp
, const DLLSPEC
*spec
)
840 if (odp
->name
|| odp
->export_name
)
843 buffer
= strmake( "__wine_stub_%s", odp
->name
? odp
->name
: odp
->export_name
);
844 /* make sure name is a legal C identifier */
845 for (p
= buffer
; *p
; p
++) if (!isalnum(*p
) && *p
!= '_') break;
846 if (!*p
) return buffer
;
849 buffer
= strmake( "__wine_stub_%s_%d", make_c_identifier(spec
->file_name
), odp
->ordinal
);
853 /* parse a cpu name and return the corresponding value */
854 enum target_cpu
get_cpu_from_name( const char *name
)
858 for (i
= 0; i
< sizeof(cpu_names
)/sizeof(cpu_names
[0]); i
++)
859 if (!strcmp( cpu_names
[i
].name
, name
)) return cpu_names
[i
].cpu
;
863 /*****************************************************************
864 * Function: get_alignment
867 * According to the info page for gas, the .align directive behaves
868 * differently on different systems. On some architectures, the
869 * argument of a .align directive is the number of bytes to pad to, so
870 * to align on an 8-byte boundary you'd say
872 * On other systems, the argument is "the number of low-order zero bits
873 * that the location counter must have after advancement." So to
874 * align on an 8-byte boundary you'd say
877 * The reason gas is written this way is that it's trying to mimick
878 * native assemblers for the various architectures it runs on. gas
879 * provides other directives that work consistently across
880 * architectures, but of course we want to work on all arches with or
881 * without gas. Hence this function.
885 * align -- the number of bytes to align to. Must be a power of 2.
887 unsigned int get_alignment(unsigned int align
)
891 assert( !(align
& (align
- 1)) );
898 if (target_platform
!= PLATFORM_APPLE
) return align
;
904 while ((1u << n
) != align
) n
++;
912 /* return the page size for the target CPU */
913 unsigned int get_page_size(void)
917 case CPU_x86
: return 4096;
918 case CPU_x86_64
: return 4096;
919 case CPU_POWERPC
: return 4096;
920 case CPU_ARM
: return 4096;
921 case CPU_ARM64
: return 4096;
922 case CPU_SPARC
: return 8192;
929 /* return the size of a pointer on the target CPU */
930 unsigned int get_ptr_size(void)
948 /* return the total size in bytes of the arguments on the stack */
949 unsigned int get_args_size( const ORDDEF
*odp
)
953 for (i
= size
= 0; i
< odp
->u
.func
.nb_args
; i
++)
955 switch (odp
->u
.func
.args
[i
])
962 /* int128 is passed as pointer on x86_64 */
963 if (target_cpu
!= CPU_x86_64
)
970 size
+= get_ptr_size();
977 /* return the assembly name for a C symbol */
978 const char *asm_name( const char *sym
)
982 switch (target_platform
)
985 case PLATFORM_WINDOWS
:
986 if (sym
[0] == '.' && sym
[1] == 'L') return sym
;
988 buffer
= strmake( "_%s", sym
);
995 /* return an assembly function declaration for a C function name */
996 const char *func_declaration( const char *func
)
1000 switch (target_platform
)
1002 case PLATFORM_APPLE
:
1004 case PLATFORM_WINDOWS
:
1006 buffer
= strmake( ".def _%s; .scl 2; .type 32; .endef", func
);
1014 buffer
= strmake( ".type %s,%%function", func
);
1017 buffer
= strmake( ".type %s,@function", func
);
1025 /* output a size declaration for an assembly function */
1026 void output_function_size( const char *name
)
1028 switch (target_platform
)
1030 case PLATFORM_APPLE
:
1031 case PLATFORM_WINDOWS
:
1034 output( "\t.size %s, .-%s\n", name
, name
);
1039 /* output a .cfi directive */
1040 void output_cfi( const char *format
, ... )
1044 if (!unwind_tables
) return;
1045 va_start( valist
, format
);
1046 fputc( '\t', output_file
);
1047 vfprintf( output_file
, format
, valist
);
1048 fputc( '\n', output_file
);
1052 /* output the GNU note for non-exec stack */
1053 void output_gnu_stack_note(void)
1055 switch (target_platform
)
1057 case PLATFORM_WINDOWS
:
1058 case PLATFORM_APPLE
:
1065 output( "\t.section .note.GNU-stack,\"\",%%progbits\n" );
1068 output( "\t.section .note.GNU-stack,\"\",@progbits\n" );
1075 /* return a global symbol declaration for an assembly symbol */
1076 const char *asm_globl( const char *func
)
1078 static char *buffer
;
1081 switch (target_platform
)
1083 case PLATFORM_APPLE
:
1084 buffer
= strmake( "\t.globl _%s\n\t.private_extern _%s\n_%s:", func
, func
, func
);
1086 case PLATFORM_WINDOWS
:
1087 buffer
= strmake( "\t.globl _%s\n_%s:", func
, func
);
1090 buffer
= strmake( "\t.globl %s\n\t.hidden %s\n%s:", func
, func
, func
);
1096 const char *get_asm_ptr_keyword(void)
1098 switch(get_ptr_size())
1100 case 4: return ".long";
1101 case 8: return ".quad";
1107 const char *get_asm_string_keyword(void)
1109 switch (target_platform
)
1111 case PLATFORM_APPLE
:
1118 const char *get_asm_short_keyword(void)
1120 switch (target_platform
)
1122 default: return ".short";
1126 const char *get_asm_rodata_section(void)
1128 switch (target_platform
)
1130 case PLATFORM_APPLE
: return ".const";
1131 default: return ".section .rodata";
1135 const char *get_asm_string_section(void)
1137 switch (target_platform
)
1139 case PLATFORM_APPLE
: return ".cstring";
1140 default: return ".section .rodata";