blob: 3a7a2cecd176ace53be018f5c40c1fa95d432f57 (
plain)
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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
# Compute x86-specific values
# This one really needs a little love! :-(
CT_DoArchTupleValues() {
# Override the architecture part of the tuple:
if [ "${CT_ARCH_64}" = "y" ]; then
CT_TARGET_ARCH=x86_64
else
arch="${CT_ARCH_ARCH}"
[ -z "${arch}" ] && arch="${CT_ARCH_TUNE}"
case "${arch}" in
"") CT_TARGET_ARCH=i386;;
i386|i486|i586|i686) CT_TARGET_ARCH="${arch}";;
winchip*) CT_TARGET_ARCH=i486;;
pentium|pentium-mmx|c3*) CT_TARGET_ARCH=i586;;
pentiumpro|pentium*|athlon*) CT_TARGET_ARCH=i686;;
core2|atom) CT_TARGET_ARCH=i686;;
prescott|nocona) CT_TARGET_ARCH=i686;;
k8*|opteron*) CT_TARGET_ARCH=i686;;
*) CT_TARGET_ARCH=i586;;
esac
fi
CT_TARGET_ARCH="${CT_TARGET_ARCH}${CT_ARCH_SUFFIX}"
# Shouldn't be possible to specify this (CT_TARGET_SYS is not specified by the user,
# it is computed by scripts/functions from libc choices). But trap if such invalid
# values ever come from the caller:
case "${CT_TARGET_ARCH}-${CT_TARGET_SYS}" in
i[34567]86-gnux32)
CT_DoLog ERROR "Invalid CT_TARGET: i[34567]86-<vendor>-<os>-gnux32 is invalid."
CT_DoLog ERROR "CT_TARGET: ${CT_TARGET}"
CT_Abort "Go read: https://wiki.debian.org/Multiarch/Tuples"
;;
esac
}
#------------------------------------------------------------------------------
# Get multilib architecture-specific target
# Usage: CT_DoArchMultilibTarget "target variable" "multilib flags"
CT_DoArchMultilibTarget ()
{
local target_var="${1}"; shift
local -a multi_flags=( "$@" )
local target_
local bit32=false
local bit64=false
local abi_dflt=false
local abi_x32=false
for m in "${multi_flags[@]}"; do
case "$m" in
-m32) bit32=true; abi_dflt=true;;
-m64) bit64=true; abi_dflt=true;;
-mx32) bit64=true; abi_x32=true;;
esac
done
eval target_=\"\${${target_var}}\"
# Fix up architecture.
case "${target_}" in
x86_64-*) $bit32 && target_=${target_/#x86_64-/i386-} ;;
i[34567]86-*) $bit64 && target_=${target_/#i[34567]86-/x86_64-} ;;
esac
# Fix up the ABI part.
case "${target_}" in
*x32) $abi_dflt && target_=${target_/%x32} ;;
*) $abi_x32 && target_=${target_}x32 ;;
esac
# Set the target variable
eval ${target_var}=\"${target_}\"
}
# Adjust target tuple for GLIBC
CT_DoArchGlibcAdjustTuple() {
local target_var="${1}"
local target_
eval target_=\"\${${target_var}}\"
case "${target_}" in
# x86 quirk: architecture name is i386, but glibc expects i[4567]86 - to
# indicate the desired optimization. If it was a multilib variant of x86_64,
# then it targets at least NetBurst a.k.a. i786, but we'll follow the model
# above # and set the optimization to i686. Otherwise, replace with the most
# conservative choice, i486.
i386-*)
if [ "${CT_TARGET_ARCH}" = "x86_64" ]; then
target_=${target_/#i386-/i686-}
elif [ "${CT_TARGET_ARCH}" != "i386" ]; then
target_=${target_/#i386-/${CT_TARGET_ARCH}-}
else
target_=${target_/#i386-/i486-}
fi
;;
esac
# Set the target variable
eval ${target_var}=\"${target_}\"
}
CT_DoArchUClibcConfig() {
local cfg="${1}"
if [ "${CT_ARCH_BITNESS}" = 64 ]; then
CT_DoArchUClibcSelectArch "${cfg}" "x86_64"
else
CT_DoArchUClibcSelectArch "${cfg}" "i386"
fi
# FIXME This doesn't cover all cases of x86_32 on uClibc (!ng)
CT_KconfigDisableOption "CONFIG_386" "${cfg}"
CT_KconfigDisableOption "CONFIG_486" "${cfg}"
CT_KconfigDisableOption "CONFIG_586" "${cfg}"
CT_KconfigDisableOption "CONFIG_686" "${cfg}"
case ${CT_TARGET_ARCH} in
i386)
CT_KconfigEnableOption "CONFIG_386" "${cfg}"
;;
i486)
CT_KconfigEnableOption "CONFIG_486" "${cfg}"
;;
i586)
CT_KconfigEnableOption "CONFIG_586" "${cfg}"
;;
i686)
CT_KconfigEnableOption "CONFIG_686" "${cfg}"
;;
esac
}
CT_DoArchUClibcCflags() {
local cfg="${1}"
local cflags="${2}"
local f
for f in ${cflags}; do
case "${f}" in
-m64)
CT_DoArchUClibcSelectArch "${cfg}" "x86_64"
;;
-m32)
# Since it's a part of multilib with 64-bit flavor, default
# to new architecture (i686).
CT_DoArchUClibcSelectArch "${cfg}" "i386"
CT_KconfigDisableOption "CONFIG_386" "${cfg}"
CT_KconfigDisableOption "CONFIG_486" "${cfg}"
CT_KconfigDisableOption "CONFIG_586" "${cfg}"
CT_KconfigEnableOption "CONFIG_686" "${cfg}"
;;
-mx32)
CT_Abort "uClibc does not support x32 ABI"
;;
esac
done
}
CT_DoArchUClibcHeaderDir() {
local dir_var="${1}"
local cflags="${2}"
# If it is non-default multilib, add a suffix with architecture (reported by gcc)
# to the headers installation path.
if [ -n "${cflags}" ]; then
eval "${dir_var}="$( ${CT_TARGET}-${CT_CC} -print-multiarch ${cflags} )
fi
}
CT_DoArchMUSLHeaderDir() {
local dir_var="${1}"
local cflags="${2}"
# If it is non-default multilib, add a suffix with architecture (reported by gcc)
# to the headers installation path.
if [ -n "${cflags}" ]; then
eval "${dir_var}="$( ${CT_TARGET}-${CT_CC} -print-multiarch ${cflags} )
fi
}
|
