Alexandre Rames | b78f139 | 2016-07-01 14:22:22 +0100 | [diff] [blame] | 1 | # Copyright 2015, VIXL authors |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 2 | # All rights reserved. |
| 3 | # |
| 4 | # Redistribution and use in source and binary forms, with or without |
| 5 | # modification, are permitted provided that the following conditions are met: |
| 6 | # |
| 7 | # * Redistributions of source code must retain the above copyright notice, |
| 8 | # this list of conditions and the following disclaimer. |
| 9 | # * Redistributions in binary form must reproduce the above copyright notice, |
| 10 | # this list of conditions and the following disclaimer in the documentation |
| 11 | # and/or other materials provided with the distribution. |
| 12 | # * Neither the name of ARM Limited nor the names of its contributors may be |
| 13 | # used to endorse or promote products derived from this software without |
| 14 | # specific prior written permission. |
| 15 | # |
| 16 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND |
| 17 | # ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| 18 | # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| 19 | # DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE |
| 20 | # FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| 21 | # DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| 22 | # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| 23 | # CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| 24 | # OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| 25 | # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 27 | import glob |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 28 | import itertools |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 29 | import os |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 30 | from os.path import join |
armvixl | c68cb64 | 2014-09-25 18:49:30 +0100 | [diff] [blame] | 31 | import platform |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 32 | import subprocess |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 33 | import sys |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 34 | from collections import OrderedDict |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 35 | |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 36 | root_dir = os.path.dirname(File('SConstruct').rfile().abspath) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 37 | sys.path.insert(0, join(root_dir, 'tools')) |
| 38 | import config |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 39 | import util |
| 40 | |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 41 | from SCons.Errors import UserError |
| 42 | |
armvixl | c68cb64 | 2014-09-25 18:49:30 +0100 | [diff] [blame] | 43 | |
| 44 | Help(''' |
| 45 | Build system for the VIXL project. |
| 46 | See README.md for documentation and details about the build system. |
armvixl | c68cb64 | 2014-09-25 18:49:30 +0100 | [diff] [blame] | 47 | ''') |
| 48 | |
| 49 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 50 | # We track top-level targets to automatically generate help and alias them. |
Pierre Langlois | 287e6d1 | 2016-11-21 14:56:01 +0000 | [diff] [blame] | 51 | class VIXLTargets: |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 52 | def __init__(self): |
| 53 | self.targets = [] |
| 54 | self.help_messages = [] |
| 55 | def Add(self, target, help_message): |
| 56 | self.targets.append(target) |
| 57 | self.help_messages.append(help_message) |
| 58 | def Help(self): |
armvixl | 684cd2a | 2015-10-23 13:38:33 +0100 | [diff] [blame] | 59 | res = "" |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 60 | for i in range(len(self.targets)): |
| 61 | res += '\t{0:<{1}}{2:<{3}}\n'.format( |
| 62 | 'scons ' + self.targets[i], |
| 63 | len('scons ') + max(map(len, self.targets)), |
| 64 | ' : ' + self.help_messages[i], |
| 65 | len(' : ') + max(map(len, self.help_messages))) |
| 66 | return res |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 67 | |
Pierre Langlois | 287e6d1 | 2016-11-21 14:56:01 +0000 | [diff] [blame] | 68 | top_level_targets = VIXLTargets() |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 69 | |
| 70 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 71 | |
| 72 | # Build options ---------------------------------------------------------------- |
| 73 | |
| 74 | # Store all the options in a dictionary. |
| 75 | # The SConstruct will check the build variables and construct the build |
| 76 | # environment as appropriate. |
| 77 | options = { |
| 78 | 'all' : { # Unconditionally processed. |
| 79 | 'CCFLAGS' : ['-Wall', |
| 80 | '-Werror', |
| 81 | '-fdiagnostics-show-option', |
| 82 | '-Wextra', |
| 83 | '-Wredundant-decls', |
| 84 | '-pedantic', |
Alexandre Rames | fd09817 | 2016-08-09 10:29:53 +0100 | [diff] [blame] | 85 | '-Wwrite-strings', |
Jacob Bramley | cff5a2e | 2019-03-15 09:34:56 +0000 | [diff] [blame] | 86 | '-Wunused', |
| 87 | '-Wno-missing-noreturn'], |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 88 | 'CPPPATH' : [config.dir_src_vixl] |
| 89 | }, |
| 90 | # 'build_option:value' : { |
| 91 | # 'environment_key' : 'values to append' |
| 92 | # }, |
| 93 | 'mode:debug' : { |
| 94 | 'CCFLAGS' : ['-DVIXL_DEBUG', '-O0'] |
| 95 | }, |
| 96 | 'mode:release' : { |
Alexandre Rames | fa4a4bd | 2016-07-25 14:14:22 +0100 | [diff] [blame] | 97 | 'CCFLAGS' : ['-O3'], |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 98 | }, |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 99 | 'simulator:aarch64' : { |
Pierre Langlois | 1e85b7f | 2016-08-05 14:20:36 +0100 | [diff] [blame] | 100 | 'CCFLAGS' : ['-DVIXL_INCLUDE_SIMULATOR_AARCH64'], |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 101 | }, |
| 102 | 'symbols:on' : { |
| 103 | 'CCFLAGS' : ['-g'], |
| 104 | 'LINKFLAGS' : ['-g'] |
| 105 | }, |
Georgia Kouveli | 38d5d1b | 2016-11-16 11:58:41 +0000 | [diff] [blame] | 106 | 'negative_testing:on' : { |
| 107 | 'CCFLAGS' : ['-DVIXL_NEGATIVE_TESTING'] |
Jacob Bramley | 1fa6f06 | 2016-12-19 11:40:08 +0000 | [diff] [blame] | 108 | }, |
| 109 | 'code_buffer_allocator:mmap' : { |
| 110 | 'CCFLAGS' : ['-DVIXL_CODE_BUFFER_MMAP'] |
| 111 | }, |
| 112 | 'code_buffer_allocator:malloc' : { |
| 113 | 'CCFLAGS' : ['-DVIXL_CODE_BUFFER_MALLOC'] |
Vincent Belliard | 4e52d4d | 2018-04-03 13:34:44 -0700 | [diff] [blame] | 114 | }, |
| 115 | 'ubsan:on' : { |
| 116 | 'CCFLAGS': ['-fsanitize=undefined'], |
| 117 | 'LINKFLAGS': ['-fsanitize=undefined'] |
Georgia Kouveli | 38d5d1b | 2016-11-16 11:58:41 +0000 | [diff] [blame] | 118 | } |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 119 | } |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 120 | |
| 121 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 122 | # A `DefaultVariable` has a default value that depends on elements not known |
| 123 | # when variables are first evaluated. |
| 124 | # Each `DefaultVariable` has a handler that will compute the default value for |
| 125 | # the given environment. |
| 126 | def modifiable_flags_handler(env): |
| 127 | env['modifiable_flags'] = \ |
| 128 | 'on' if 'mode' in env and env['mode'] == 'debug' else 'off' |
armvixl | 6e2c827 | 2015-03-31 11:04:14 +0100 | [diff] [blame] | 129 | |
| 130 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 131 | def symbols_handler(env): |
| 132 | env['symbols'] = 'on' if 'mode' in env and env['mode'] == 'debug' else 'off' |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 133 | |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 134 | def Is32BitHost(env): |
| 135 | return env['host_arch'] in ['aarch32', 'i386'] |
| 136 | |
| 137 | def IsAArch64Host(env): |
| 138 | return env['host_arch'] == 'aarch64' |
| 139 | |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 140 | def CanTargetA32(env): |
| 141 | return 'a32' in env['target'] |
| 142 | |
| 143 | def CanTargetT32(env): |
| 144 | return 't32' in env['target'] |
| 145 | |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 146 | def CanTargetAArch32(env): |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 147 | return CanTargetA32(env) or CanTargetT32(env) |
| 148 | |
| 149 | def CanTargetA64(env): |
| 150 | return 'a64' in env['target'] |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 151 | |
| 152 | def CanTargetAArch64(env): |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 153 | return CanTargetA64(env) |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 154 | |
| 155 | |
| 156 | # By default, include the simulator only if AArch64 is targeted and we are not |
| 157 | # building VIXL natively for AArch64. |
| 158 | def simulator_handler(env): |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 159 | if not IsAArch64Host(env) and CanTargetAArch64(env): |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 160 | env['simulator'] = 'aarch64' |
| 161 | else: |
| 162 | env['simulator'] = 'none' |
| 163 | |
| 164 | |
Jacob Bramley | 1fa6f06 | 2016-12-19 11:40:08 +0000 | [diff] [blame] | 165 | # 'mmap' is required for use with 'mprotect', which is needed for the tests |
| 166 | # (when running natively), so we use it by default where we can. |
| 167 | def code_buffer_allocator_handler(env): |
| 168 | directives = util.GetCompilerDirectives(env) |
| 169 | if '__linux__' in directives: |
| 170 | env['code_buffer_allocator'] = 'mmap' |
| 171 | else: |
| 172 | env['code_buffer_allocator'] = 'malloc' |
| 173 | |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 174 | # A validator checks the consistency of provided options against the environment. |
| 175 | def default_validator(env): |
| 176 | pass |
| 177 | |
| 178 | |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 179 | def simulator_validator(env): |
| 180 | if env['simulator'] == 'aarch64' and not CanTargetAArch64(env): |
| 181 | raise UserError('Building an AArch64 simulator implies that VIXL targets ' |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 182 | 'AArch64. Set `target` to include `aarch64` or `a64`.') |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 183 | |
| 184 | |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 185 | # Default variables may depend on each other, therefore we need this dictionnary |
| 186 | # to be ordered. |
| 187 | vars_default_handlers = OrderedDict({ |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 188 | # variable_name : [ 'default val', 'handler', 'validator'] |
| 189 | 'symbols' : [ 'mode==debug', symbols_handler, default_validator ], |
| 190 | 'modifiable_flags' : [ 'mode==debug', modifiable_flags_handler, default_validator], |
Jacob Bramley | 1fa6f06 | 2016-12-19 11:40:08 +0000 | [diff] [blame] | 191 | 'simulator' : [ 'on if the target architectures include AArch64 but ' |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 192 | 'the host is not AArch64, else off', |
Jacob Bramley | 1fa6f06 | 2016-12-19 11:40:08 +0000 | [diff] [blame] | 193 | simulator_handler, simulator_validator ], |
| 194 | 'code_buffer_allocator' : [ 'mmap with __linux__, malloc otherwise', |
| 195 | code_buffer_allocator_handler, default_validator ] |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 196 | }) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 197 | |
| 198 | |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 199 | def DefaultVariable(name, help, allowed_values): |
| 200 | help = '%s (%s)' % (help, '|'.join(allowed_values)) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 201 | default_value = vars_default_handlers[name][0] |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 202 | def validator(name, value, env): |
| 203 | if value != default_value and value not in allowed_values: |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 204 | raise UserError('Invalid value for option {name}: {value}. ' |
| 205 | 'Valid values are: {allowed_values}'.format( |
| 206 | name, value, allowed_values)) |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 207 | return (name, help, default_value, validator) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 208 | |
| 209 | |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 210 | def SortListVariable(iterator): |
| 211 | # Previously this code relied on the order of items in a list |
| 212 | # converted from a set. However in Python 3 the order changes each run. |
| 213 | # Here we do a custom partial sort to ensure that the build directory |
| 214 | # name is stable, the same across Python 2 and 3, and the same as the |
| 215 | # old code. |
| 216 | result = list(sorted(iterator)) |
| 217 | result = sorted(result, key=lambda x: x == 't32', reverse=True) |
| 218 | result = sorted(result, key=lambda x: x == 'a32', reverse=True) |
| 219 | result = sorted(result, key=lambda x: x == 'a64', reverse=True) |
| 220 | return result |
| 221 | |
| 222 | |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 223 | def AliasedListVariable(name, help, default_value, allowed_values, aliasing): |
| 224 | help = '%s (all|auto|comma-separated list) (any combination from [%s])' % \ |
| 225 | (help, ', '.join(allowed_values)) |
| 226 | |
| 227 | def validator(name, value, env): |
| 228 | # Here list has been converted to space separated strings. |
| 229 | if value == '': return # auto |
| 230 | for v in value.split(): |
| 231 | if v not in allowed_values: |
| 232 | raise UserError('Invalid value for %s: %s' % (name, value)) |
| 233 | |
| 234 | def converter(value): |
| 235 | if value == 'auto': return [] |
| 236 | if value == 'all': |
| 237 | translated = [aliasing[v] for v in allowed_values] |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 238 | return SortListVariable(itertools.chain.from_iterable(translated)) |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 239 | # The validator is run later hence the get. |
| 240 | translated = [aliasing.get(v, v) for v in value.split(',')] |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 241 | return SortListVariable(itertools.chain.from_iterable(translated)) |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 242 | |
| 243 | return (name, help, default_value, validator, converter) |
| 244 | |
| 245 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 246 | vars = Variables() |
| 247 | # Define command line build options. |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 248 | vars.AddVariables( |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 249 | AliasedListVariable('target', 'Target ISA/Architecture', 'auto', |
| 250 | ['aarch32', 'a32', 't32', 'aarch64', 'a64'], |
| 251 | {'aarch32' : ['a32', 't32'], |
| 252 | 'a32' : ['a32'], 't32' : ['t32'], |
| 253 | 'aarch64' : ['a64'], 'a64' : ['a64']}), |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 254 | EnumVariable('mode', 'Build mode', |
| 255 | 'release', allowed_values=config.build_options_modes), |
Vincent Belliard | 4e52d4d | 2018-04-03 13:34:44 -0700 | [diff] [blame] | 256 | EnumVariable('ubsan', 'Enable undefined behavior checks', |
| 257 | 'off', allowed_values=['on', 'off']), |
Jacob Bramley | 1fa6f06 | 2016-12-19 11:40:08 +0000 | [diff] [blame] | 258 | EnumVariable('negative_testing', |
| 259 | 'Enable negative testing (needs exceptions)', |
Georgia Kouveli | 38d5d1b | 2016-11-16 11:58:41 +0000 | [diff] [blame] | 260 | 'off', allowed_values=['on', 'off']), |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 261 | DefaultVariable('symbols', 'Include debugging symbols in the binaries', |
| 262 | ['on', 'off']), |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 263 | DefaultVariable('simulator', 'Simulators to include', ['aarch64', 'none']), |
Jacob Bramley | 1fa6f06 | 2016-12-19 11:40:08 +0000 | [diff] [blame] | 264 | DefaultVariable('code_buffer_allocator', |
| 265 | 'Configure the allocation mechanism in the CodeBuffer', |
| 266 | ['malloc', 'mmap']), |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 267 | ('std', |
| 268 | 'C++ standard. The standards tested are: %s.' % \ |
| 269 | ', '.join(config.tested_cpp_standards), |
| 270 | config.tested_cpp_standards[0]), |
Anthony Barbier | 9c4ba7a | 2019-02-15 15:20:25 +0000 | [diff] [blame] | 271 | ('compiler_wrapper', 'Command to prefix to the C and C++ compiler (e.g ccache)', '') |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 272 | ) |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 273 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 274 | # We use 'variant directories' to avoid recompiling multiple times when build |
| 275 | # options are changed, different build paths are used depending on the options |
| 276 | # set. These are the options that should be reflected in the build directory |
| 277 | # path. |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 278 | options_influencing_build_path = [ |
Anthony Barbier | 9c4ba7a | 2019-02-15 15:20:25 +0000 | [diff] [blame] | 279 | 'target', 'mode', 'symbols', 'compiler', 'std', 'simulator', 'negative_testing', |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 280 | 'code_buffer_allocator' |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 281 | ] |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 282 | |
armvixl | ad96eda | 2013-06-14 11:42:37 +0100 | [diff] [blame] | 283 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 284 | |
| 285 | # Build helpers ---------------------------------------------------------------- |
| 286 | |
| 287 | def RetrieveEnvironmentVariables(env): |
Pierre Langlois | 88c46b8 | 2016-06-02 18:15:32 +0100 | [diff] [blame] | 288 | for key in ['CC', 'CXX', 'AR', 'RANLIB', 'LD']: |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 289 | if os.getenv(key): env[key] = os.getenv(key) |
| 290 | if os.getenv('LD_LIBRARY_PATH'): env['LIBPATH'] = os.getenv('LD_LIBRARY_PATH') |
Pierre Langlois | 88c46b8 | 2016-06-02 18:15:32 +0100 | [diff] [blame] | 291 | if os.getenv('CCFLAGS'): |
| 292 | env.Append(CCFLAGS = os.getenv('CCFLAGS').split()) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 293 | if os.getenv('CXXFLAGS'): |
| 294 | env.Append(CXXFLAGS = os.getenv('CXXFLAGS').split()) |
| 295 | if os.getenv('LINKFLAGS'): |
| 296 | env.Append(LINKFLAGS = os.getenv('LINKFLAGS').split()) |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 297 | |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 298 | # The architecture targeted by default will depend on the compiler being |
| 299 | # used. 'host_arch' is extracted from the compiler while 'target' can be |
| 300 | # set by the user. |
| 301 | # By default, we target both AArch32 and AArch64 unless the compiler targets a |
| 302 | # 32-bit architecture. At the moment, we cannot build VIXL's AArch64 support on |
| 303 | # a 32-bit platform. |
| 304 | # TODO: Port VIXL to build on a 32-bit platform. |
| 305 | def target_handler(env): |
| 306 | # Auto detect |
| 307 | if Is32BitHost(env): |
| 308 | # We use list(set(...)) to keep the same order as if it was specify as |
| 309 | # an option. |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 310 | env['target'] = SortListVariable(['a32', 't32']) |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 311 | else: |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 312 | env['target'] = SortListVariable(['a64', 'a32', 't32']) |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 313 | |
| 314 | |
| 315 | def target_validator(env): |
| 316 | # TODO: Port VIXL64 to work on a 32-bit platform. |
| 317 | if Is32BitHost(env) and CanTargetAArch64(env): |
| 318 | raise UserError('Building VIXL for AArch64 in 32-bit is not supported. Set ' |
| 319 | '`target` to `aarch32`') |
| 320 | |
| 321 | |
| 322 | # The target option is handled differently from the rest. |
| 323 | def ProcessTargetOption(env): |
| 324 | if env['target'] == []: target_handler(env) |
| 325 | |
| 326 | if 'a32' in env['target']: env['CCFLAGS'] += ['-DVIXL_INCLUDE_TARGET_A32'] |
| 327 | if 't32' in env['target']: env['CCFLAGS'] += ['-DVIXL_INCLUDE_TARGET_T32'] |
| 328 | if 'a64' in env['target']: env['CCFLAGS'] += ['-DVIXL_INCLUDE_TARGET_A64'] |
| 329 | |
| 330 | target_validator(env) |
| 331 | |
| 332 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 333 | def ProcessBuildOptions(env): |
| 334 | # 'all' is unconditionally processed. |
| 335 | if 'all' in options: |
| 336 | for var in options['all']: |
| 337 | if var in env and env[var]: |
| 338 | env[var] += options['all'][var] |
| 339 | else: |
| 340 | env[var] = options['all'][var] |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 341 | |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 342 | # The target option *must* be processed before the options defined in |
| 343 | # vars_default_handlers. |
| 344 | ProcessTargetOption(env) |
| 345 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 346 | # Other build options must match 'option:value' |
| 347 | env_dict = env.Dictionary() |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 348 | |
| 349 | # First apply the default variables handlers in order. |
| 350 | for key, value in vars_default_handlers.items(): |
| 351 | default = value[0] |
| 352 | handler = value[1] |
| 353 | if env_dict.get(key) == default: |
| 354 | handler(env_dict) |
| 355 | |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 356 | # Second, run the series of validators, to check for errors. |
| 357 | for _, value in vars_default_handlers.items(): |
| 358 | validator = value[2] |
| 359 | validator(env) |
| 360 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 361 | for key in env_dict.keys(): |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 362 | # Then update the environment according to the value of the variable. |
| 363 | key_val_couple = key + ':%s' % env_dict[key] |
| 364 | if key_val_couple in options: |
| 365 | for var in options[key_val_couple]: |
| 366 | env[var] += options[key_val_couple][var] |
| 367 | |
| 368 | |
| 369 | def ConfigureEnvironmentForCompiler(env): |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 370 | compiler = util.CompilerInformation(env) |
Pierre Langlois | f737e0a | 2016-11-02 13:08:11 +0000 | [diff] [blame] | 371 | if compiler == 'clang': |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 372 | # These warnings only work for Clang. |
| 373 | # -Wimplicit-fallthrough only works when compiling the code base as C++11 or |
| 374 | # newer. The compiler does not complain if the option is passed when |
| 375 | # compiling earlier C++ standards. |
| 376 | env.Append(CPPFLAGS = ['-Wimplicit-fallthrough', '-Wshorten-64-to-32']) |
| 377 | |
| 378 | # The '-Wunreachable-code' flag breaks builds for clang 3.4. |
Jacob Bramley | 176a379 | 2016-11-09 14:44:39 +0000 | [diff] [blame] | 379 | if compiler != 'clang-3.4': |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 380 | env.Append(CPPFLAGS = ['-Wunreachable-code']) |
| 381 | |
Vincent Belliard | 4e52d4d | 2018-04-03 13:34:44 -0700 | [diff] [blame] | 382 | if env['ubsan'] == 'on': |
| 383 | env.Append(LINKFLAGS = ['-fuse-ld=lld']) |
| 384 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 385 | # GCC 4.8 has a bug which produces a warning saying that an anonymous Operand |
| 386 | # object might be used uninitialized: |
| 387 | # http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57045 |
| 388 | # The bug does not seem to appear in GCC 4.7, or in debug builds with GCC 4.8. |
| 389 | if env['mode'] == 'release': |
Pierre Langlois | f737e0a | 2016-11-02 13:08:11 +0000 | [diff] [blame] | 390 | if compiler == 'gcc-4.8': |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 391 | env.Append(CPPFLAGS = ['-Wno-maybe-uninitialized']) |
Pierre Langlois | f737e0a | 2016-11-02 13:08:11 +0000 | [diff] [blame] | 392 | |
Pierre Langlois | f7bf655 | 2017-05-05 13:14:35 +0100 | [diff] [blame] | 393 | # GCC 6 and higher is able to detect throwing from inside a destructor and |
| 394 | # reports a warning. However, if negative testing is enabled then assertions |
| 395 | # will throw exceptions. |
| 396 | if env['negative_testing'] == 'on' and env['mode'] == 'debug' \ |
| 397 | and compiler >= 'gcc-6': |
| 398 | env.Append(CPPFLAGS = ['-Wno-terminate']) |
Pierre Langlois | f7bf655 | 2017-05-05 13:14:35 +0100 | [diff] [blame] | 399 | |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 400 | # Suggest missing override keywords on methods. |
| 401 | if compiler >= 'gcc-5': |
| 402 | env.Append(CPPFLAGS = ['-Wsuggest-override']) |
| 403 | elif compiler >= 'clang-3.6': |
| 404 | env.Append(CPPFLAGS = ['-Winconsistent-missing-override']) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 405 | |
| 406 | |
| 407 | def ConfigureEnvironment(env): |
| 408 | RetrieveEnvironmentVariables(env) |
Anthony Barbier | 9c4ba7a | 2019-02-15 15:20:25 +0000 | [diff] [blame] | 409 | env['compiler'] = env['CXX'] |
| 410 | if env['compiler_wrapper'] != '': |
| 411 | env['CXX'] = env['compiler_wrapper'] + ' ' + env['CXX'] |
| 412 | env['CC'] = env['compiler_wrapper'] + ' ' + env['CC'] |
Pierre Langlois | 8253a3c | 2016-12-14 18:54:22 +0000 | [diff] [blame] | 413 | env['host_arch'] = util.GetHostArch(env) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 414 | ProcessBuildOptions(env) |
| 415 | if 'std' in env: |
| 416 | env.Append(CPPFLAGS = ['-std=' + env['std']]) |
| 417 | std_path = env['std'] |
| 418 | ConfigureEnvironmentForCompiler(env) |
| 419 | |
| 420 | |
| 421 | def TargetBuildDir(env): |
| 422 | # Build-time option values are embedded in the build path to avoid requiring a |
| 423 | # full build when an option changes. |
| 424 | build_dir = config.dir_build |
| 425 | for option in options_influencing_build_path: |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 426 | option_value = ''.join(env[option]) if option in env else '' |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 427 | build_dir = join(build_dir, option + '_'+ option_value) |
| 428 | return build_dir |
| 429 | |
| 430 | |
| 431 | def PrepareVariantDir(location, build_dir): |
| 432 | location_build_dir = join(build_dir, location) |
| 433 | VariantDir(location_build_dir, location) |
| 434 | return location_build_dir |
| 435 | |
| 436 | |
| 437 | def VIXLLibraryTarget(env): |
| 438 | build_dir = TargetBuildDir(env) |
| 439 | # Create a link to the latest build directory. |
Alexandre Rames | 4e24193 | 2016-06-08 21:32:03 +0100 | [diff] [blame] | 440 | # Use `-r` to avoid failure when `latest` exists and is a directory. |
| 441 | subprocess.check_call(["rm", "-rf", config.dir_build_latest]) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 442 | util.ensure_dir(build_dir) |
| 443 | subprocess.check_call(["ln", "-s", build_dir, config.dir_build_latest]) |
Alexandre Rames | d383296 | 2016-07-04 15:03:43 +0100 | [diff] [blame] | 444 | # Source files are in `src` and in `src/aarch64/`. |
Alexandre Rames | 39c32a6 | 2016-05-23 15:47:22 +0100 | [diff] [blame] | 445 | variant_dir_vixl = PrepareVariantDir(join('src'), build_dir) |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 446 | sources = [Glob(join(variant_dir_vixl, '*.cc'))] |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 447 | if CanTargetAArch32(env): |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 448 | variant_dir_aarch32 = PrepareVariantDir(join('src', 'aarch32'), build_dir) |
| 449 | sources.append(Glob(join(variant_dir_aarch32, '*.cc'))) |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 450 | if CanTargetAArch64(env): |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 451 | variant_dir_aarch64 = PrepareVariantDir(join('src', 'aarch64'), build_dir) |
| 452 | sources.append(Glob(join(variant_dir_aarch64, '*.cc'))) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 453 | return env.Library(join(build_dir, 'vixl'), sources) |
| 454 | |
| 455 | |
| 456 | |
| 457 | # Build ------------------------------------------------------------------------ |
| 458 | |
| 459 | # The VIXL library, built by default. |
Pierre Langlois | 287e6d1 | 2016-11-21 14:56:01 +0000 | [diff] [blame] | 460 | env = Environment(variables = vars, |
| 461 | BUILDERS = { |
| 462 | 'Markdown': Builder(action = 'markdown $SOURCE > $TARGET', |
| 463 | suffix = '.html') |
Anthony Barbier | f2986e1 | 2019-02-28 16:49:23 +0000 | [diff] [blame] | 464 | }, ENV = os.environ) |
Alexandre Rames | f5de33d | 2016-10-25 09:51:11 +0100 | [diff] [blame] | 465 | # Abort the build if any command line option is unknown or invalid. |
| 466 | unknown_build_options = vars.UnknownVariables() |
| 467 | if unknown_build_options: |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 468 | print('Unknown build options: ' + str(unknown_build_options.keys())) |
Alexandre Rames | f5de33d | 2016-10-25 09:51:11 +0100 | [diff] [blame] | 469 | Exit(1) |
| 470 | |
Anthony Barbier | f2986e1 | 2019-02-28 16:49:23 +0000 | [diff] [blame] | 471 | if env['negative_testing'] == 'on' and env['mode'] != 'debug': |
Artem Serov | 5a229a9 | 2020-11-09 15:26:22 +0000 | [diff] [blame] | 472 | print('negative_testing only works in debug mode') |
Anthony Barbier | f2986e1 | 2019-02-28 16:49:23 +0000 | [diff] [blame] | 473 | Exit(1) |
| 474 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 475 | ConfigureEnvironment(env) |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 476 | Help(vars.GenerateHelpText(env)) |
| 477 | libvixl = VIXLLibraryTarget(env) |
| 478 | Default(libvixl) |
| 479 | env.Alias('libvixl', libvixl) |
| 480 | top_level_targets.Add('', 'Build the VIXL library.') |
| 481 | |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 482 | |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 483 | # Common test code. |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 484 | test_build_dir = PrepareVariantDir('test', TargetBuildDir(env)) |
Pierre Langlois | 88c46b8 | 2016-06-02 18:15:32 +0100 | [diff] [blame] | 485 | test_objects = [env.Object(Glob(join(test_build_dir, '*.cc')))] |
| 486 | |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 487 | # AArch32 support |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 488 | if CanTargetAArch32(env): |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 489 | # The examples. |
| 490 | aarch32_example_names = util.ListCCFilesWithoutExt(config.dir_aarch32_examples) |
| 491 | aarch32_examples_build_dir = PrepareVariantDir('examples/aarch32', TargetBuildDir(env)) |
| 492 | aarch32_example_targets = [] |
| 493 | for example in aarch32_example_names: |
| 494 | prog = env.Program(join(aarch32_examples_build_dir, example), |
| 495 | join(aarch32_examples_build_dir, example + '.cc'), |
| 496 | LIBS=[libvixl]) |
| 497 | aarch32_example_targets.append(prog) |
| 498 | env.Alias('aarch32_examples', aarch32_example_targets) |
| 499 | top_level_targets.Add('aarch32_examples', 'Build the examples for AArch32.') |
Pierre Langlois | 88c46b8 | 2016-06-02 18:15:32 +0100 | [diff] [blame] | 500 | |
Vincent Belliard | 32cf254 | 2016-07-14 10:04:09 -0700 | [diff] [blame] | 501 | # The benchmarks |
| 502 | aarch32_benchmark_names = util.ListCCFilesWithoutExt(config.dir_aarch32_benchmarks) |
| 503 | aarch32_benchmarks_build_dir = PrepareVariantDir('benchmarks/aarch32', TargetBuildDir(env)) |
| 504 | aarch32_benchmark_targets = [] |
| 505 | for bench in aarch32_benchmark_names: |
| 506 | prog = env.Program(join(aarch32_benchmarks_build_dir, bench), |
| 507 | join(aarch32_benchmarks_build_dir, bench + '.cc'), |
| 508 | LIBS=[libvixl]) |
| 509 | aarch32_benchmark_targets.append(prog) |
| 510 | env.Alias('aarch32_benchmarks', aarch32_benchmark_targets) |
| 511 | top_level_targets.Add('aarch32_benchmarks', 'Build the benchmarks for AArch32.') |
| 512 | |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 513 | # The tests. |
| 514 | test_aarch32_build_dir = PrepareVariantDir(join('test', 'aarch32'), TargetBuildDir(env)) |
| 515 | test_objects.append(env.Object( |
| 516 | Glob(join(test_aarch32_build_dir, '*.cc')), |
Anthony Barbier | 7b4df2b | 2019-03-12 17:36:15 +0000 | [diff] [blame] | 517 | CPPPATH = env['CPPPATH'] + [config.dir_tests], |
| 518 | CCFLAGS = [flag for flag in env['CCFLAGS'] if flag != '-O3'])) |
Pierre Langlois | 88c46b8 | 2016-06-02 18:15:32 +0100 | [diff] [blame] | 519 | |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 520 | # AArch64 support |
Rodolph Perfetta | 9a9331f | 2016-12-09 22:05:48 +0000 | [diff] [blame] | 521 | if CanTargetAArch64(env): |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 522 | # The benchmarks. |
| 523 | aarch64_benchmark_names = util.ListCCFilesWithoutExt(config.dir_aarch64_benchmarks) |
| 524 | aarch64_benchmarks_build_dir = PrepareVariantDir('benchmarks/aarch64', TargetBuildDir(env)) |
| 525 | aarch64_benchmark_targets = [] |
Jacob Bramley | 1d925c0 | 2019-06-17 16:51:23 +0100 | [diff] [blame] | 526 | bench_utils = env.Object(join(aarch64_benchmarks_build_dir, 'bench-utils.o'), |
| 527 | join(aarch64_benchmarks_build_dir, 'bench-utils.cc')) |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 528 | for bench in aarch64_benchmark_names: |
Jacob Bramley | 1d925c0 | 2019-06-17 16:51:23 +0100 | [diff] [blame] | 529 | if bench != 'bench-utils': |
| 530 | prog = env.Program(join(aarch64_benchmarks_build_dir, bench), |
| 531 | [join(aarch64_benchmarks_build_dir, bench + '.cc'), bench_utils], |
| 532 | LIBS=[libvixl]) |
| 533 | aarch64_benchmark_targets.append(prog) |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 534 | env.Alias('aarch64_benchmarks', aarch64_benchmark_targets) |
| 535 | top_level_targets.Add('aarch64_benchmarks', 'Build the benchmarks for AArch64.') |
| 536 | |
| 537 | # The examples. |
| 538 | aarch64_example_names = util.ListCCFilesWithoutExt(config.dir_aarch64_examples) |
| 539 | aarch64_examples_build_dir = PrepareVariantDir('examples/aarch64', TargetBuildDir(env)) |
| 540 | aarch64_example_targets = [] |
| 541 | for example in aarch64_example_names: |
| 542 | prog = env.Program(join(aarch64_examples_build_dir, example), |
| 543 | join(aarch64_examples_build_dir, example + '.cc'), |
| 544 | LIBS=[libvixl]) |
| 545 | aarch64_example_targets.append(prog) |
| 546 | env.Alias('aarch64_examples', aarch64_example_targets) |
| 547 | top_level_targets.Add('aarch64_examples', 'Build the examples for AArch64.') |
| 548 | |
| 549 | # The tests. |
| 550 | test_aarch64_build_dir = PrepareVariantDir(join('test', 'aarch64'), TargetBuildDir(env)) |
| 551 | test_objects.append(env.Object( |
| 552 | Glob(join(test_aarch64_build_dir, '*.cc')), |
Anthony Barbier | 7b4df2b | 2019-03-12 17:36:15 +0000 | [diff] [blame] | 553 | CPPPATH = env['CPPPATH'] + [config.dir_tests], |
| 554 | CCFLAGS = [flag for flag in env['CCFLAGS'] if flag != '-O3'])) |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 555 | |
| 556 | # The test requires building the example files with specific options, so we |
| 557 | # create a separate variant dir for the example objects built this way. |
| 558 | test_aarch64_examples_vdir = join(TargetBuildDir(env), 'test', 'aarch64', 'test_examples') |
| 559 | VariantDir(test_aarch64_examples_vdir, '.') |
| 560 | test_aarch64_examples_obj = env.Object( |
Jacob Bramley | 0f71a76 | 2018-08-30 12:09:34 +0100 | [diff] [blame] | 561 | [Glob(join(test_aarch64_examples_vdir, join('test', 'aarch64', 'examples', '*.cc'))), |
Pierre Langlois | a3b2146 | 2016-08-04 16:01:51 +0100 | [diff] [blame] | 562 | Glob(join(test_aarch64_examples_vdir, join('examples/aarch64', '*.cc')))], |
| 563 | CCFLAGS = env['CCFLAGS'] + ['-DTEST_EXAMPLES'], |
| 564 | CPPPATH = env['CPPPATH'] + [config.dir_aarch64_examples] + [config.dir_tests]) |
| 565 | test_objects.append(test_aarch64_examples_obj) |
Pierre Langlois | 88c46b8 | 2016-06-02 18:15:32 +0100 | [diff] [blame] | 566 | |
| 567 | test = env.Program(join(test_build_dir, 'test-runner'), test_objects, |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 568 | LIBS=[libvixl]) |
| 569 | env.Alias('tests', test) |
| 570 | top_level_targets.Add('tests', 'Build the tests.') |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 571 | |
armvixl | 4a102ba | 2014-07-14 09:02:40 +0100 | [diff] [blame] | 572 | |
armvixl | db64434 | 2015-07-21 11:37:10 +0100 | [diff] [blame] | 573 | env.Alias('all', top_level_targets.targets) |
| 574 | top_level_targets.Add('all', 'Build all the targets above.') |
| 575 | |
| 576 | Help('\n\nAvailable top level targets:\n' + top_level_targets.Help()) |
Pierre Langlois | 287e6d1 | 2016-11-21 14:56:01 +0000 | [diff] [blame] | 577 | |
| 578 | extra_targets = VIXLTargets() |
| 579 | |
| 580 | # Build documentation |
| 581 | doc = [ |
| 582 | env.Markdown('README.md'), |
| 583 | env.Markdown('doc/changelog.md'), |
| 584 | env.Markdown('doc/aarch32/getting-started-aarch32.md'), |
| 585 | env.Markdown('doc/aarch32/design/code-generation-aarch32.md'), |
| 586 | env.Markdown('doc/aarch32/design/literal-pool-aarch32.md'), |
| 587 | env.Markdown('doc/aarch64/supported-instructions-aarch64.md'), |
| 588 | env.Markdown('doc/aarch64/getting-started-aarch64.md'), |
| 589 | env.Markdown('doc/aarch64/topics/ycm.md'), |
| 590 | env.Markdown('doc/aarch64/topics/extending-the-disassembler.md'), |
| 591 | env.Markdown('doc/aarch64/topics/index.md'), |
| 592 | ] |
| 593 | env.Alias('doc', doc) |
| 594 | extra_targets.Add('doc', 'Convert documentation to HTML (requires the ' |
| 595 | '`markdown` program).') |
| 596 | |
| 597 | Help('\nAvailable extra targets:\n' + extra_targets.Help()) |