Welcome to mirror list, hosted at ThFree Co, Russian Federation.

bazel_to_cmake.py « cmake - github.com/google/ruy.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
blob: 8f972ba734a891bee6384b566ddba60c120e8915 (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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
#!/usr/bin/env python3
# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""This is yet another bazel-to-cmake converter. It's independently written from
scratch but relies on the same basic idea as others (including IREE's), namely:
to let the python interpreter do the bulk of the work, exploiting the fact that
both Bazel's BUILD syntax and Starlark (".bzl") languages are more or less
subsets of Python.

The main features that this converter supports and that others don't, justifying
its existence as of early 2021, are:
  1. Ad-hoc support for select(), generating CMake if()...elseif()... chains
     parsing the condition keys (e.g. anything ending in ":windows" is
     interpreted as the condition "the target platform is Windows"). This allows
     to just ignore config_setting, as we only care about the config_setting
     names, not their actual implementation, as well as all the variants from
     the Bazel 'selects' library.
  2. Support for load(), loading macros from Starlark files.
"""

import re
import os
import os.path
import pickle
import sys
import datetime
import itertools

# Ruy's dependencies.
external_targets = ['gtest', 'gtest_main', 'cpuinfo']

# Text replacements [oldstring, newstring] pairs, applied on all BUILD and
# Starlark files that we load. Only used by preprocess_input_text.
replacements = [
    ['$(STACK_FRAME_UNLIMITED)', ''],
    ['native.cc_', 'cc_'],
    ['selects.config_setting_group', 'config_setting_group'],
    ['@com_google_googletest//:gtest', 'gtest'],
    ['@com_google_googletest//:gtest_main', 'gtest_main'],
    ['@cpuinfo', 'cpuinfo'],
]


def preprocess_input_text(text):
  result = text
  for replacement in replacements:
    result = result.replace(replacement[0], replacement[1])
  return result


def set_cmake_list(list_name, values, indent):
  semicolon_separated = ';'.join(values)
  print(f'{indent}set({list_name} "{semicolon_separated}")')


def generate_cmake_select(select_name, dict):
  new_if_branch_keyword = 'if'
  default_value = []
  for key in dict:
    condition = ''
    if key == '//conditions:default':
      default_value = dict[key]
      continue
    elif re.search(r':windows$', key):
      condition = 'CMAKE_SYSTEM_NAME STREQUAL Windows'
    elif re.search(r':ppc$', key):
      condition = ('CMAKE_SYSTEM_PROCESSOR STREQUAL ppc64 OR '
                   'CMAKE_SYSTEM_PROCESSOR STREQUAL ppc64le')
    elif re.search(r':s390x$', key):
      condition = ('CMAKE_SYSTEM_PROCESSOR STREQUAL s390 OR '
                   'CMAKE_SYSTEM_PROCESSOR STREQUAL s390x')
    elif re.search(r':fuchsia$', key):
      condition = 'CMAKE_SYSTEM_NAME STREQUAL Fuchsia'
    elif re.search(r':arm32_assuming_neon$', key):
      condition = 'CMAKE_SYSTEM_PROCESSOR STREQUAL arm'
    elif re.search(r':do_not_want_O3$', key):
      # Ruy is a specialist library: we always want code to be compiled
      # with -O3 unless the build type is Debug or the compiler does not
      # support that flag syntax.
      condition = '(CMAKE_BUILD_TYPE STREQUAL Debug) OR MSVC'
    elif re.search(r':x86_64_and_not_msvc$', key):
      condition = ('(CMAKE_SYSTEM_PROCESSOR STREQUAL x86_64 OR '
                   'CMAKE_SYSTEM_PROCESSOR STREQUAL amd64) AND NOT MSVC')
    elif re.search(r':windows_msvc$', key):
      condition = 'MSVC'
    elif re.search(r':ruy_profiler$', key):
      condition = '${RUY_PROFILER}'
    else:
      raise ValueError(f'Unhandled key in select: {key}')

    print(f'{new_if_branch_keyword}({condition})')
    set_cmake_list(select_name, dict[key], '  ')
    new_if_branch_keyword = 'elseif'

  print('else()')
  set_cmake_list(select_name, default_value, '  ')

  print('endif()\n')


def trim_multiple_ruy_prefixes(name):
  return re.sub(r'(ruy_)+ruy', 'ruy', name)


def get_cmake_local_target_name(name):
  global package_prefix
  return trim_multiple_ruy_prefixes(f'ruy_{package_prefix}_{name}')


def get_cmake_dep_target_name(name):
  if name in external_targets:
    return name
  if name.startswith('$'):
    # Happens for deps that are the result of expanding a select() that we
    # have compiled to expanding a variable.
    return name
  if name.startswith('//'):
    after_last_slash = name.split('/')[-1]
    if ':' not in after_last_slash:
      name = f'{name}:{after_last_slash}'
    raw = name[2:].replace('/', '_').replace(':', '_')
    return trim_multiple_ruy_prefixes(raw)
  if name.startswith(':'):
    name = name[1:]
  return get_cmake_local_target_name(name)


#
# Functions implementing BUILD functions
#


def package(**kwargs):
  pass


def exports_files(*args):
  pass


def load(filename, *args):
  if filename.startswith('@'):
    return
  elif filename.startswith(':'):
    filename = os.path.join(bazel_package_dir, filename[1:])
  elif filename.startswith('//'):
    split = filename[2:].split(':')
    filename = os.path.join(bazel_workspace_dir, split[0], split[1])

  src_file_content = open(filename).read()
  processed_file_content = preprocess_input_text(src_file_content)
  exec(processed_file_content, globals(), globals())


def config_setting(**kwargs):
  # Nothing to do since our implementation of select() is based on parsing
  # the names of config_settings, not looking deep into their actual
  # implementation.
  pass


def filegroup(**kwargs):
  pass


def config_setting_group(**kwargs):
  # See config_setting.
  pass


def bzl_library(**kwargs):
  pass


select_index = 0
select_cache = {}


def select(select_dict):
  global select_index
  global select_cache
  global package_prefix
  key = pickle.dumps(sorted(select_dict.items()))
  if key in select_cache:
    select_name = select_cache[key]
  else:
    unique_values = sorted(
        set(itertools.chain.from_iterable(select_dict.values()))
    )  # sorting ensures determinism, no spurious diffs
    description = '_'.join(unique_values)
    select_name = f'{package_prefix}_{select_index}_{description}'
    select_name = select_name.replace('c++', 'cxx')
    select_name = re.sub(r'[^a-zA-Z0-9]+', '_', select_name)
    select_index = select_index + 1
    select_cache[key] = select_name
    generate_cmake_select(select_name, select_dict)

  return [f'${{{select_name}}}']


def generic_rule(rule_name, **kwargs):
  print(f'{rule_name}(')
  for key in kwargs.keys():
    values = kwargs[key]
    if type(values) is bool:
      if values:
        print(f'  {key.upper()}')
        continue
      else:
        raise ValueError('Cannot specify FALSE boolean args in CMake')
    if key == 'visibility':
      if values == ['//visibility:public']:
        print(f'  PUBLIC')
      continue
    if key == 'tags':
      values = list(filter(lambda x: not x.startswith('req_dep'), values))
    if not values:
      continue
    print(f'  {key.upper()}')
    if type(values) is list:
      for value in values:
        if key == 'deps':
          target_name = get_cmake_dep_target_name(value)
          print(f'    {target_name}')
        else:
          print(f'    {value}')
    else:
      if key == 'name':
        target_name = get_cmake_local_target_name(values)
        print(f'    {target_name}')
      else:
        print(f'    {values}')
  print(')\n')


def cc_library(**kwargs):
  generic_rule('ruy_cc_library', **kwargs)


def cc_test(**kwargs):
  generic_rule('ruy_cc_test', **kwargs)


def cc_binary(**kwargs):
  generic_rule('ruy_cc_binary', **kwargs)


#
# Program entry point.
#
if __name__ == "__main__":
  if len(sys.argv) != 3:
    print('Usage: bazel_to_cmake.py bazel_workspace_dir bazel_package_dir')
    sys.exit(1)

  bazel_workspace_dir = sys.argv[1]
  bazel_package_dir = sys.argv[2]
  bazel_package_relative_dir = os.path.relpath(bazel_package_dir,
                                               bazel_workspace_dir)
  package_prefix = bazel_package_relative_dir.replace(os.path.sep, '_')

  print("""# This file is generated (whence no license header). Do not edit!
# To regenerate, run:
#   cmake/bazel_to_cmake.sh
""")

  src_build_file = os.path.join(bazel_package_dir, 'BUILD')
  src_build_content = open(src_build_file).read()
  processed_build_content = preprocess_input_text(src_build_content)
  exec(processed_build_content)

  print('ruy_add_all_subdirs()')