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 #if defined(_WIN32) && !defined(__CYGWIN__)
43 # define PATH_SEPARATOR ';'
45 # define PATH_SEPARATOR ':'
48 static const char **tmp_files
;
49 static unsigned int nb_tmp_files
;
50 static unsigned int max_tmp_files
;
63 { "amd64", CPU_x86_64
},
64 { "x86_64", CPU_x86_64
},
65 { "powerpc", CPU_POWERPC
},
70 { "arm64", CPU_ARM64
},
71 { "aarch64", CPU_ARM64
},
74 /* atexit handler to clean tmp files */
75 void cleanup_tmp_files(void)
78 for (i
= 0; i
< nb_tmp_files
; i
++) if (tmp_files
[i
]) unlink( tmp_files
[i
] );
82 void *xmalloc (size_t size
)
86 res
= malloc (size
? size
: 1);
89 fprintf (stderr
, "Virtual memory exhausted.\n");
95 void *xrealloc (void *ptr
, size_t size
)
97 void *res
= realloc (ptr
, size
);
98 if (size
&& res
== NULL
)
100 fprintf (stderr
, "Virtual memory exhausted.\n");
106 char *xstrdup( const char *str
)
108 char *res
= strdup( str
);
111 fprintf (stderr
, "Virtual memory exhausted.\n");
117 char *strupper(char *s
)
120 for (p
= s
; *p
; p
++) *p
= toupper(*p
);
124 int strendswith(const char* str
, const char* end
)
128 return l
>= m
&& strcmp(str
+ l
- m
, end
) == 0;
131 char *strmake( const char* fmt
, ... )
139 char *p
= xmalloc( size
);
141 n
= vsnprintf( p
, size
, fmt
, ap
);
143 if (n
== -1) size
*= 2;
144 else if ((size_t)n
>= size
) size
= n
+ 1;
150 static struct strarray
*strarray_init( const char *str
)
152 struct strarray
*array
= xmalloc( sizeof(*array
) );
155 array
->str
= xmalloc( array
->max
* sizeof(*array
->str
) );
156 if (str
) array
->str
[array
->count
++] = str
;
160 static struct strarray
*strarray_copy( const struct strarray
*src
)
162 struct strarray
*array
= xmalloc( sizeof(*array
) );
163 array
->count
= src
->count
;
164 array
->max
= src
->max
;
165 array
->str
= xmalloc( array
->max
* sizeof(*array
->str
) );
166 memcpy( array
->str
, src
->str
, array
->count
* sizeof(*array
->str
) );
170 static void strarray_add_one( struct strarray
*array
, const char *str
)
172 if (array
->count
== array
->max
)
175 array
->str
= xrealloc( array
->str
, array
->max
* sizeof(*array
->str
) );
177 array
->str
[array
->count
++] = str
;
180 void strarray_add( struct strarray
*array
, ... )
185 va_start( valist
, array
);
186 while ((str
= va_arg( valist
, const char *))) strarray_add_one( array
, str
);
190 void strarray_addv( struct strarray
*array
, char * const *argv
)
192 while (*argv
) strarray_add_one( array
, *argv
++ );
195 struct strarray
*strarray_fromstring( const char *str
, const char *delim
)
198 struct strarray
*array
= strarray_init( NULL
);
199 char *buf
= strdup( str
);
201 for (tok
= strtok( buf
, delim
); tok
; tok
= strtok( NULL
, delim
))
202 strarray_add_one( array
, strdup( tok
));
208 void strarray_free( struct strarray
*array
)
214 void fatal_error( const char *msg
, ... )
217 va_start( valist
, msg
);
220 fprintf( stderr
, "%s:", input_file_name
);
222 fprintf( stderr
, "%d:", current_line
);
223 fputc( ' ', stderr
);
225 else fprintf( stderr
, "winebuild: " );
226 vfprintf( stderr
, msg
, valist
);
231 void fatal_perror( const char *msg
, ... )
234 va_start( valist
, msg
);
237 fprintf( stderr
, "%s:", input_file_name
);
239 fprintf( stderr
, "%d:", current_line
);
240 fputc( ' ', stderr
);
242 vfprintf( stderr
, msg
, valist
);
248 void error( const char *msg
, ... )
251 va_start( valist
, msg
);
254 fprintf( stderr
, "%s:", input_file_name
);
256 fprintf( stderr
, "%d:", current_line
);
257 fputc( ' ', stderr
);
259 vfprintf( stderr
, msg
, valist
);
264 void warning( const char *msg
, ... )
268 if (!display_warnings
) return;
269 va_start( valist
, msg
);
272 fprintf( stderr
, "%s:", input_file_name
);
274 fprintf( stderr
, "%d:", current_line
);
275 fputc( ' ', stderr
);
277 fprintf( stderr
, "warning: " );
278 vfprintf( stderr
, msg
, valist
);
282 int output( const char *format
, ... )
287 va_start( valist
, format
);
288 ret
= vfprintf( output_file
, format
, valist
);
290 if (ret
< 0) fatal_perror( "Output error" );
294 void spawn( struct strarray
*args
)
299 strarray_add_one( args
, NULL
);
301 for (i
= 0; args
->str
[i
]; i
++)
302 fprintf( stderr
, "%s%c", args
->str
[i
], args
->str
[i
+1] ? ' ' : '\n' );
304 if ((status
= _spawnvp( _P_WAIT
, args
->str
[0], args
->str
)))
306 if (status
> 0) fatal_error( "%s failed with status %u\n", args
->str
[0], status
);
307 else fatal_perror( "winebuild" );
312 /* find a build tool in the path, trying the various names */
313 struct strarray
*find_tool( const char *name
, const char * const *names
)
316 static unsigned int count
, maxlen
;
319 const char *alt_names
[2];
327 /* split the path in directories */
329 if (!getenv( "PATH" )) fatal_error( "PATH not set, cannot find required tools\n" );
330 path
= xstrdup( getenv( "PATH" ));
331 for (p
= path
, count
= 2; *p
; p
++) if (*p
== PATH_SEPARATOR
) count
++;
332 dirs
= xmalloc( count
* sizeof(*dirs
) );
334 dirs
[count
++] = p
= path
;
337 while (*p
&& *p
!= PATH_SEPARATOR
) p
++;
342 for (i
= 0; i
< count
; i
++) maxlen
= max( maxlen
, strlen(dirs
[i
])+2 );
354 len
= strlen(*names
) + sizeof(EXEEXT
) + 1;
356 len
+= strlen(target_alias
) + 1;
357 file
= xmalloc( maxlen
+ len
);
359 for (i
= 0; i
< count
; i
++)
361 strcpy( file
, dirs
[i
] );
362 p
= file
+ strlen(file
);
363 if (p
== file
) *p
++ = '.';
364 if (p
[-1] != '/') *p
++ = '/';
367 strcpy( p
, target_alias
);
374 if (!stat( file
, &st
) && S_ISREG(st
.st_mode
) && (st
.st_mode
& 0111))
375 return strarray_init( file
);
380 fatal_error( "cannot find the '%s' tool\n", name
);
383 struct strarray
*get_as_command(void)
385 struct strarray
*args
;
389 args
= strarray_copy( cc_command
);
390 strarray_add( args
, "-xassembler", "-c", NULL
);
391 if (force_pointer_size
)
392 strarray_add_one( args
, (force_pointer_size
== 8) ? "-m64" : "-m32" );
393 if (cpu_option
) strarray_add_one( args
, strmake("-mcpu=%s", cpu_option
) );
394 if (arch_option
) strarray_add_one( args
, strmake("-march=%s", arch_option
) );
400 static const char * const commands
[] = { "gas", "as", NULL
};
401 as_command
= find_tool( "as", commands
);
404 args
= strarray_copy( as_command
);
406 if (force_pointer_size
)
408 switch (target_platform
)
411 strarray_add( args
, "-arch", (force_pointer_size
== 8) ? "x86_64" : "i386", NULL
);
417 strarray_add_one( args
, (force_pointer_size
== 8) ? "-a64" : "-a32" );
420 strarray_add_one( args
, (force_pointer_size
== 8) ? "--64" : "--32" );
427 if (cpu_option
) strarray_add_one( args
, strmake("-mcpu=%s", cpu_option
) );
431 struct strarray
*get_ld_command(void)
433 struct strarray
*args
;
437 static const char * const commands
[] = { "ld", "gld", NULL
};
438 ld_command
= find_tool( "ld", commands
);
441 args
= strarray_copy( ld_command
);
443 if (force_pointer_size
)
445 switch (target_platform
)
448 strarray_add( args
, "-arch", (force_pointer_size
== 8) ? "x86_64" : "i386", NULL
);
450 case PLATFORM_FREEBSD
:
451 strarray_add( args
, "-m", (force_pointer_size
== 8) ? "elf_x86_64_fbsd" : "elf_i386_fbsd", NULL
);
457 strarray_add( args
, "-m", (force_pointer_size
== 8) ? "elf64ppc" : "elf32ppc", NULL
);
460 strarray_add( args
, "-m", (force_pointer_size
== 8) ? "elf_x86_64" : "elf_i386", NULL
);
469 const char *get_nm_command(void)
473 static const char * const commands
[] = { "nm", "gnm", NULL
};
474 nm_command
= find_tool( "nm", commands
);
476 if (nm_command
->count
> 1)
477 fatal_error( "multiple arguments in nm command not supported yet\n" );
478 return nm_command
->str
[0];
481 /* get a name for a temp file, automatically cleaned up on exit */
482 char *get_temp_file_name( const char *prefix
, const char *suffix
)
485 const char *ext
, *basename
;
488 if (!prefix
|| !prefix
[0]) prefix
= "winebuild";
489 if (!suffix
) suffix
= "";
490 if ((basename
= strrchr( prefix
, '/' ))) basename
++;
491 else basename
= prefix
;
492 if (!(ext
= strchr( basename
, '.' ))) ext
= prefix
+ strlen(prefix
);
493 name
= xmalloc( sizeof("/tmp/") + (ext
- prefix
) + sizeof(".XXXXXX") + strlen(suffix
) );
494 memcpy( name
, prefix
, ext
- prefix
);
495 strcpy( name
+ (ext
- prefix
), ".XXXXXX" );
496 strcat( name
, suffix
);
498 if ((fd
= mkstemps( name
, strlen(suffix
) )) == -1)
500 strcpy( name
, "/tmp/" );
501 memcpy( name
+ 5, basename
, ext
- basename
);
502 strcpy( name
+ 5 + (ext
- basename
), ".XXXXXX" );
503 strcat( name
, suffix
);
504 if ((fd
= mkstemps( name
, strlen(suffix
) )) == -1)
505 fatal_error( "could not generate a temp file\n" );
509 if (nb_tmp_files
>= max_tmp_files
)
511 max_tmp_files
= max( 2 * max_tmp_files
, 8 );
512 tmp_files
= xrealloc( tmp_files
, max_tmp_files
* sizeof(tmp_files
[0]) );
514 tmp_files
[nb_tmp_files
++] = name
;
518 /*******************************************************************
521 * Function for reading from/writing to a memory buffer.
524 int byte_swapped
= 0;
525 const char *input_buffer_filename
;
526 const unsigned char *input_buffer
;
527 size_t input_buffer_pos
;
528 size_t input_buffer_size
;
529 unsigned char *output_buffer
;
530 size_t output_buffer_pos
;
531 size_t output_buffer_size
;
533 static void check_output_buffer_space( size_t size
)
535 if (output_buffer_pos
+ size
>= output_buffer_size
)
537 output_buffer_size
= max( output_buffer_size
* 2, output_buffer_pos
+ size
);
538 output_buffer
= xrealloc( output_buffer
, output_buffer_size
);
542 void init_input_buffer( const char *file
)
547 if ((fd
= open( file
, O_RDONLY
| O_BINARY
)) == -1) fatal_perror( "Cannot open %s", file
);
548 if ((fstat( fd
, &st
) == -1)) fatal_perror( "Cannot stat %s", file
);
549 if (!st
.st_size
) fatal_error( "%s is an empty file\n", file
);
551 if ((input_buffer
= mmap( NULL
, st
.st_size
, PROT_READ
, MAP_PRIVATE
, fd
, 0 )) == (void*)-1)
554 unsigned char *buffer
= xmalloc( st
.st_size
);
555 if (read( fd
, buffer
, st
.st_size
) != st
.st_size
) fatal_error( "Cannot read %s\n", file
);
556 input_buffer
= buffer
;
559 input_buffer_filename
= xstrdup( file
);
560 input_buffer_size
= st
.st_size
;
561 input_buffer_pos
= 0;
565 void init_output_buffer(void)
567 output_buffer_size
= 1024;
568 output_buffer_pos
= 0;
569 output_buffer
= xmalloc( output_buffer_size
);
572 void flush_output_buffer(void)
574 if (fwrite( output_buffer
, 1, output_buffer_pos
, output_file
) != output_buffer_pos
)
575 fatal_error( "Error writing to %s\n", output_file_name
);
576 free( output_buffer
);
579 unsigned char get_byte(void)
581 if (input_buffer_pos
>= input_buffer_size
)
582 fatal_error( "%s is a truncated file\n", input_buffer_filename
);
583 return input_buffer
[input_buffer_pos
++];
586 unsigned short get_word(void)
590 if (input_buffer_pos
+ sizeof(ret
) > input_buffer_size
)
591 fatal_error( "%s is a truncated file\n", input_buffer_filename
);
592 memcpy( &ret
, input_buffer
+ input_buffer_pos
, sizeof(ret
) );
593 if (byte_swapped
) ret
= (ret
<< 8) | (ret
>> 8);
594 input_buffer_pos
+= sizeof(ret
);
598 unsigned int get_dword(void)
602 if (input_buffer_pos
+ sizeof(ret
) > input_buffer_size
)
603 fatal_error( "%s is a truncated file\n", input_buffer_filename
);
604 memcpy( &ret
, input_buffer
+ input_buffer_pos
, sizeof(ret
) );
606 ret
= ((ret
<< 24) | ((ret
<< 8) & 0x00ff0000) | ((ret
>> 8) & 0x0000ff00) | (ret
>> 24));
607 input_buffer_pos
+= sizeof(ret
);
611 void put_data( const void *data
, size_t size
)
613 check_output_buffer_space( size
);
614 memcpy( output_buffer
+ output_buffer_pos
, data
, size
);
615 output_buffer_pos
+= size
;
618 void put_byte( unsigned char val
)
620 check_output_buffer_space( 1 );
621 output_buffer
[output_buffer_pos
++] = val
;
624 void put_word( unsigned short val
)
626 if (byte_swapped
) val
= (val
<< 8) | (val
>> 8);
627 put_data( &val
, sizeof(val
) );
630 void put_dword( unsigned int val
)
633 val
= ((val
<< 24) | ((val
<< 8) & 0x00ff0000) | ((val
>> 8) & 0x0000ff00) | (val
>> 24));
634 put_data( &val
, sizeof(val
) );
637 void put_qword( unsigned int val
)
651 /* pointer-sized word */
652 void put_pword( unsigned int val
)
654 if (get_ptr_size() == 8) put_qword( val
);
655 else put_dword( val
);
658 void align_output( unsigned int align
)
660 size_t size
= align
- (output_buffer_pos
% align
);
662 if (size
== align
) return;
663 check_output_buffer_space( size
);
664 memset( output_buffer
+ output_buffer_pos
, 0, size
);
665 output_buffer_pos
+= size
;
668 /* output a standard header for generated files */
669 void output_standard_file_header(void)
672 output( "/* File generated automatically from %s; do not edit! */\n", spec_file_name
);
674 output( "/* File generated automatically; do not edit! */\n" );
675 output( "/* This file can be copied, modified and distributed without restriction. */\n\n" );
678 /* dump a byte stream into the assembly code */
679 void dump_bytes( const void *buffer
, unsigned int size
)
682 const unsigned char *ptr
= buffer
;
685 output( "\t.byte " );
686 for (i
= 0; i
< size
- 1; i
++, ptr
++)
688 if ((i
% 16) == 15) output( "0x%02x\n\t.byte ", *ptr
);
689 else output( "0x%02x,", *ptr
);
691 output( "0x%02x\n", *ptr
);
695 /*******************************************************************
698 * Open a file in the given srcdir and set the input_file_name global variable.
700 FILE *open_input_file( const char *srcdir
, const char *name
)
703 FILE *file
= fopen( name
, "r" );
707 fullname
= strmake( "%s/%s", srcdir
, name
);
708 file
= fopen( fullname
, "r" );
710 else fullname
= xstrdup( name
);
712 if (!file
) fatal_error( "Cannot open file '%s'\n", fullname
);
713 input_file_name
= fullname
;
719 /*******************************************************************
722 * Close the current input file (must have been opened with open_input_file).
724 void close_input_file( FILE *file
)
727 free( input_file_name
);
728 input_file_name
= NULL
;
733 /*******************************************************************
734 * remove_stdcall_decoration
736 * Remove a possible @xx suffix from a function name.
737 * Return the numerical value of the suffix, or -1 if none.
739 int remove_stdcall_decoration( char *name
)
741 char *p
, *end
= strrchr( name
, '@' );
742 if (!end
|| !end
[1] || end
== name
) return -1;
743 if (target_cpu
!= CPU_x86
) return -1;
744 /* make sure all the rest is digits */
745 for (p
= end
+ 1; *p
; p
++) if (!isdigit(*p
)) return -1;
747 return atoi( end
+ 1 );
751 /*******************************************************************
754 * Run a file through the assembler.
756 void assemble_file( const char *src_file
, const char *obj_file
)
758 struct strarray
*args
= get_as_command();
759 strarray_add( args
, "-o", obj_file
, src_file
, NULL
);
761 strarray_free( args
);
765 /*******************************************************************
768 * Create a new dll spec file descriptor
770 DLLSPEC
*alloc_dll_spec(void)
774 spec
= xmalloc( sizeof(*spec
) );
775 spec
->file_name
= NULL
;
776 spec
->dll_name
= NULL
;
777 spec
->init_func
= NULL
;
778 spec
->main_module
= NULL
;
779 spec
->type
= SPEC_WIN32
;
780 spec
->base
= MAX_ORDINALS
;
782 spec
->stack_size
= 0;
784 spec
->nb_entry_points
= 0;
785 spec
->alloc_entry_points
= 0;
787 spec
->nb_resources
= 0;
788 spec
->characteristics
= IMAGE_FILE_EXECUTABLE_IMAGE
;
789 if (get_ptr_size() > 4)
790 spec
->characteristics
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
792 spec
->characteristics
|= IMAGE_FILE_32BIT_MACHINE
;
793 spec
->dll_characteristics
= IMAGE_DLLCHARACTERISTICS_NX_COMPAT
;
795 spec
->subsystem_major
= 4;
796 spec
->subsystem_minor
= 0;
797 spec
->entry_points
= NULL
;
799 spec
->ordinals
= NULL
;
800 spec
->resources
= NULL
;
805 /*******************************************************************
808 * Free dll spec file descriptor
810 void free_dll_spec( DLLSPEC
*spec
)
814 for (i
= 0; i
< spec
->nb_entry_points
; i
++)
816 ORDDEF
*odp
= &spec
->entry_points
[i
];
818 free( odp
->export_name
);
819 free( odp
->link_name
);
821 free( spec
->file_name
);
822 free( spec
->dll_name
);
823 free( spec
->init_func
);
824 free( spec
->entry_points
);
826 free( spec
->ordinals
);
827 free( spec
->resources
);
832 /*******************************************************************
835 * Map a string to a valid C identifier.
837 const char *make_c_identifier( const char *str
)
839 static char buffer
[256];
842 for (p
= buffer
; *str
&& p
< buffer
+sizeof(buffer
)-1; p
++, str
++)
844 if (isalnum(*str
)) *p
= *str
;
852 /*******************************************************************
855 * Generate an internal name for a stub entry point.
857 const char *get_stub_name( const ORDDEF
*odp
, const DLLSPEC
*spec
)
862 if (odp
->name
|| odp
->export_name
)
865 buffer
= strmake( "__wine_stub_%s", odp
->name
? odp
->name
: odp
->export_name
);
866 /* make sure name is a legal C identifier */
867 for (p
= buffer
; *p
; p
++) if (!isalnum(*p
) && *p
!= '_') break;
868 if (!*p
) return buffer
;
871 buffer
= strmake( "__wine_stub_%s_%d", make_c_identifier(spec
->file_name
), odp
->ordinal
);
875 /* parse a cpu name and return the corresponding value */
876 int get_cpu_from_name( const char *name
)
880 for (i
= 0; i
< sizeof(cpu_names
)/sizeof(cpu_names
[0]); i
++)
881 if (!strcmp( cpu_names
[i
].name
, name
)) return cpu_names
[i
].cpu
;
885 /*****************************************************************
886 * Function: get_alignment
889 * According to the info page for gas, the .align directive behaves
890 * differently on different systems. On some architectures, the
891 * argument of a .align directive is the number of bytes to pad to, so
892 * to align on an 8-byte boundary you'd say
894 * On other systems, the argument is "the number of low-order zero bits
895 * that the location counter must have after advancement." So to
896 * align on an 8-byte boundary you'd say
899 * The reason gas is written this way is that it's trying to mimick
900 * native assemblers for the various architectures it runs on. gas
901 * provides other directives that work consistently across
902 * architectures, but of course we want to work on all arches with or
903 * without gas. Hence this function.
907 * align -- the number of bytes to align to. Must be a power of 2.
909 unsigned int get_alignment(unsigned int align
)
913 assert( !(align
& (align
- 1)) );
919 if (target_platform
!= PLATFORM_APPLE
) return align
;
925 while ((1u << n
) != align
) n
++;
933 /* return the page size for the target CPU */
934 unsigned int get_page_size(void)
951 /* return the size of a pointer on the target CPU */
952 unsigned int get_ptr_size(void)
969 /* return the total size in bytes of the arguments on the stack */
970 unsigned int get_args_size( const ORDDEF
*odp
)
974 for (i
= size
= 0; i
< odp
->u
.func
.nb_args
; i
++)
976 switch (odp
->u
.func
.args
[i
])
983 /* int128 is passed as pointer on x86_64 */
984 if (target_cpu
!= CPU_x86_64
)
991 size
+= get_ptr_size();
998 /* return the assembly name for a C symbol */
999 const char *asm_name( const char *sym
)
1001 static char *buffer
;
1003 switch (target_platform
)
1005 case PLATFORM_APPLE
:
1006 case PLATFORM_WINDOWS
:
1007 if (sym
[0] == '.' && sym
[1] == 'L') return sym
;
1009 buffer
= strmake( "_%s", sym
);
1016 /* return an assembly function declaration for a C function name */
1017 const char *func_declaration( const char *func
)
1019 static char *buffer
;
1021 switch (target_platform
)
1023 case PLATFORM_APPLE
:
1025 case PLATFORM_WINDOWS
:
1027 buffer
= strmake( ".def _%s; .scl 2; .type 32; .endef", func
);
1035 buffer
= strmake( ".type %s,%%function", func
);
1038 buffer
= strmake( ".type %s,@function", func
);
1046 /* output a size declaration for an assembly function */
1047 void output_function_size( const char *name
)
1049 switch (target_platform
)
1051 case PLATFORM_APPLE
:
1052 case PLATFORM_WINDOWS
:
1055 output( "\t.size %s, .-%s\n", name
, name
);
1060 /* output a .cfi directive */
1061 void output_cfi( const char *format
, ... )
1065 if (!unwind_tables
) return;
1066 va_start( valist
, format
);
1067 fputc( '\t', output_file
);
1068 vfprintf( output_file
, format
, valist
);
1069 fputc( '\n', output_file
);
1073 /* output the GNU note for non-exec stack */
1074 void output_gnu_stack_note(void)
1076 switch (target_platform
)
1078 case PLATFORM_WINDOWS
:
1079 case PLATFORM_APPLE
:
1086 output( "\t.section .note.GNU-stack,\"\",%%progbits\n" );
1089 output( "\t.section .note.GNU-stack,\"\",@progbits\n" );
1096 /* return a global symbol declaration for an assembly symbol */
1097 const char *asm_globl( const char *func
)
1099 static char *buffer
;
1102 switch (target_platform
)
1104 case PLATFORM_APPLE
:
1105 buffer
= strmake( "\t.globl _%s\n\t.private_extern _%s\n_%s:", func
, func
, func
);
1107 case PLATFORM_WINDOWS
:
1108 buffer
= strmake( "\t.globl _%s\n_%s:", func
, func
);
1111 buffer
= strmake( "\t.globl %s\n\t.hidden %s\n%s:", func
, func
, func
);
1117 const char *get_asm_ptr_keyword(void)
1119 switch(get_ptr_size())
1121 case 4: return ".long";
1122 case 8: return ".quad";
1128 const char *get_asm_string_keyword(void)
1130 switch (target_platform
)
1132 case PLATFORM_APPLE
:
1139 const char *get_asm_rodata_section(void)
1141 switch (target_platform
)
1143 case PLATFORM_APPLE
: return ".const";
1144 default: return ".section .rodata";
1148 const char *get_asm_string_section(void)
1150 switch (target_platform
)
1152 case PLATFORM_APPLE
: return ".cstring";
1153 default: return ".section .rodata";