1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
|
# Do any platform-specific initialize for the 'arch_compile' library.
proc arch_compile_init {} {
global systemtap_arch_compile_flags
# RHEL[67] ppc64 systems can build both 64-bit and 32-bit
# executables. Fedora 24 ppc64 has dropped 32-bit exe support. So,
# if we're on ppc64 and the 32-bit exe compilation fails here, we
# assume that 32-bit exe support is unavailable.
#
# Note that it is possible that 32-bit exe support is available just
# not installed (on RHEL[67] anyway), but we can't really tell the
# difference.
if { [regexp "^(ppc64)$" $::tcl_platform(machine)] } {
# Create a tempory directory.
if {[catch {exec mktemp -d -t staptestXXXXXX-arch_compile-test} tmpdir]} {
verbose -log "Failed to create temporary directory: $tmpdir"
exit 1
}
set curdir [pwd]
cd ${tmpdir}
set source "hello.c"
set hello_file [open $source "w"]
puts $hello_file "#include <stdio.h>"
puts $hello_file "int main () { printf(\"Hello World!\"); return 0; }"
close $hello_file
set flags "additional_flags=-g compiler=gcc additional_flags=-m32"
set exe "hello-m32"
set result [target_compile $source $exe executable $flags]
if { $result != "" } {
set systemtap_arch_compile_flags 1
verbose -log "ppc64 32-bit support unavailable"
} else {
set systemtap_arch_compile_flags 2
verbose -log "ppc64 32-bit support available"
}
cd ${curdir}
catch {exec rm -rf $tmpdir}
}
}
# Number of different compile flags for this arch.
proc arch_compile_flags {} {
global systemtap_arch_compile_flags
switch -regexp $::tcl_platform(machine) {
{^(x86_64|s390x)$} { return 2 }
{^ppc64$} { return $systemtap_arch_compile_flags }
default { return 1 }
}
}
# Additional compile flag to use for with target_compile.
# Given INDEX starts at zero and should be smaller than the number
# returned by arch_compile_flags.
proc arch_compile_flag { INDEX } {
if { [arch_compile_flags] == 1 } {
return ""
}
switch $INDEX {
0 {
return "additional_flags=-m64"
}
1 {
switch -regexp $::tcl_platform(machine) {
{^s390x$} { return "additional_flags=-m31" }
default { return "additional_flags=-m32" }
}
}
}
}
# Name of compile flag to use in generated files or user/test messages.
# Given INDEX starts at zero and should be smaller than the number
# returned by arch_compile_flags.
proc arch_compile_flag_name { INDEX } {
if { [arch_compile_flags] == 1 } {
switch -regexp $::tcl_platform(machine) {
{^(ia64|aarch64|ppc64le|ppc64)$} { return "m64" }
{^s390$} { return "m31" }
{^mips64$} { return "64" }
default { return "m32" }
}
}
switch $INDEX {
0 {
return "m64"
}
1 {
switch -regexp $::tcl_platform(machine) {
{^s390x$} { return "m31" }
default { return "m32" }
}
}
}
}
# Number of bits for compile flag for use in generated files or
# user/test messages.
#
# Given INDEX starts at zero and should be smaller than the number
# returned by arch_compile_flags.
proc arch_compile_flag_bits { INDEX } {
# Notice that even though s390/s390x is 31 bits, we'll call it 32.
if { [arch_compile_flags] == 1 } {
switch -regexp $::tcl_platform(machine) {
{^(ia64|aarch64|ppc64le|ppc64|mips64)$} { return 64 }
default { return 32 }
}
}
switch $INDEX {
0 { return 64 }
1 { return 32 }
}
}
# Number of different combinations of compile flags.
proc all_compile_flags {} {
# There are 3 sets of flags for each architecture.
return [expr 3 * [arch_compile_flags]]
}
# Is INDEX a native (i.e. non-multiarch) configuration?
proc all_compile_flag_native_p { INDEX } {
set arch_index [expr $INDEX % [arch_compile_flags]]
if { $arch_index == 0 } {
return 1
}
return 0
}
# Is INDEX a configuration with optimization turned on?
proc all_compile_flag_optimized_p { INDEX } {
return [expr (($INDEX / 2) % 3) > 0]
}
# Additional compile flag to use for with target_compile.
# Given INDEX starts at zero and should be smaller than the number
# returned by all_compile_flags.
proc all_compile_flag { INDEX } {
set opt_flags [list "" "additional_flags=-O" "additional_flags=-O2" ]
set arch_index [expr $INDEX % [arch_compile_flags]]
set opt_flag [lindex $opt_flags [expr ($INDEX / 2) % 3]]
return "[arch_compile_flag $arch_index] $opt_flag"
}
# Name of compile flag to use in generated files or user/test messages.
# Given INDEX starts at zero and should be smaller than the number
# returned by arch_compile_flags.
proc all_compile_flag_name { INDEX } {
set opt_names [list "" "-O" "-O2" ]
set arch_index [expr $INDEX % [arch_compile_flags]]
set opt_name [lindex $opt_names [expr ($INDEX / 2) % 3]]
return "[arch_compile_flag_name $arch_index]$opt_name"
}
|
