OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [gcc/] [testsuite/] [lib/] [target-supports.exp] - Blame information for rev 149

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 149 jeremybenn
#   Copyright (C) 1999, 2001, 2003, 2004, 2005, 2006, 2007
2
#    Free Software Foundation, Inc.
3
 
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 3 of the License, or
7
# (at your option) any later version.
8
#
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
# GNU General Public License for more details.
13
#
14
# You should have received a copy of the GNU General Public License
15
# along with GCC; see the file COPYING3.  If not see
16
# .
17
 
18
# Please email any bugs, comments, and/or additions to this file to:
19
# gcc-patches@gcc.gnu.org
20
 
21
# This file defines procs for determining features supported by the target.
22
 
23
# Try to compile some code and return the messages printed by the compiler,
24
# and optionally the contents for assembly files.  Either a string or
25
# a list of two strings are returned, depending on WANT_OUTPUT.
26
#
27
# BASENAME is a basename to use for temporary files.
28
# WANT_OUTPUT is a flag which is 0 to request returning just the
29
#   compiler messages, or 1 to return the messages and the contents
30
#   of the assembly file.  TYPE should be "assembly" if WANT_OUTPUT
31
#   is set.
32
# TYPE is the type of compilation to perform (see target_compile).
33
# CONTENTS gives the contents of the input file.
34
# The rest is optional:
35
# OPTIONS: additional compiler options to use.
36
proc get_compiler_messages {basename want_output type contents args} {
37
    global tool
38
 
39
    if { [llength $args] > 0 } {
40
        set options [list "additional_flags=[lindex $args 0]"]
41
    } else {
42
        set options ""
43
    }
44
 
45
    set src ${basename}[pid].c
46
    switch $type {
47
        assembly { set output ${basename}[pid].s }
48
        object { set output ${basename}[pid].o }
49
    }
50
    set f [open $src "w"]
51
    puts $f $contents
52
    close $f
53
    set lines [${tool}_target_compile $src $output $type "$options"]
54
    file delete $src
55
 
56
    if { $want_output } {
57
        if { $type != "assembly" } {
58
            error "WANT_OUTPUT can only be used with assembly output"
59
        } elseif { ![string match "" $lines] } {
60
            # An error occurred.
61
            set result [list $lines ""]
62
        } else {
63
            set text ""
64
            set chan [open "$output"]
65
            while {[gets $chan line] >= 0} {
66
                append text "$line\n"
67
            }
68
            close $chan
69
            set result [list $lines $text]
70
        }
71
    } else {
72
        set result $lines
73
    }
74
 
75
    remote_file build delete $output
76
    return $result
77
}
78
 
79
proc current_target_name { } {
80
    global target_info
81
    if [info exists target_info(target,name)] {
82
        set answer $target_info(target,name)
83
    } else {
84
        set answer ""
85
    }
86
    return $answer
87
}
88
 
89
# Implement an effective-target check for property PROP by invoking
90
# the compiler and seeing if it prints any messages.  Assume that the
91
# property holds if the compiler doesn't print anything.  The other
92
# arguments are as for get_compiler_messages, starting with TYPE.
93
proc check_no_compiler_messages {prop args} {
94
    global et_cache
95
 
96
    set target [current_target_name]
97
    if {![info exists et_cache($prop,target)]
98
        || $et_cache($prop,target) != $target} {
99
        verbose "check_no_compiler_messages $prop: compiling source for $target" 2
100
        set et_cache($prop,target) $target
101
        set et_cache($prop,value) \
102
            [string match "" [eval get_compiler_messages $prop 0 $args]]
103
    }
104
    set value $et_cache($prop,value)
105
    verbose "check_no_compiler_messages $prop: returning $value for $target" 2
106
    return $value
107
}
108
 
109
# Similar to check_no_compiler_messages, but also verify that the regular
110
# expression PATTERN matches the compiler's output.
111
proc check_no_messages_and_pattern {prop pattern args} {
112
    global et_cache
113
 
114
    set target [current_target_name]
115
    if {![info exists et_cache($prop,target)]
116
        || $et_cache($prop,target) != $target} {
117
        verbose "check_no_messages_and_pattern $prop: compiling source for $target" 2
118
        set et_cache($prop,target) $target
119
        set results [eval get_compiler_messages $prop 1 $args]
120
        set et_cache($prop,value) \
121
            [expr [string match "" [lindex $results 0]] \
122
                 && [regexp $pattern [lindex $results 1]]]
123
    }
124
    set value $et_cache($prop,value)
125
    verbose "check_no_messages_and_pattern $prop: returning $value for $target" 2
126
    return $value
127
}
128
 
129
###############################
130
# proc check_weak_available { }
131
###############################
132
 
133
# weak symbols are only supported in some configs/object formats
134
# this proc returns 1 if they're supported, 0 if they're not, or -1 if unsure
135
 
136
proc check_weak_available { } {
137
    global target_triplet
138
    global target_cpu
139
 
140
    # All mips targets should support it
141
 
142
    if { [ string first "mips" $target_cpu ] >= 0 } {
143
        return 1
144
    }
145
 
146
    # All solaris2 targets should support it
147
 
148
    if { [regexp ".*-solaris2.*" $target_triplet] } {
149
        return 1
150
    }
151
 
152
    # DEC OSF/1/Digital UNIX/Tru64 UNIX supports it
153
 
154
    if { [regexp "alpha.*osf.*" $target_triplet] } {
155
        return 1
156
    }
157
 
158
    # Windows targets Cygwin and MingW32 support it
159
 
160
    if { [regexp ".*mingw32|.*cygwin" $target_triplet] } {
161
        return 1
162
    }
163
 
164
    # HP-UX 10.X doesn't support it
165
 
166
    if { [istarget "hppa*-*-hpux10*"] } {
167
        return 0
168
    }
169
 
170
    # ELF and ECOFF support it. a.out does with gas/gld but may also with
171
    # other linkers, so we should try it
172
 
173
    set objformat [gcc_target_object_format]
174
 
175
    switch $objformat {
176
        elf      { return 1 }
177
        ecoff    { return 1 }
178
        a.out    { return 1 }
179
        mach-o   { return 1 }
180
        som      { return 1 }
181
        unknown  { return -1 }
182
        default  { return 0 }
183
    }
184
}
185
 
186
###############################
187
# proc check_visibility_available { what_kind }
188
###############################
189
 
190
# The visibility attribute is only support in some object formats
191
# This proc returns 1 if it is supported, 0 if not.
192
# The argument is the kind of visibility, default/protected/hidden/internal.
193
 
194
proc check_visibility_available { what_kind } {
195
    global tool
196
    global target_triplet
197
 
198
    # On NetWare, support makes no sense.
199
    if { [istarget *-*-netware*] } {
200
        return 0
201
    }
202
 
203
    if [string match "" $what_kind] { set what_kind "hidden" }
204
 
205
    return [check_no_compiler_messages visibility_available_$what_kind object "
206
        void f() __attribute__((visibility(\"$what_kind\")));
207
        void f() {}
208
    "]
209
}
210
 
211
###############################
212
# proc check_alias_available { }
213
###############################
214
 
215
# Determine if the target toolchain supports the alias attribute.
216
 
217
# Returns 2 if the target supports aliases.  Returns 1 if the target
218
# only supports weak aliased.  Returns 0 if the target does not
219
# support aliases at all.  Returns -1 if support for aliases could not
220
# be determined.
221
 
222
proc check_alias_available { } {
223
    global alias_available_saved
224
    global tool
225
 
226
    if [info exists alias_available_saved] {
227
        verbose "check_alias_available  returning saved $alias_available_saved" 2
228
    } else {
229
        set src alias[pid].c
230
        set obj alias[pid].o
231
        verbose "check_alias_available  compiling testfile $src" 2
232
        set f [open $src "w"]
233
        # Compile a small test program.  The definition of "g" is
234
        # necessary to keep the Solaris assembler from complaining
235
        # about the program.
236
        puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
237
        puts $f "void g() {} void f() __attribute__((alias(\"g\")));"
238
        close $f
239
        set lines [${tool}_target_compile $src $obj object ""]
240
        file delete $src
241
        remote_file build delete $obj
242
 
243
        if [string match "" $lines] then {
244
            # No error messages, everything is OK.
245
            set alias_available_saved 2
246
        } else {
247
            if [regexp "alias definitions not supported" $lines] {
248
                verbose "check_alias_available  target does not support aliases" 2
249
 
250
                set objformat [gcc_target_object_format]
251
 
252
                if { $objformat == "elf" } {
253
                    verbose "check_alias_available  but target uses ELF format, so it ought to" 2
254
                    set alias_available_saved -1
255
                } else {
256
                    set alias_available_saved 0
257
                }
258
            } else {
259
                if [regexp "only weak aliases are supported" $lines] {
260
                verbose "check_alias_available  target supports only weak aliases" 2
261
                set alias_available_saved 1
262
                } else {
263
                    set alias_available_saved -1
264
                }
265
            }
266
        }
267
 
268
        verbose "check_alias_available  returning $alias_available_saved" 2
269
    }
270
 
271
    return $alias_available_saved
272
}
273
 
274
# Returns true if --gc-sections is supported on the target.
275
 
276
proc check_gc_sections_available { } {
277
    global gc_sections_available_saved
278
    global tool
279
 
280
    if {![info exists gc_sections_available_saved]} {
281
        # Some targets don't support gc-sections despite whatever's
282
        # advertised by ld's options.
283
        if { [istarget alpha*-*-*]
284
             || [istarget ia64-*-*] } {
285
            set gc_sections_available_saved 0
286
            return 0
287
        }
288
 
289
        # Check if the ld used by gcc supports --gc-sections.
290
        set gcc_spec [${tool}_target_compile "-dumpspecs" "" "none" ""]
291
        regsub ".*\n\*linker:\[ \t\]*\n(\[^ \t\n\]*).*" "$gcc_spec" {\1} linker
292
        set gcc_ld [lindex [${tool}_target_compile "-print-prog-name=$linker" "" "none" ""] 0]
293
        set ld_output [remote_exec host "$gcc_ld" "--help"]
294
        if { [ string first "--gc-sections" $ld_output ] >= 0 } {
295
            set gc_sections_available_saved 1
296
        } else {
297
            set gc_sections_available_saved 0
298
        }
299
    }
300
    return $gc_sections_available_saved
301
}
302
 
303
# Return true if profiling is supported on the target.
304
 
305
proc check_profiling_available { test_what } {
306
    global profiling_available_saved
307
 
308
    verbose "Profiling argument is <$test_what>" 1
309
 
310
    # These conditions depend on the argument so examine them before
311
    # looking at the cache variable.
312
 
313
    # Support for -p on solaris2 relies on mcrt1.o which comes with the
314
    # vendor compiler.  We cannot reliably predict the directory where the
315
    # vendor compiler (and thus mcrt1.o) is installed so we can't
316
    # necessarily find mcrt1.o even if we have it.
317
    if { [istarget *-*-solaris2*] && [lindex $test_what 1] == "-p" } {
318
        return 0
319
    }
320
 
321
    # Support for -p on irix relies on libprof1.a which doesn't appear to
322
    # exist on any irix6 system currently posting testsuite results.
323
    # Support for -pg on irix relies on gcrt1.o which doesn't exist yet.
324
    # See: http://gcc.gnu.org/ml/gcc/2002-10/msg00169.html
325
    if { [istarget mips*-*-irix*]
326
    && ([lindex $test_what 1] == "-p" || [lindex $test_what 1] == "-pg") } {
327
        return 0
328
    }
329
 
330
    # At present, there is no profiling support on NetWare.
331
    if { [istarget *-*-netware*] } {
332
        return 0
333
    }
334
 
335
    # Now examine the cache variable.
336
    if {![info exists profiling_available_saved]} {
337
        # Some targets don't have any implementation of __bb_init_func or are
338
        # missing other needed machinery.
339
        if { [istarget mmix-*-*]
340
             || [istarget arm*-*-eabi*]
341
             || [istarget arm*-*-elf]
342
             || [istarget arm*-*-symbianelf*]
343
             || [istarget powerpc-*-eabi*]
344
             || [istarget strongarm*-*-elf]
345
             || [istarget xscale*-*-elf]
346
             || [istarget cris-*-*]
347
             || [istarget h8300-*-*]
348
             || [istarget m32c-*-elf]
349
             || [istarget m68k-*-elf]
350
             || [istarget mips*-*-elf]
351
             || [istarget xtensa-*-elf]
352
             || [istarget *-*-windiss] } {
353
            set profiling_available_saved 0
354
        } else {
355
            set profiling_available_saved 1
356
        }
357
    }
358
 
359
    return $profiling_available_saved
360
}
361
 
362
# Return 1 if target has packed layout of structure members by
363
# default, 0 otherwise.  Note that this is slightly different than
364
# whether the target has "natural alignment": both attributes may be
365
# false.
366
 
367
proc check_effective_target_default_packed { } {
368
    return [check_no_compiler_messages default_packed assembly {
369
        struct x { char a; long b; } c;
370
        int s[sizeof (c) == sizeof (char) + sizeof (long) ? 1 : -1];
371
    }]
372
}
373
 
374
# Return 1 if target has PCC_BITFIELD_TYPE_MATTERS defined.  See
375
# documentation, where the test also comes from.
376
 
377
proc check_effective_target_pcc_bitfield_type_matters { } {
378
    # PCC_BITFIELD_TYPE_MATTERS isn't just about unnamed or empty
379
    # bitfields, but let's stick to the example code from the docs.
380
    return [check_no_compiler_messages pcc_bitfield_type_matters assembly {
381
        struct foo1 { char x; char :0; char y; };
382
        struct foo2 { char x; int :0; char y; };
383
        int s[sizeof (struct foo1) != sizeof (struct foo2) ? 1 : -1];
384
    }]
385
}
386
 
387
# Return 1 if thread local storage (TLS) is supported, 0 otherwise.
388
#
389
# This won't change for different subtargets so cache the result.
390
 
391
proc check_effective_target_tls {} {
392
    global et_tls_saved
393
    global tool
394
 
395
    if [info exists et_tls_saved] {
396
        verbose "check_effective_target_tls: using cached result" 2
397
    } else {
398
        set et_tls_saved 1
399
 
400
        set src tls[pid].c
401
        set asm tls[pid].S
402
        verbose "check_effective_target_tls: compiling testfile $src" 2
403
        set f [open $src "w"]
404
        # Compile a small test program.
405
        puts $f "__thread int i;\n"
406
        close $f
407
 
408
        # Test for thread-local data supported by the platform.
409
        set comp_output \
410
            [${tool}_target_compile $src $asm assembly ""]
411
        file delete $src
412
        if { [string match "*not supported*" $comp_output] } {
413
            set et_tls_saved 0
414
        }
415
        remove-build-file $asm
416
    }
417
    verbose "check_effective_target_tls: returning $et_tls_saved" 2
418
    return $et_tls_saved
419
}
420
 
421
# Return 1 if TLS executables can run correctly, 0 otherwise.
422
#
423
# This won't change for different subtargets so cache the result.
424
 
425
proc check_effective_target_tls_runtime {} {
426
    global et_tls_runtime_saved
427
    global tool
428
 
429
    if [info exists et_tls_runtime_saved] {
430
        verbose "check_effective_target_tls_runtime: using cached result" 2
431
    } else {
432
        set et_tls_runtime_saved 0
433
 
434
        set src tls_runtime[pid].c
435
        set exe tls_runtime[pid].x
436
        verbose "check_effective_target_tls_runtime: compiling testfile $src" 2
437
        set f [open $src "w"]
438
        # Compile a small test program.
439
        puts $f "__thread int thr = 0;\n"
440
        puts $f "int main(void)\n {\n return thr;\n}"
441
        close $f
442
 
443
        set comp_output \
444
            [${tool}_target_compile $src $exe executable ""]
445
        file delete $src
446
 
447
        if [string match "" $comp_output] then {
448
            # No error messages, everything is OK.
449
 
450
            set result [remote_load target "./$exe" "" ""]
451
            set status [lindex $result 0]
452
            remote_file build delete $exe
453
 
454
            verbose "check_effective_target_tls_runtime status is <$status>" 2
455
 
456
            if { $status == "pass" } {
457
                set et_tls_runtime_saved 1
458
            }
459
 
460
            verbose "check_effective_target_tls_runtime: returning $et_tls_runtime_saved" 2
461
        }
462
    }
463
 
464
    return $et_tls_runtime_saved
465
}
466
 
467
# Return 1 if compilation with -fopenmp is error-free for trivial
468
# code, 0 otherwise.
469
 
470
proc check_effective_target_fopenmp {} {
471
    return [check_no_compiler_messages fopenmp object {
472
        void foo (void) { }
473
    } "-fopenmp"]
474
}
475
 
476
# Return 1 if compilation with -freorder-blocks-and-partition is error-free
477
# for trivial code, 0 otherwise.
478
 
479
proc check_effective_target_freorder {} {
480
    return [check_no_compiler_messages freorder object {
481
        void foo (void) { }
482
    } "-freorder-blocks-and-partition"]
483
}
484
 
485
# Return 1 if -fpic and -fPIC are supported, as in no warnings or errors
486
# emitted, 0 otherwise.  Whether a shared library can actually be built is
487
# out of scope for this test.
488
 
489
proc check_effective_target_fpic { } {
490
    # Note that M68K has a multilib that supports -fpic but not
491
    # -fPIC, so we need to check both.  We test with a program that
492
    # requires GOT references.
493
    foreach arg {fpic fPIC} {
494
        if [check_no_compiler_messages $arg object {
495
            extern int foo (void); extern int bar;
496
            int baz (void) { return foo () + bar; }
497
        } "-$arg"] {
498
            return 1
499
        }
500
    }
501
    return 0
502
}
503
 
504
# Return true if the target supports -mpaired-single (as used on MIPS).
505
 
506
proc check_effective_target_mpaired_single { } {
507
    return [check_no_compiler_messages mpaired_single object {
508
        void foo (void) { }
509
    } "-mpaired-single"]
510
}
511
 
512
# Return true if iconv is supported on the target. In particular IBM1047.
513
 
514
proc check_iconv_available { test_what } {
515
    global tool
516
    global libiconv
517
 
518
    set result ""
519
 
520
    set src iconv[pid].c
521
    set exe iconv[pid].x
522
    verbose "check_iconv_available compiling testfile $src" 2
523
    set f [open $src "w"]
524
    # Compile a small test program.
525
    puts $f "#include \n"
526
    puts $f "int main (void)\n {\n iconv_t cd; \n"
527
    puts $f "cd = iconv_open (\"[lindex $test_what 1]\", \"UTF-8\");\n"
528
    puts $f "if (cd == (iconv_t) -1)\n return 1;\n"
529
    puts $f "return 0;\n}"
530
    close $f
531
 
532
    # If the tool configuration file has not set libiconv, try "-liconv"
533
    if { ![info exists libiconv] } {
534
        set libiconv "-liconv"
535
    }
536
    set lines [${tool}_target_compile $src $exe executable "libs=$libiconv" ]
537
    file delete $src
538
 
539
    if [string match "" $lines] then {
540
        # No error messages, everything is OK.
541
 
542
        set result [${tool}_load "./$exe" "" ""]
543
        set status [lindex $result 0]
544
        remote_file build delete $exe
545
 
546
        verbose "check_iconv_available status is <$status>" 2
547
 
548
        if { $status == "pass" } then {
549
            return 1
550
        }
551
    }
552
 
553
    return 0
554
}
555
 
556
# Return true if named sections are supported on this target.
557
 
558
proc check_named_sections_available { } {
559
    return [check_no_compiler_messages named_sections assembly {
560
        int __attribute__ ((section("whatever"))) foo;
561
    }]
562
}
563
 
564
# Return 1 if the target supports Fortran real kinds larger than real(8),
565
# 0 otherwise.
566
#
567
# When the target name changes, replace the cached result.
568
 
569
proc check_effective_target_fortran_large_real { } {
570
    global et_fortran_large_real_saved
571
    global et_fortran_large_real_target_name
572
    global tool
573
 
574
    if { ![info exists et_fortran_large_real_target_name] } {
575
        set et_fortran_large_real_target_name ""
576
    }
577
 
578
    # If the target has changed since we set the cached value, clear it.
579
    set current_target [current_target_name]
580
    if { $current_target != $et_fortran_large_real_target_name } {
581
        verbose "check_effective_target_fortran_large_real: `$et_fortran_large_real_target_name' `$current_target'" 2
582
        set et_fortran_large_real_target_name $current_target
583
        if [info exists et_fortran_large_real_saved] {
584
            verbose "check_effective_target_fortran_large_real: removing cached result" 2
585
            unset et_fortran_large_real_saved
586
        }
587
    }
588
 
589
    if [info exists et_fortran_large_real_saved] {
590
        verbose "check_effective_target_fortran_large_real returning saved $et_fortran_large_real_saved" 2
591
    } else {
592
        set et_fortran_large_real_saved 0
593
 
594
        # Set up, compile, and execute a test program using large real
595
        # kinds.  Include the current process ID in the file names to
596
        # prevent conflicts with invocations for multiple testsuites.
597
        set src real[pid].f90
598
        set exe real[pid].x
599
 
600
        set f [open $src "w"]
601
        puts $f "integer,parameter :: k = &"
602
        puts $f "  selected_real_kind (precision (0.0_8) + 1)"
603
        puts $f "real(kind=k) :: x"
604
        puts $f "x = cos (x);"
605
        puts $f "end"
606
        close $f
607
 
608
        verbose "check_effective_target_fortran_large_real compiling testfile $src" 2
609
        set lines [${tool}_target_compile $src $exe executable ""]
610
        file delete $src
611
 
612
        if [string match "" $lines] then {
613
            # No error message, compilation succeeded.
614
            set et_fortran_large_real_saved 1
615
        }
616
    }
617
 
618
    return $et_fortran_large_real_saved
619
}
620
 
621
# Return 1 if the target supports Fortran integer kinds larger than
622
# integer(8), 0 otherwise.
623
#
624
# When the target name changes, replace the cached result.
625
 
626
proc check_effective_target_fortran_large_int { } {
627
    global et_fortran_large_int_saved
628
    global et_fortran_large_int_target_name
629
    global tool
630
 
631
    if { ![info exists et_fortran_large_int_target_name] } {
632
        set et_fortran_large_int_target_name ""
633
    }
634
 
635
    # If the target has changed since we set the cached value, clear it.
636
    set current_target [current_target_name]
637
    if { $current_target != $et_fortran_large_int_target_name } {
638
        verbose "check_effective_target_fortran_large_int: `$et_fortran_large_int_target_name' `$current_target'" 2
639
        set et_fortran_large_int_target_name $current_target
640
        if [info exists et_fortran_large_int_saved] {
641
            verbose "check_effective_target_fortran_large_int: removing cached result" 2
642
            unset et_fortran_large_int_saved
643
        }
644
    }
645
 
646
    if [info exists et_fortran_large_int_saved] {
647
        verbose "check_effective_target_fortran_large_int returning saved $et_fortran_large_int_saved" 2
648
    } else {
649
        set et_fortran_large_int_saved 0
650
 
651
        # Set up, compile, and execute a test program using large integer
652
        # kinds.  Include the current process ID in the file names to
653
        # prevent conflicts with invocations for multiple testsuites.
654
        set src int[pid].f90
655
        set exe int[pid].x
656
 
657
        set f [open $src "w"]
658
        puts $f "integer,parameter :: k = &"
659
        puts $f "  selected_int_kind (range (0_8) + 1)"
660
        puts $f "integer(kind=k) :: i"
661
        puts $f "end"
662
        close $f
663
 
664
        verbose "check_effective_target_fortran_large_int compiling testfile $src" 2
665
        set lines [${tool}_target_compile $src $exe executable ""]
666
        file delete $src
667
 
668
        if [string match "" $lines] then {
669
            # No error message, compilation succeeded.
670
            set et_fortran_large_int_saved 1
671
        }
672
    }
673
 
674
    return $et_fortran_large_int_saved
675
}
676
 
677
# Return 1 if we can statically link libgfortran, 0 otherwise.
678
#
679
# When the target name changes, replace the cached result.
680
 
681
proc check_effective_target_static_libgfortran { } {
682
    global et_static_libgfortran
683
    global et_static_libgfortran_target_name
684
    global tool
685
 
686
    if { ![info exists et_static_libgfortran_target_name] } {
687
       set et_static_libgfortran_target_name ""
688
    }
689
 
690
    # If the target has changed since we set the cached value, clear it.
691
    set current_target [current_target_name]
692
    if { $current_target != $et_static_libgfortran_target_name } {
693
       verbose "check_effective_target_static_libgfortran: `$et_static_libgfortran_target_name' `$current_target'" 2
694
       set et_static_libgfortran_target_name $current_target
695
       if [info exists et_static_libgfortran_saved] {
696
           verbose "check_effective_target_static_libgfortran: removing cached result" 2
697
           unset et_static_libgfortran_saved
698
       }
699
    }
700
 
701
    if [info exists et_static_libgfortran_saved] {
702
       verbose "check_effective_target_static_libgfortran returning saved $et_static_libgfortran_saved" 2
703
    } else {
704
       set et_static_libgfortran_saved 0
705
 
706
       # Set up, compile, and execute a test program using static linking.
707
       # Include the current process ID in the file names to prevent
708
       # conflicts with invocations for multiple testsuites.
709
       set opts "additional_flags=-static"
710
       set src static[pid].f
711
       set exe static[pid].x
712
 
713
       set f [open $src "w"]
714
       puts $f "      print *, 'test'"
715
       puts $f "      end"
716
       close $f
717
 
718
       verbose "check_effective_target_static_libgfortran compiling testfile $src" 2
719
       set lines [${tool}_target_compile $src $exe executable "$opts"]
720
       file delete $src
721
 
722
       if [string match "" $lines] then {
723
           # No error message, compilation succeeded.
724
           set et_static_libgfortran_saved 1
725
       }
726
    }
727
 
728
    return $et_static_libgfortran_saved
729
}
730
 
731
# Return 1 if the target supports executing AltiVec instructions, 0
732
# otherwise.  Cache the result.
733
 
734
proc check_vmx_hw_available { } {
735
    global vmx_hw_available_saved
736
    global tool
737
 
738
    if [info exists vmx_hw_available_saved] {
739
        verbose "check_hw_available  returning saved $vmx_hw_available_saved" 2
740
    } else {
741
        set vmx_hw_available_saved 0
742
 
743
        # Some simulators are known to not support VMX instructions.
744
        if { [istarget powerpc-*-eabi] || [istarget powerpc*-*-eabispe] } {
745
            verbose "check_hw_available  returning 0" 2
746
            return $vmx_hw_available_saved
747
        }
748
 
749
        # Set up, compile, and execute a test program containing VMX
750
        # instructions.  Include the current process ID in the file
751
        # names to prevent conflicts with invocations for multiple
752
        # testsuites.
753
        set src vmx[pid].c
754
        set exe vmx[pid].x
755
 
756
        set f [open $src "w"]
757
        puts $f "int main() {"
758
        puts $f "#ifdef __MACH__"
759
        puts $f "  asm volatile (\"vor v0,v0,v0\");"
760
        puts $f "#else"
761
        puts $f "  asm volatile (\"vor 0,0,0\");"
762
        puts $f "#endif"
763
        puts $f "  return 0; }"
764
        close $f
765
 
766
        # Most targets don't require special flags for this test case, but
767
        # Darwin does.
768
        if [istarget *-*-darwin*] {
769
          set opts "additional_flags=-maltivec"
770
        } else {
771
          set opts ""
772
        }
773
 
774
        verbose "check_vmx_hw_available  compiling testfile $src" 2
775
        set lines [${tool}_target_compile $src $exe executable "$opts"]
776
        file delete $src
777
 
778
        if [string match "" $lines] then {
779
            # No error message, compilation succeeded.
780
            set result [${tool}_load "./$exe" "" ""]
781
            set status [lindex $result 0]
782
            remote_file build delete $exe
783
            verbose "check_vmx_hw_available testfile status is <$status>" 2
784
 
785
            if { $status == "pass" } then {
786
                set vmx_hw_available_saved 1
787
            }
788
        } else {
789
            verbose "check_vmx_hw_availalble testfile compilation failed" 2
790
        }
791
    }
792
 
793
    return $vmx_hw_available_saved
794
}
795
 
796
# GCC 3.4.0 for powerpc64-*-linux* included an ABI fix for passing
797
# complex float arguments.  This affects gfortran tests that call cabsf
798
# in libm built by an earlier compiler.  Return 1 if libm uses the same
799
# argument passing as the compiler under test, 0 otherwise.
800
#
801
# When the target name changes, replace the cached result.
802
 
803
proc check_effective_target_broken_cplxf_arg { } {
804
    global et_broken_cplxf_arg_saved
805
    global et_broken_cplxf_arg_target_name
806
    global tool
807
 
808
    # Skip the work for targets known not to be affected.
809
    if { ![istarget powerpc64-*-linux*] } {
810
        return 0
811
    } elseif { [is-effective-target ilp32] } {
812
        return 0
813
    }
814
 
815
    if { ![info exists et_broken_cplxf_arg_target_name] } {
816
        set et_broken_cplxf_arg_target_name ""
817
    }
818
 
819
    # If the target has changed since we set the cached value, clear it.
820
    set current_target [current_target_name]
821
    if { $current_target != $et_broken_cplxf_arg_target_name } {
822
        verbose "check_effective_target_broken_cplxf_arg: `$et_broken_cplxf_arg_target_name'" 2
823
        set et_broken_cplxf_arg_target_name $current_target
824
        if [info exists et_broken_cplxf_arg_saved] {
825
            verbose "check_effective_target_broken_cplxf_arg: removing cached result" 2
826
            unset et_broken_cplxf_arg_saved
827
        }
828
    }
829
 
830
    if [info exists et_broken_cplxf_arg_saved] {
831
        verbose "check_effective_target_broken_cplxf_arg: using cached result" 2
832
    } else {
833
        set et_broken_cplxf_arg_saved 0
834
        # This is only known to affect one target.
835
        if { ![istarget powerpc64-*-linux*] || ![is-effective-target lp64] } {
836
            set et_broken_cplxf_arg_saved 0
837
            verbose "check_effective_target_broken_cplxf_arg: caching 0" 2
838
            return $et_broken_cplxf_arg_saved
839
        }
840
 
841
        # Set up, compile, and execute a C test program that calls cabsf.
842
        set src cabsf[pid].c
843
        set exe cabsf[pid].x
844
 
845
        set f [open $src "w"]
846
        puts $f "#include "
847
        puts $f "extern void abort (void);"
848
        puts $f "float fabsf (float);"
849
        puts $f "float cabsf (_Complex float);"
850
        puts $f "int main ()"
851
        puts $f "{"
852
        puts $f "  _Complex float cf;"
853
        puts $f "  float f;"
854
        puts $f "  cf = 3 + 4.0fi;"
855
        puts $f "  f = cabsf (cf);"
856
        puts $f "  if (fabsf (f - 5.0) > 0.0001) abort ();"
857
        puts $f "  return 0;"
858
        puts $f "}"
859
        close $f
860
 
861
        set lines [${tool}_target_compile $src $exe executable "-lm"]
862
        file delete $src
863
 
864
        if [string match "" $lines] {
865
            # No error message, compilation succeeded.
866
            set result [${tool}_load "./$exe" "" ""]
867
            set status [lindex $result 0]
868
            remote_file build delete $exe
869
 
870
            verbose "check_effective_target_broken_cplxf_arg: status is <$status>" 2
871
 
872
            if { $status != "pass" } {
873
                set et_broken_cplxf_arg_saved 1
874
            }
875
        } else {
876
            verbose "check_effective_target_broken_cplxf_arg: compilation failed" 2
877
        }
878
    }
879
    return $et_broken_cplxf_arg_saved
880
}
881
 
882
proc check_alpha_max_hw_available { } {
883
    global alpha_max_hw_available_saved
884
    global tool
885
 
886
    if [info exists alpha_max_hw_available_saved] {
887
        verbose "check_alpha_max_hw_available returning saved $alpha_max_hw_available_saved" 2
888
    } else {
889
        set alpha_max_hw_available_saved 0
890
 
891
        # Set up, compile, and execute a test program probing bit 8 of the
892
        # architecture mask, which indicates presence of MAX instructions.
893
        set src max[pid].c
894
        set exe max[pid].x
895
 
896
        set f [open $src "w"]
897
        puts $f "int main() { return __builtin_alpha_amask(1<<8) != 0; }"
898
        close $f
899
 
900
        verbose "check_alpha_max_hw_available compiling testfile $src" 2
901
        set lines [${tool}_target_compile $src $exe executable ""]
902
        file delete $src
903
 
904
        if [string match "" $lines] then {
905
            # No error message, compilation succeeded.
906
            set result [${tool}_load "./$exe" "" ""]
907
            set status [lindex $result 0]
908
            remote_file build delete $exe
909
            verbose "check_alpha_max_hw_available testfile status is <$status>" 2
910
 
911
            if { $status == "pass" } then {
912
                set alpha_max_hw_available_saved 1
913
            }
914
        } else {
915
            verbose "check_alpha_max_hw_availalble testfile compilation failed" 2
916
        }
917
    }
918
 
919
    return $alpha_max_hw_available_saved
920
}
921
 
922
# Returns true iff the FUNCTION is available on the target system.
923
# (This is essentially a Tcl implementation of Autoconf's
924
# AC_CHECK_FUNC.)
925
 
926
proc check_function_available { function } {
927
    set var "${function}_available_saved"
928
    global $var
929
    global tool
930
 
931
    if {![info exists $var]} {
932
        # Assume it exists.
933
        set $var 1
934
        # Check to make sure.
935
        set src "function[pid].c"
936
        set exe "function[pid].exe"
937
 
938
        set f [open $src "w"]
939
        puts $f "#ifdef __cplusplus\nextern \"C\"\n#endif\n"
940
        puts $f "char $function ();\n"
941
        puts $f "int main () { $function (); }"
942
        close $f
943
 
944
        set lines [${tool}_target_compile $src $exe executable ""]
945
        file delete $src
946
        file delete $exe
947
 
948
        if {![string match "" $lines]} then {
949
            set $var 0
950
            verbose -log "$function is not available"
951
        } else {
952
            verbose -log "$function is available"
953
        }
954
    }
955
 
956
    eval return \$$var
957
}
958
 
959
# Returns true iff "fork" is available on the target system.
960
 
961
proc check_fork_available {} {
962
    return [check_function_available "fork"]
963
}
964
 
965
# Returns true iff "mkfifo" is available on the target system.
966
 
967
proc check_mkfifo_available {} {
968
    if {[istarget *-*-cygwin*]} {
969
       # Cygwin has mkfifo, but support is incomplete.
970
       return 0
971
     }
972
 
973
    return [check_function_available "mkfifo"]
974
}
975
 
976
# Returns true iff "__cxa_atexit" is used on the target system.
977
 
978
proc check_cxa_atexit_available { } {
979
    global et_cxa_atexit
980
    global et_cxa_atexit_target_name
981
    global tool
982
 
983
    if { ![info exists et_cxa_atexit_target_name] } {
984
        set et_cxa_atexit_target_name ""
985
    }
986
 
987
    # If the target has changed since we set the cached value, clear it.
988
    set current_target [current_target_name]
989
    if { $current_target != $et_cxa_atexit_target_name } {
990
        verbose "check_cxa_atexit_available: `$et_cxa_atexit_target_name'" 2
991
        set et_cxa_atexit_target_name $current_target
992
        if [info exists et_cxa_atexit] {
993
            verbose "check_cxa_atexit_available: removing cached result" 2
994
            unset et_cxa_atexit
995
        }
996
    }
997
 
998
    if [info exists et_cxa_atexit] {
999
        verbose "check_cxa_atexit_available: using cached result" 2
1000
    } elseif { [istarget "hppa*-*-hpux10*"] } {
1001
        # HP-UX 10 doesn't have __cxa_atexit but subsequent test passes.
1002
        set et_cxa_atexit 0
1003
    } else {
1004
        set et_cxa_atexit 0
1005
 
1006
        # Set up, compile, and execute a C++ test program that depends
1007
        # on correct ordering of static object destructors. This is
1008
        # indicative of the presence and use of __cxa_atexit.
1009
        set src cxaatexit[pid].cc
1010
        set exe cxaatexit[pid].x
1011
 
1012
        set f [open $src "w"]
1013
        puts $f "#include "
1014
        puts $f "static unsigned int count;"
1015
        puts $f "struct X"
1016
        puts $f "{"
1017
        puts $f "  X() { count = 1; }"
1018
        puts $f "  ~X()"
1019
        puts $f "  {"
1020
        puts $f "    if (count != 3)"
1021
        puts $f "      exit(1);"
1022
        puts $f "    count = 4;"
1023
        puts $f "  }"
1024
        puts $f "};"
1025
        puts $f "void f()"
1026
        puts $f "{"
1027
        puts $f "  static X x;"
1028
        puts $f "}"
1029
        puts $f "struct Y"
1030
        puts $f "{"
1031
        puts $f "  Y() { f(); count = 2; }"
1032
        puts $f "  ~Y()"
1033
        puts $f "  {"
1034
        puts $f "    if (count != 2)"
1035
        puts $f "      exit(1);"
1036
        puts $f "    count = 3;"
1037
        puts $f "  }"
1038
        puts $f "};"
1039
        puts $f "Y y;"
1040
        puts $f "int main()"
1041
        puts $f "{ return 0; }"
1042
        close $f
1043
 
1044
        set lines [${tool}_target_compile $src $exe executable ""]
1045
        file delete $src
1046
 
1047
        if [string match "" $lines] {
1048
            # No error message, compilation succeeded.
1049
            set result [${tool}_load "./$exe" "" ""]
1050
            set status [lindex $result 0]
1051
            remote_file build delete $exe
1052
 
1053
            verbose "check_cxa_atexit_available: status is <$status>" 2
1054
 
1055
            if { $status == "pass" } {
1056
                set et_cxa_atexit 1
1057
            }
1058
        } else {
1059
            verbose "check_cxa_atexit_available: compilation failed" 2
1060
        }
1061
    }
1062
    return $et_cxa_atexit
1063
}
1064
 
1065
 
1066
# Return 1 if we're generating 32-bit code using default options, 0
1067
# otherwise.
1068
 
1069
proc check_effective_target_ilp32 { } {
1070
    return [check_no_compiler_messages ilp32 object {
1071
        int dummy[sizeof (int) == 4
1072
                  && sizeof (void *) == 4
1073
                  && sizeof (long) == 4 ? 1 : -1];
1074
    }]
1075
}
1076
 
1077
# Return 1 if we're generating 32-bit or larger integers using default
1078
# options, 0 otherwise.
1079
 
1080
proc check_effective_target_int32plus { } {
1081
    return [check_no_compiler_messages int32plus object {
1082
        int dummy[sizeof (int) >= 4 ? 1 : -1];
1083
    }]
1084
}
1085
 
1086
# Return 1 if we're generating 32-bit or larger pointers using default
1087
# options, 0 otherwise.
1088
 
1089
proc check_effective_target_ptr32plus { } {
1090
    return [check_no_compiler_messages ptr32plus object {
1091
        int dummy[sizeof (void *) >= 4 ? 1 : -1];
1092
    }]
1093
}
1094
 
1095
# Return 1 if we support 32-bit or larger array and structure sizes
1096
# using default options, 0 otherwise.
1097
 
1098
proc check_effective_target_size32plus { } {
1099
    return [check_no_compiler_messages size32plus object {
1100
        char dummy[65537];
1101
    }]
1102
}
1103
 
1104
# Returns 1 if we're generating 16-bit or smaller integers with the
1105
# default options, 0 otherwise.
1106
 
1107
proc check_effective_target_int16 { } {
1108
    return [check_no_compiler_messages int16 object {
1109
        int dummy[sizeof (int) < 4 ? 1 : -1];
1110
    }]
1111
}
1112
 
1113
# Return 1 if we're generating 64-bit code using default options, 0
1114
# otherwise.
1115
 
1116
proc check_effective_target_lp64 { } {
1117
    return [check_no_compiler_messages lp64 object {
1118
        int dummy[sizeof (int) == 4
1119
                  && sizeof (void *) == 8
1120
                  && sizeof (long) == 8 ? 1 : -1];
1121
    }]
1122
}
1123
 
1124
# Return 1 if the target supports compiling decimal floating point,
1125
# 0 otherwise.
1126
 
1127
proc check_effective_target_dfp_nocache { } {
1128
    verbose "check_effective_target_dfp_nocache: compiling source" 2
1129
    set ret [string match "" [get_compiler_messages dfp 0 object {
1130
        _Decimal32 x; _Decimal64 y; _Decimal128 z;
1131
    }]]
1132
    verbose "check_effective_target_dfp_nocache: returning $ret" 2
1133
    return $ret
1134
}
1135
 
1136
proc check_effective_target_dfprt_nocache { } {
1137
    global tool
1138
 
1139
    set ret 0
1140
 
1141
    verbose "check_effective_target_dfprt_nocache: compiling source" 2
1142
    # Set up, compile, and execute a test program containing decimal
1143
    # float operations.
1144
    set src dfprt[pid].c
1145
    set exe dfprt[pid].x
1146
 
1147
    set f [open $src "w"]
1148
    puts $f "_Decimal32 x = 1.2df; _Decimal64 y = 2.3dd; _Decimal128 z;"
1149
    puts $f "int main () { z = x + y; return 0; }"
1150
    close $f
1151
 
1152
    verbose "check_effective_target_dfprt_nocache: compiling testfile $src" 2
1153
    set lines [${tool}_target_compile $src $exe executable ""]
1154
    file delete $src
1155
 
1156
    if [string match "" $lines] then {
1157
        # No error message, compilation succeeded.
1158
        set result [${tool}_load "./$exe" "" ""]
1159
        set status [lindex $result 0]
1160
        remote_file build delete $exe
1161
        verbose "check_effective_target_dfprt_nocache: testfile status is <$status>" 2
1162
        if { $status == "pass" } then {
1163
            set ret 1
1164
        }
1165
    }
1166
    return $ret
1167
    verbose "check_effective_target_dfprt_nocache: returning $ret" 2
1168
}
1169
 
1170
# Return 1 if the target supports compiling Decimal Floating Point,
1171
# 0 otherwise.
1172
#
1173
# This won't change for different subtargets so cache the result.
1174
 
1175
proc check_effective_target_dfp { } {
1176
    global et_dfp_saved
1177
 
1178
    if [info exists et_dfp_saved] {
1179
        verbose "check_effective_target_dfp: using cached result" 2
1180
    } else {
1181
        set et_dfp_saved [check_effective_target_dfp_nocache]
1182
    }
1183
    verbose "check_effective_target_dfp: returning $et_dfp_saved" 2
1184
    return $et_dfp_saved
1185
}
1186
 
1187
# Return 1 if the target supports linking and executing Decimal Floating
1188
# Point, # 0 otherwise.
1189
#
1190
# This won't change for different subtargets so cache the result.
1191
 
1192
proc check_effective_target_dfprt { } {
1193
    global et_dfprt_saved
1194
    global tool
1195
 
1196
    if [info exists et_dfprt_saved] {
1197
        verbose "check_effective_target_dfprt: using cached result" 2
1198
    } else {
1199
        set et_dfprt_saved [check_effective_target_dfprt_nocache]
1200
    }
1201
    verbose "check_effective_target_dfprt: returning $et_dfprt_saved" 2
1202
    return $et_dfprt_saved
1203
}
1204
 
1205
# Return 1 if the target needs a command line argument to enable a SIMD
1206
# instruction set.
1207
 
1208
proc check_effective_target_vect_cmdline_needed { } {
1209
    global et_vect_cmdline_needed_saved
1210
    global et_vect_cmdline_needed_target_name
1211
 
1212
    if { ![info exists et_vect_cmdline_needed_target_name] } {
1213
        set et_vect_cmdline_needed_target_name ""
1214
    }
1215
 
1216
    # If the target has changed since we set the cached value, clear it.
1217
    set current_target [current_target_name]
1218
    if { $current_target != $et_vect_cmdline_needed_target_name } {
1219
        verbose "check_effective_target_vect_cmdline_needed: `$et_vect_cmdline_needed_target_name' `$current_target'" 2
1220
        set et_vect_cmdline_needed_target_name $current_target
1221
        if { [info exists et_vect_cmdline_needed_saved] } {
1222
            verbose "check_effective_target_vect_cmdline_needed: removing cached result" 2
1223
            unset et_vect_cmdline_needed_saved
1224
        }
1225
    }
1226
 
1227
    if [info exists et_vect_cmdline_needed_saved] {
1228
        verbose "check_effective_target_vect_cmdline_needed: using cached result" 2
1229
    } else {
1230
        set et_vect_cmdline_needed_saved 1
1231
        if { [istarget ia64-*-*]
1232
             || (([istarget x86_64-*-*] || [istarget i?86-*-*])
1233
                 && [check_effective_target_lp64])
1234
             || ([istarget powerpc*-*-*]
1235
                 && ([check_effective_target_powerpc_spe]
1236
                     || [check_effective_target_powerpc_altivec]))} {
1237
           set et_vect_cmdline_needed_saved 0
1238
        }
1239
    }
1240
 
1241
    verbose "check_effective_target_vect_cmdline_needed: returning $et_vect_cmdline_needed_saved" 2
1242
    return $et_vect_cmdline_needed_saved
1243
}
1244
 
1245
# Return 1 if the target supports hardware vectors of int, 0 otherwise.
1246
#
1247
# This won't change for different subtargets so cache the result.
1248
 
1249
proc check_effective_target_vect_int { } {
1250
    global et_vect_int_saved
1251
 
1252
    if [info exists et_vect_int_saved] {
1253
        verbose "check_effective_target_vect_int: using cached result" 2
1254
    } else {
1255
        set et_vect_int_saved 0
1256
        if { [istarget i?86-*-*]
1257
              || [istarget powerpc*-*-*]
1258
              || [istarget x86_64-*-*]
1259
              || [istarget sparc*-*-*]
1260
              || [istarget alpha*-*-*]
1261
              || [istarget ia64-*-*] } {
1262
           set et_vect_int_saved 1
1263
        }
1264
    }
1265
 
1266
    verbose "check_effective_target_vect_int: returning $et_vect_int_saved" 2
1267
    return $et_vect_int_saved
1268
}
1269
 
1270
# Return 1 is this is an arm target using 32-bit instructions
1271
proc check_effective_target_arm32 { } {
1272
    global et_arm32_saved
1273
    global et_arm32_target_name
1274
    global compiler_flags
1275
 
1276
    if { ![info exists et_arm32_target_name] } {
1277
        set et_arm32_target_name ""
1278
    }
1279
 
1280
    # If the target has changed since we set the cached value, clear it.
1281
    set current_target [current_target_name]
1282
    if { $current_target != $et_arm32_target_name } {
1283
        verbose "check_effective_target_arm32: `$et_arm32_target_name' `$current_target'" 2
1284
        set et_arm32_target_name $current_target
1285
        if { [info exists et_arm32_saved] } {
1286
            verbose "check_effective_target_arm32: removing cached result" 2
1287
            unset et_arm32_saved
1288
        }
1289
    }
1290
 
1291
    if [info exists et_arm32_saved] {
1292
        verbose "check-effective_target_arm32: using cached result" 2
1293
    } else {
1294
        set et_arm32_saved 0
1295
        if { [istarget arm-*-*]
1296
              || [istarget strongarm*-*-*]
1297
              || [istarget xscale-*-*] } {
1298
            if ![string match "*-mthumb *" $compiler_flags] {
1299
                set et_arm32_saved 1
1300
            }
1301
        }
1302
    }
1303
    verbose "check_effective_target_arm32: returning $et_arm32_saved" 2
1304
    return $et_arm32_saved
1305
}
1306
 
1307
# Return 1 if this is an ARM target supporting -mfpu=vfp
1308
# -mfloat-abi=softfp.  Some multilibs may be incompatible with these
1309
# options.
1310
 
1311
proc check_effective_target_arm_vfp_ok { } {
1312
    if { [check_effective_target_arm32] } {
1313
        return [check_no_compiler_messages arm_vfp_ok object {
1314
            int dummy;
1315
        } "-mfpu=vfp -mfloat-abi=softfp"]
1316
    } else {
1317
        return 0
1318
    }
1319
}
1320
 
1321
# Return 1 if this is a PowerPC target with floating-point registers.
1322
 
1323
proc check_effective_target_powerpc_fprs { } {
1324
    if { [istarget powerpc*-*-*]
1325
         || [istarget rs6000-*-*] } {
1326
        return [check_no_compiler_messages powerpc_fprs object {
1327
            #ifdef __NO_FPRS__
1328
            #error no FPRs
1329
            #else
1330
            int dummy;
1331
            #endif
1332
        }]
1333
    } else {
1334
        return 0
1335
    }
1336
}
1337
 
1338
# Return 1 if this is a PowerPC target supporting -maltivec.
1339
 
1340
proc check_effective_target_powerpc_altivec_ok { } {
1341
    if { [istarget powerpc*-*-*]
1342
         || [istarget rs6000-*-*] } {
1343
        # AltiVec is not supported on Aix.
1344
        if { [istarget powerpc*-*-aix*] } {
1345
            return 0
1346
        }
1347
        return [check_no_compiler_messages powerpc_altivec_ok object {
1348
            int dummy;
1349
        } "-maltivec"]
1350
    } else {
1351
        return 0
1352
    }
1353
}
1354
 
1355
# Return 1 if this is a PowerPC target with SPE enabled.
1356
 
1357
proc check_effective_target_powerpc_spe { } {
1358
    if { [istarget powerpc*-*-*] } {
1359
        return [check_no_compiler_messages powerpc_spe object {
1360
            #ifndef __SPE__
1361
            #error not SPE
1362
            #else
1363
            int dummy;
1364
            #endif
1365
        }]
1366
    } else {
1367
        return 0
1368
    }
1369
}
1370
 
1371
# Return 1 if this is a PowerPC target with Altivec enabled.
1372
 
1373
proc check_effective_target_powerpc_altivec { } {
1374
    if { [istarget powerpc*-*-*] } {
1375
        return [check_no_compiler_messages powerpc_altivec object {
1376
            #ifndef __ALTIVEC__
1377
            #error not Altivec
1378
            #else
1379
            int dummy;
1380
            #endif
1381
        }]
1382
    } else {
1383
        return 0
1384
    }
1385
}
1386
 
1387
# Return 1 if the target supports hardware vector shift operation.
1388
 
1389
proc check_effective_target_vect_shift { } {
1390
    global et_vect_shift_saved
1391
 
1392
    if [info exists et_vect_shift_saved] {
1393
        verbose "check_effective_target_vect_shift: using cached result" 2
1394
    } else {
1395
        set et_vect_shift_saved 0
1396
        if { [istarget powerpc*-*-*]
1397
             || [istarget ia64-*-*]
1398
             || [istarget i?86-*-*]
1399
             || [istarget x86_64-*-*] } {
1400
           set et_vect_shift_saved 1
1401
        }
1402
    }
1403
 
1404
    verbose "check_effective_target_vect_shift: returning $et_vect_shift_saved" 2
1405
    return $et_vect_shift_saved
1406
}
1407
 
1408
# Return 1 if the target supports hardware vectors of long, 0 otherwise.
1409
#
1410
# This can change for different subtargets so do not cache the result.
1411
 
1412
proc check_effective_target_vect_long { } {
1413
    if { [istarget i?86-*-*]
1414
         || ([istarget powerpc*-*-*] && [check_effective_target_ilp32])
1415
         || [istarget x86_64-*-*]
1416
         || ([istarget sparc*-*-*] && [check_effective_target_ilp32]) } {
1417
        set answer 1
1418
    } else {
1419
        set answer 0
1420
    }
1421
 
1422
    verbose "check_effective_target_vect_long: returning $answer" 2
1423
    return $answer
1424
}
1425
 
1426
# Return 1 if the target supports hardware vectors of float, 0 otherwise.
1427
#
1428
# This won't change for different subtargets so cache the result.
1429
 
1430
proc check_effective_target_vect_float { } {
1431
    global et_vect_float_saved
1432
 
1433
    if [info exists et_vect_float_saved] {
1434
        verbose "check_effective_target_vect_float: using cached result" 2
1435
    } else {
1436
        set et_vect_float_saved 0
1437
        if { [istarget i?86-*-*]
1438
              || [istarget powerpc*-*-*]
1439
              || [istarget mipsisa64*-*-*]
1440
              || [istarget x86_64-*-*]
1441
              || [istarget ia64-*-*] } {
1442
           set et_vect_float_saved 1
1443
        }
1444
    }
1445
 
1446
    verbose "check_effective_target_vect_float: returning $et_vect_float_saved" 2
1447
    return $et_vect_float_saved
1448
}
1449
 
1450
# Return 1 if the target supports hardware vectors of double, 0 otherwise.
1451
#
1452
# This won't change for different subtargets so cache the result.
1453
 
1454
proc check_effective_target_vect_double { } {
1455
    global et_vect_double_saved
1456
 
1457
    if [info exists et_vect_double_saved] {
1458
        verbose "check_effective_target_vect_double: using cached result" 2
1459
    } else {
1460
        set et_vect_double_saved 0
1461
        if { [istarget i?86-*-*]
1462
              || [istarget x86_64-*-*] } {
1463
           set et_vect_double_saved 1
1464
        }
1465
    }
1466
 
1467
    verbose "check_effective_target_vect_double: returning $et_vect_double_saved" 2
1468
    return $et_vect_double_saved
1469
}
1470
 
1471
# Return 1 if the target plus current options does not support a vector
1472
# max instruction on "int", 0 otherwise.
1473
#
1474
# This won't change for different subtargets so cache the result.
1475
 
1476
proc check_effective_target_vect_no_int_max { } {
1477
    global et_vect_no_int_max_saved
1478
 
1479
    if [info exists et_vect_no_int_max_saved] {
1480
        verbose "check_effective_target_vect_no_int_max: using cached result" 2
1481
    } else {
1482
        set et_vect_no_int_max_saved 0
1483
        if { [istarget sparc*-*-*]
1484
             || [istarget alpha*-*-*] } {
1485
            set et_vect_no_int_max_saved 1
1486
        }
1487
    }
1488
    verbose "check_effective_target_vect_no_int_max: returning $et_vect_no_int_max_saved" 2
1489
    return $et_vect_no_int_max_saved
1490
}
1491
 
1492
# Return 1 if the target plus current options does not support a vector
1493
# add instruction on "int", 0 otherwise.
1494
#
1495
# This won't change for different subtargets so cache the result.
1496
 
1497
proc check_effective_target_vect_no_int_add { } {
1498
    global et_vect_no_int_add_saved
1499
 
1500
    if [info exists et_vect_no_int_add_saved] {
1501
        verbose "check_effective_target_vect_no_int_add: using cached result" 2
1502
    } else {
1503
        set et_vect_no_int_add_saved 0
1504
        # Alpha only supports vector add on V8QI and V4HI.
1505
        if { [istarget alpha*-*-*] } {
1506
            set et_vect_no_int_add_saved 1
1507
        }
1508
    }
1509
    verbose "check_effective_target_vect_no_int_add: returning $et_vect_no_int_add_saved" 2
1510
    return $et_vect_no_int_add_saved
1511
}
1512
 
1513
# Return 1 if the target plus current options does not support vector
1514
# bitwise instructions, 0 otherwise.
1515
#
1516
# This won't change for different subtargets so cache the result.
1517
 
1518
proc check_effective_target_vect_no_bitwise { } {
1519
    global et_vect_no_bitwise_saved
1520
 
1521
    if [info exists et_vect_no_bitwise_saved] {
1522
        verbose "check_effective_target_vect_no_bitwise: using cached result" 2
1523
    } else {
1524
        set et_vect_no_bitwise_saved 0
1525
    }
1526
    verbose "check_effective_target_vect_no_bitwise: returning $et_vect_no_bitwise_saved" 2
1527
    return $et_vect_no_bitwise_saved
1528
}
1529
 
1530
# Return 1 if the target plus current options supports a vector
1531
# widening summation of *short* args into *int* result, 0 otherwise.
1532
#
1533
# This won't change for different subtargets so cache the result.
1534
 
1535
proc check_effective_target_vect_widen_sum_hi_to_si { } {
1536
    global et_vect_widen_sum_hi_to_si
1537
 
1538
    if [info exists et_vect_widen_sum_hi_to_si_saved] {
1539
        verbose "check_effective_target_vect_widen_sum_hi_to_si: using cached result" 2
1540
    } else {
1541
        set et_vect_widen_sum_hi_to_si_saved 0
1542
        if { [istarget powerpc*-*-*]
1543
             || [istarget ia64-*-*] } {
1544
            set et_vect_widen_sum_hi_to_si_saved 1
1545
        }
1546
    }
1547
    verbose "check_effective_target_vect_widen_sum_hi_to_si: returning $et_vect_widen_sum_hi_to_si_saved" 2
1548
    return $et_vect_widen_sum_hi_to_si_saved
1549
}
1550
 
1551
# Return 1 if the target plus current options supports a vector
1552
# widening summation of *char* args into *short* result, 0 otherwise.
1553
#
1554
# This won't change for different subtargets so cache the result.
1555
 
1556
proc check_effective_target_vect_widen_sum_qi_to_hi { } {
1557
    global et_vect_widen_sum_qi_to_hi
1558
 
1559
    if [info exists et_vect_widen_sum_qi_to_hi_saved] {
1560
        verbose "check_effective_target_vect_widen_sum_qi_to_hi: using cached result" 2
1561
    } else {
1562
        set et_vect_widen_sum_qi_to_hi_saved 0
1563
        if { [istarget ia64-*-*] } {
1564
            set et_vect_widen_sum_qi_to_hi_saved 1
1565
        }
1566
    }
1567
    verbose "check_effective_target_vect_widen_sum_qi_to_hi: returning $et_vect_widen_sum_qi_to_hi_saved" 2
1568
    return $et_vect_widen_sum_qi_to_hi_saved
1569
}
1570
 
1571
# Return 1 if the target plus current options supports a vector
1572
# widening summation of *char* args into *int* result, 0 otherwise.
1573
#
1574
# This won't change for different subtargets so cache the result.
1575
 
1576
proc check_effective_target_vect_widen_sum_qi_to_si { } {
1577
    global et_vect_widen_sum_qi_to_si
1578
 
1579
    if [info exists et_vect_widen_sum_qi_to_si_saved] {
1580
        verbose "check_effective_target_vect_widen_sum_qi_to_si: using cached result" 2
1581
    } else {
1582
        set et_vect_widen_sum_qi_to_si_saved 0
1583
        if { [istarget powerpc*-*-*] } {
1584
            set et_vect_widen_sum_qi_to_si_saved 1
1585
        }
1586
    }
1587
    verbose "check_effective_target_vect_widen_sum_qi_to_si: returning $et_vect_widen_sum_qi_to_si_saved" 2
1588
    return $et_vect_widen_sum_qi_to_si_saved
1589
}
1590
 
1591
# Return 1 if the target plus current options supports a vector
1592
# widening summation, 0 otherwise.
1593
#
1594
# This won't change for different subtargets so cache the result.
1595
 
1596
proc check_effective_target_vect_widen_sum { } {
1597
    global et_vect_widen_sum
1598
 
1599
    if [info exists et_vect_widen_sum_saved] {
1600
        verbose "check_effective_target_vect_widen_sum: using cached result" 2
1601
    } else {
1602
        set et_vect_widen_sum_saved 0
1603
        if { [istarget powerpc*-*-*]
1604
             || [istarget ia64-*-*] } {
1605
            set et_vect_widen_sum_saved 1
1606
        }
1607
    }
1608
    verbose "check_effective_target_vect_widen_sum: returning $et_vect_widen_sum_saved" 2
1609
    return $et_vect_widen_sum_saved
1610
}
1611
 
1612
# Return 1 if the target plus current options supports a vector
1613
# dot-product of signed chars, 0 otherwise.
1614
#
1615
# This won't change for different subtargets so cache the result.
1616
 
1617
proc check_effective_target_vect_sdot_qi { } {
1618
    global et_vect_sdot_qi
1619
 
1620
    if [info exists et_vect_sdot_qi_saved] {
1621
        verbose "check_effective_target_vect_sdot_qi: using cached result" 2
1622
    } else {
1623
        set et_vect_sdot_qi_saved 0
1624
        if { [istarget ia64-*-*] } {
1625
            set et_vect_sdot_qi_saved 1
1626
        }
1627
    }
1628
    verbose "check_effective_target_vect_sdot_qi: returning $et_vect_sdot_qi_saved" 2
1629
    return $et_vect_sdot_qi_saved
1630
}
1631
 
1632
# Return 1 if the target plus current options supports a vector
1633
# dot-product of unsigned chars, 0 otherwise.
1634
#
1635
# This won't change for different subtargets so cache the result.
1636
 
1637
proc check_effective_target_vect_udot_qi { } {
1638
    global et_vect_udot_qi
1639
 
1640
    if [info exists et_vect_udot_qi_saved] {
1641
        verbose "check_effective_target_vect_udot_qi: using cached result" 2
1642
    } else {
1643
        set et_vect_udot_qi_saved 0
1644
        if { [istarget powerpc*-*-*]
1645
             || [istarget ia64-*-*] } {
1646
            set et_vect_udot_qi_saved 1
1647
        }
1648
    }
1649
    verbose "check_effective_target_vect_udot_qi: returning $et_vect_udot_qi_saved" 2
1650
    return $et_vect_udot_qi_saved
1651
}
1652
 
1653
# Return 1 if the target plus current options supports a vector
1654
# dot-product of signed shorts, 0 otherwise.
1655
#
1656
# This won't change for different subtargets so cache the result.
1657
 
1658
proc check_effective_target_vect_sdot_hi { } {
1659
    global et_vect_sdot_hi
1660
 
1661
    if [info exists et_vect_sdot_hi_saved] {
1662
        verbose "check_effective_target_vect_sdot_hi: using cached result" 2
1663
    } else {
1664
        set et_vect_sdot_hi_saved 0
1665
        if { [istarget powerpc*-*-*]
1666
             || [istarget i?86-*-*]
1667
             || [istarget x86_64-*-*]
1668
             || [istarget ia64-*-*] } {
1669
            set et_vect_sdot_hi_saved 1
1670
        }
1671
    }
1672
    verbose "check_effective_target_vect_sdot_hi: returning $et_vect_sdot_hi_saved" 2
1673
    return $et_vect_sdot_hi_saved
1674
}
1675
 
1676
# Return 1 if the target plus current options supports a vector
1677
# dot-product of unsigned shorts, 0 otherwise.
1678
#
1679
# This won't change for different subtargets so cache the result.
1680
 
1681
proc check_effective_target_vect_udot_hi { } {
1682
    global et_vect_udot_hi
1683
 
1684
    if [info exists et_vect_udot_hi_saved] {
1685
        verbose "check_effective_target_vect_udot_hi: using cached result" 2
1686
    } else {
1687
        set et_vect_udot_hi_saved 0
1688
        if { [istarget powerpc*-*-*] } {
1689
            set et_vect_udot_hi_saved 1
1690
        }
1691
    }
1692
    verbose "check_effective_target_vect_udot_hi: returning $et_vect_udot_hi_saved" 2
1693
    return $et_vect_udot_hi_saved
1694
}
1695
 
1696
 
1697
# Return 1 if the target plus current options does not support a vector
1698
# alignment mechanism, 0 otherwise.
1699
#
1700
# This won't change for different subtargets so cache the result.
1701
 
1702
proc check_effective_target_vect_no_align { } {
1703
    global et_vect_no_align_saved
1704
 
1705
    if [info exists et_vect_no_align_saved] {
1706
        verbose "check_effective_target_vect_no_align: using cached result" 2
1707
    } else {
1708
        set et_vect_no_align_saved 0
1709
        if { [istarget mipsisa64*-*-*]
1710
             || [istarget sparc*-*-*]
1711
             || [istarget ia64-*-*] } {
1712
            set et_vect_no_align_saved 1
1713
        }
1714
    }
1715
    verbose "check_effective_target_vect_no_align: returning $et_vect_no_align_saved" 2
1716
    return $et_vect_no_align_saved
1717
}
1718
 
1719
# Return 1 if arrays are naturally aligned to the vector
1720
# alignment boundary, 0 otherwise.
1721
#
1722
# This won't change for different subtargets so cache the result.
1723
 
1724
proc check_effective_target_vect_aligned_arrays { } {
1725
    global et_vect_aligned_arrays
1726
 
1727
    if [info exists et_vect_aligned_arrays_saved] {
1728
        verbose "check_effective_target_vect_aligned_arrays: using cached result" 2
1729
    } else {
1730
        set et_vect_aligned_arrays_saved 0
1731
        if { ([istarget x86_64-*-*]
1732
              || [istarget i?86-*-*]) && [is-effective-target lp64] } {
1733
            set et_vect_aligned_arrays_saved 1
1734
        }
1735
    }
1736
    verbose "check_effective_target_vect_aligned_arrays: returning $et_vect_aligned_arrays_saved" 2
1737
    return $et_vect_aligned_arrays_saved
1738
}
1739
 
1740
# Return 1 if the target supports vector conditional operations, 0 otherwise.
1741
 
1742
proc check_effective_target_vect_condition { } {
1743
    global et_vect_cond_saved
1744
 
1745
    if [info exists et_vect_cond_saved] {
1746
        verbose "check_effective_target_vect_cond: using cached result" 2
1747
    } else {
1748
        set et_vect_cond_saved 0
1749
        if { [istarget powerpc*-*-*]
1750
             || [istarget ia64-*-*]
1751
             || [istarget i?86-*-*]
1752
             || [istarget x86_64-*-*] } {
1753
           set et_vect_cond_saved 1
1754
        }
1755
    }
1756
 
1757
    verbose "check_effective_target_vect_cond: returning $et_vect_cond_saved" 2
1758
    return $et_vect_cond_saved
1759
}
1760
 
1761
# Return 1 if the target supports vector char multiplication, 0 otherwise.
1762
 
1763
proc check_effective_target_vect_char_mult { } {
1764
    global et_vect_char_mult_saved
1765
 
1766
    if [info exists et_vect_char_mult_saved] {
1767
        verbose "check_effective_target_vect_char_mult: using cached result" 2
1768
    } else {
1769
        set et_vect_char_mult_saved 0
1770
        if { [istarget ia64-*-*]
1771
             || [istarget i?86-*-*]
1772
             || [istarget x86_64-*-*] } {
1773
           set et_vect_char_mult_saved 1
1774
        }
1775
    }
1776
 
1777
    verbose "check_effective_target_vect_char_mult: returning $et_vect_char_mult_saved" 2
1778
    return $et_vect_char_mult_saved
1779
}
1780
 
1781
# Return 1 if the target supports vector short multiplication, 0 otherwise.
1782
 
1783
proc check_effective_target_vect_short_mult { } {
1784
    global et_vect_short_mult_saved
1785
 
1786
    if [info exists et_vect_short_mult_saved] {
1787
        verbose "check_effective_target_vect_short_mult: using cached result" 2
1788
    } else {
1789
        set et_vect_short_mult_saved 0
1790
        if { [istarget ia64-*-*]
1791
             || [istarget i?86-*-*]
1792
             || [istarget x86_64-*-*] } {
1793
           set et_vect_short_mult_saved 1
1794
        }
1795
    }
1796
 
1797
    verbose "check_effective_target_vect_short_mult: returning $et_vect_short_mult_saved" 2
1798
    return $et_vect_short_mult_saved
1799
}
1800
 
1801
# Return 1 if the target supports vector int multiplication, 0 otherwise.
1802
 
1803
proc check_effective_target_vect_int_mult { } {
1804
    global et_vect_int_mult_saved
1805
 
1806
    if [info exists et_vect_int_mult_saved] {
1807
        verbose "check_effective_target_vect_int_mult: using cached result" 2
1808
    } else {
1809
        set et_vect_int_mult_saved 0
1810
        if { [istarget powerpc*-*-*]
1811
             || [istarget i?86-*-*]
1812
             || [istarget x86_64-*-*] } {
1813
           set et_vect_int_mult_saved 1
1814
        }
1815
    }
1816
 
1817
    verbose "check_effective_target_vect_int_mult: returning $et_vect_int_mult_saved" 2
1818
    return $et_vect_int_mult_saved
1819
}
1820
 
1821
# Return 1 if the target supports section-anchors
1822
 
1823
proc check_effective_target_section_anchors { } {
1824
    global et_section_anchors_saved
1825
 
1826
    if [info exists et_section_anchors_saved] {
1827
        verbose "check_effective_target_section_anchors: using cached result" 2
1828
    } else {
1829
        set et_section_anchors_saved 0
1830
        if { [istarget powerpc*-*-*] } {
1831
           set et_section_anchors_saved 1
1832
        }
1833
    }
1834
 
1835
    verbose "check_effective_target_section_anchors: returning $et_section_anchors_saved" 2
1836
    return $et_section_anchors_saved
1837
}
1838
 
1839
# Return 1 if the target supports atomic operations on "int" and "long".
1840
 
1841
proc check_effective_target_sync_int_long { } {
1842
    global et_sync_int_long_saved
1843
 
1844
    if [info exists et_sync_int_long_saved] {
1845
        verbose "check_effective_target_sync_int_long: using cached result" 2
1846
    } else {
1847
        set et_sync_int_long_saved 0
1848
# This is intentionally powerpc but not rs6000, rs6000 doesn't have the
1849
# load-reserved/store-conditional instructions.
1850
        if { [istarget ia64-*-*]
1851
             || [istarget i?86-*-*]
1852
             || [istarget x86_64-*-*]
1853
             || [istarget alpha*-*-*]
1854
             || [istarget s390*-*-*]
1855
             || [istarget powerpc*-*-*]
1856
             || [istarget sparc64-*-*]
1857
             || [istarget sparcv9-*-*] } {
1858
           set et_sync_int_long_saved 1
1859
        }
1860
    }
1861
 
1862
    verbose "check_effective_target_sync_int_long: returning $et_sync_int_long_saved" 2
1863
    return $et_sync_int_long_saved
1864
}
1865
 
1866
# Return 1 if the target supports atomic operations on "char" and "short".
1867
 
1868
proc check_effective_target_sync_char_short { } {
1869
    global et_sync_char_short_saved
1870
 
1871
    if [info exists et_sync_char_short_saved] {
1872
        verbose "check_effective_target_sync_char_short: using cached result" 2
1873
    } else {
1874
        set et_sync_char_short_saved 0
1875
# This is intentionally powerpc but not rs6000, rs6000 doesn't have the
1876
# load-reserved/store-conditional instructions.
1877
        if { [istarget ia64-*-*]
1878
             || [istarget i?86-*-*]
1879
             || [istarget x86_64-*-*]
1880
             || [istarget alpha*-*-*]
1881
             || [istarget s390*-*-*]
1882
             || [istarget powerpc*-*-*]
1883
             || [istarget sparc64-*-*]
1884
             || [istarget sparcv9-*-*] } {
1885
           set et_sync_char_short_saved 1
1886
        }
1887
    }
1888
 
1889
    verbose "check_effective_target_sync_char_short: returning $et_sync_char_short_saved" 2
1890
    return $et_sync_char_short_saved
1891
}
1892
 
1893
# Return 1 if the target matches the effective target 'arg', 0 otherwise.
1894
# This can be used with any check_* proc that takes no argument and
1895
# returns only 1 or 0.  It could be used with check_* procs that take
1896
# arguments with keywords that pass particular arguments.
1897
 
1898
proc is-effective-target { arg } {
1899
    set selected 0
1900
    if { [info procs check_effective_target_${arg}] != [list] } {
1901
        set selected [check_effective_target_${arg}]
1902
    } else {
1903
        switch $arg {
1904
          "vmx_hw"         { set selected [check_vmx_hw_available] }
1905
          "named_sections" { set selected [check_named_sections_available] }
1906
          "gc_sections"    { set selected [check_gc_sections_available] }
1907
          "cxa_atexit"     { set selected [check_cxa_atexit_available] }
1908
          default          { error "unknown effective target keyword `$arg'" }
1909
        }
1910
    }
1911
    verbose "is-effective-target: $arg $selected" 2
1912
    return $selected
1913
}
1914
 
1915
# Return 1 if the argument is an effective-target keyword, 0 otherwise.
1916
 
1917
proc is-effective-target-keyword { arg } {
1918
    if { [info procs check_effective_target_${arg}] != [list] } {
1919
        return 1
1920
    } else {
1921
        # These have different names for their check_* procs.
1922
        switch $arg {
1923
          "vmx_hw"         { return 1 }
1924
          "named_sections" { return 1 }
1925
          "gc_sections"    { return 1 }
1926
          "cxa_atexit"     { return 1 }
1927
          default          { return 0 }
1928
        }
1929
    }
1930
}
1931
 
1932
# Return 1 if target default to short enums
1933
 
1934
proc check_effective_target_short_enums { } {
1935
    return [check_no_compiler_messages short_enums assembly {
1936
        enum foo { bar };
1937
        int s[sizeof (enum foo) == 1 ? 1 : -1];
1938
    }]
1939
}
1940
 
1941
# Return 1 if target supports merging string constants at link time.
1942
 
1943
proc check_effective_target_string_merging { } {
1944
    return [check_no_messages_and_pattern string_merging \
1945
                "rodata\\.str" assembly {
1946
                    const char *var = "String";
1947
                } {-O2}]
1948
}
1949
 
1950
# Return 1 if programs are intended to be run on a simulator
1951
# (i.e. slowly) rather than hardware (i.e. fast).
1952
 
1953
proc check_effective_target_simulator { } {
1954
 
1955
    # All "src/sim" simulators set this one.
1956
    if [board_info target exists is_simulator] {
1957
        return [board_info target is_simulator]
1958
    }
1959
 
1960
    # The "sid" simulators don't set that one, but at least they set
1961
    # this one.
1962
    if [board_info target exists slow_simulator] {
1963
        return [board_info target slow_simulator]
1964
    }
1965
 
1966
    return 0
1967
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.