Verilator

1
######################################################################
2
#
3
# DESCRIPTION: CMake configuration file for Verilator
4
#
5
# Include it in your CMakeLists.txt using:
6
#
7
#     find_package(verilate)
8
#
9
#  This script adds a verilate function.
10
#
11
#     add_executable(simulator <your-c-sources>)
12
#     verilate(simulator SOURCES <your-hdl-sources>)
13
#
14
# Copyright 2003-2024 by Wilson Snyder. This program is free software; you
15
# can redistribute it and/or modify it under the terms of either the GNU
16
# Lesser General Public License Version 3 or the Perl Artistic License
17
# Version 2.0.
18
# SPDX-License-Identifier: LGPL-3.0-only OR Artistic-2.0
19
#
20
######################################################################
21

22
cmake_minimum_required(VERSION 3.13)
23

24
# Prefer VERILATOR_ROOT from environment
25
if (DEFINED ENV{VERILATOR_ROOT})
26
  set(VERILATOR_ROOT "$ENV{VERILATOR_ROOT}" CACHE PATH "VERILATOR_ROOT")
27
endif()
28

29
set(VERILATOR_ROOT "${CMAKE_CURRENT_LIST_DIR}" CACHE PATH "VERILATOR_ROOT")
30

31
find_program(VERILATOR_BIN NAMES verilator_bin verilator_bin.exe
32
  HINTS ${VERILATOR_ROOT}/bin ENV VERILATOR_ROOT
33
  NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH)
34

35
if (NOT VERILATOR_ROOT)
36
  message(FATAL_ERROR "VERILATOR_ROOT cannot be detected. Set it to the appropriate directory (e.g. /usr/share/verilator) as an environment variable or CMake define.")
37
endif()
38

39
if (NOT VERILATOR_BIN)
40
  message(FATAL_ERROR "Cannot find verilator_bin excecutable.")
41
endif()
42

43
set(verilator_FOUND 1)
44

45
include(CheckCXXSourceCompiles)
46
function(_verilator_check_cxx_libraries LIBRARIES RESVAR)
47
  # Check whether a particular link option creates a valid executable
48
  set(_VERILATOR_CHECK_CXX_LINK_OPTIONS_SRC "int main() {return 0;}\n")
49
  set(CMAKE_REQUIRED_FLAGS)
50
  set(CMAKE_REQUIRED_DEFINITIONS)
51
  set(CMAKE_REQUIRED_INCLUDES)
52
  set(CMAKE_REQUIRED_LINK_OPTIONS)
53
  set(CMAKE_REQUIRED_LIBRARIES ${LIBRARIES})
54
  set(CMAKE_REQUIRED_QUIET)
55
  check_cxx_source_compiles("${_VERILATOR_CHECK_CXX_LINK_OPTIONS_SRC}" "${RESVAR}")
56
  set("${RESVAR}" "${${RESVAR}}" PARENT_SCOPE)
57
endfunction()
58

59
# Check compiler flag support. Skip on MSVC, these are all GCC flags.
60
if (NOT CMAKE_CXX_COMPILER_ID MATCHES MSVC)
61
  if (NOT DEFINED VERILATOR_CFLAGS OR NOT DEFINED VERILATOR_MT_CFLAGS)
62
    include(CheckCXXCompilerFlag)
63
    foreach (FLAG @CFG_CXX_FLAGS_CMAKE@)
64
      string(MAKE_C_IDENTIFIER ${FLAG} FLAGNAME)
65
      check_cxx_compiler_flag(${FLAG} ${FLAGNAME})
66
      if (${FLAGNAME})
67
        list(APPEND VERILATOR_CFLAGS ${FLAG})
68
      endif()
69
    endforeach()
70
    foreach (FLAG @CFG_LDFLAGS_THREADS_CMAKE@)
71
      string(MAKE_C_IDENTIFIER ${FLAG} FLAGNAME)
72
      _verilator_check_cxx_libraries("${FLAG}" ${FLAGNAME})
73
      if (${FLAGNAME})
74
        list(APPEND VERILATOR_MT_CFLAGS ${FLAG})
75
      endif()
76
    endforeach()
77
  endif()
78
endif()
79

80
if (${CMAKE_CXX_COMPILER_ID} STREQUAL "AppleClang")
81
  add_link_options(-Wl,-U,__Z15vl_time_stamp64v,-U,__Z13sc_time_stampv)
82
endif()
83

84
define_property(TARGET
85
  PROPERTY VERILATOR_THREADED
86
  BRIEF_DOCS "Deprecated and has no effect (ignored)"
87
  FULL_DOCS "Deprecated and has no effect (ignored)"
88
)
89

90
define_property(TARGET
91
  PROPERTY VERILATOR_TRACE_THREADED
92
  BRIEF_DOCS "Verilator multithread tracing enabled"
93
  FULL_DOCS "Verilator multithread tracing enabled"
94
)
95

96
define_property(TARGET
97
  PROPERTY VERILATOR_TIMING
98
  BRIEF_DOCS "Verilator timing enabled"
99
  FULL_DOCS "Verilator timing enabled"
100
)
101

102
define_property(TARGET
103
  PROPERTY VERILATOR_COVERAGE
104
  BRIEF_DOCS "Verilator coverage enabled"
105
  FULL_DOCS "Verilator coverage enabled"
106
)
107

108
define_property(TARGET
109
  PROPERTY VERILATOR_TRACE
110
  BRIEF_DOCS "Verilator trace enabled"
111
  FULL_DOCS "Verilator trace enabled"
112
)
113

114
define_property(TARGET
115
  PROPERTY VERILATOR_TRACE_VCD
116
  BRIEF_DOCS "Verilator VCD trace enabled"
117
  FULL_DOCS "Verilator VCD trace enabled"
118
)
119

120
define_property(TARGET
121
  PROPERTY VERILATOR_TRACE_FST
122
  BRIEF_DOCS "Verilator FST trace enabled"
123
  FULL_DOCS "Verilator FST trace enabled"
124
)
125

126
define_property(TARGET
127
  PROPERTY VERILATOR_SYSTEMC
128
  BRIEF_DOCS "Verilator SystemC enabled"
129
  FULL_DOCS "Verilator SystemC enabled"
130
)
131

132
define_property(TARGET
133
    PROPERTY VERILATOR_TRACE_STRUCTS
134
    BRIEF_DOCS "Verilator trace structs enabled"
135
    FULL_DOCS "Verilator trace structs enabled"
136
)
137

138

139
function(verilate TARGET)
140
  cmake_parse_arguments(VERILATE "COVERAGE;TRACE;TRACE_FST;SYSTEMC;TRACE_STRUCTS"
141
                                 "PREFIX;TOP_MODULE;THREADS;TRACE_THREADS;DIRECTORY"
142
                                 "SOURCES;VERILATOR_ARGS;INCLUDE_DIRS;OPT_SLOW;OPT_FAST;OPT_GLOBAL"
143
                                 ${ARGN})
144
  if (NOT VERILATE_SOURCES)
145
    message(FATAL_ERROR "Need at least one source")
146
  endif()
147

148
  if (NOT VERILATE_PREFIX)
149
    list(LENGTH VERILATE_SOURCES NUM_SOURCES)
150
    if (${NUM_SOURCES} GREATER 1)
151
      message(WARNING "Specify PREFIX if there are multiple SOURCES")
152
    endif()
153
    list(GET VERILATE_SOURCES 0 TOPSRC)
154
    get_filename_component(_SRC_NAME ${TOPSRC} NAME_WE)
155
    string(MAKE_C_IDENTIFIER V${_SRC_NAME} VERILATE_PREFIX)
156
  endif()
157

158
  if (VERILATE_TOP_MODULE)
159
    list(APPEND VERILATOR_ARGS --top ${VERILATE_TOP_MODULE})
160
  endif()
161

162
  if (VERILATE_THREADS)
163
    list(APPEND VERILATOR_ARGS --threads ${VERILATE_THREADS})
164
  endif()
165

166
  if (VERILATE_TRACE_THREADS)
167
    list(APPEND VERILATOR_ARGS --trace-threads ${VERILATE_TRACE_THREADS})
168
  endif()
169

170
  if (VERILATE_COVERAGE)
171
    list(APPEND VERILATOR_ARGS --coverage)
172
  endif()
173

174
  if (VERILATE_TRACE AND VERILATE_TRACE_FST)
175
    message(FATAL_ERROR "Cannot have both TRACE and TRACE_FST")
176
  endif()
177

178
  if (VERILATE_TRACE)
179
    list(APPEND VERILATOR_ARGS --trace)
180
  endif()
181

182
  if (VERILATE_TRACE_FST)
183
    list(APPEND VERILATOR_ARGS --trace-fst)
184
  endif()
185

186
  if (VERILATE_SYSTEMC)
187
    list(APPEND VERILATOR_ARGS --sc)
188
  else()
189
    list(APPEND VERILATOR_ARGS --cc)
190
  endif()
191

192
  if (VERILATE_TRACE_STRUCTS)
193
      list(APPEND VERILATOR_ARGS --trace-structs)
194
  endif()
195

196
  foreach(INC ${VERILATE_INCLUDE_DIRS})
197
    list(APPEND VERILATOR_ARGS -y "${INC}")
198
  endforeach()
199

200
  string(TOLOWER ${CMAKE_CXX_COMPILER_ID} COMPILER)
201
  if (COMPILER STREQUAL "appleclang")
202
    set(COMPILER clang)
203
  elseif (NOT COMPILER MATCHES "^msvc$|^clang$")
204
    set(COMPILER gcc)
205
  endif()
206

207
  get_target_property(BINARY_DIR "${TARGET}" BINARY_DIR)
208
  get_target_property(TARGET_NAME "${TARGET}" NAME)
209
  set(VDIR "${BINARY_DIR}/CMakeFiles/${TARGET_NAME}.dir/${VERILATE_PREFIX}.dir")
210

211
  if (VERILATE_DIRECTORY)
212
    set(VDIR "${VERILATE_DIRECTORY}")
213
  endif()
214

215
  file(MAKE_DIRECTORY ${VDIR})
216

217
  set(VERILATOR_COMMAND "${CMAKE_COMMAND}" -E env "VERILATOR_ROOT=${VERILATOR_ROOT}"
218
                        "${VERILATOR_BIN}" --compiler ${COMPILER}
219
                        --prefix ${VERILATE_PREFIX} --Mdir ${VDIR} --make cmake
220
                        ${VERILATOR_ARGS} ${VERILATE_VERILATOR_ARGS}
221
                        ${VERILATE_SOURCES})
222

223
  set(VARGS_FILE "${VDIR}/verilator_args.txt")
224
  set(VCMAKE "${VDIR}/${VERILATE_PREFIX}.cmake")
225
  set(VCMAKE_COPY "${VDIR}/${VERILATE_PREFIX}_copy.cmake")
226

227
  if (NOT EXISTS "${VARGS_FILE}" OR NOT EXISTS "${VCMAKE_COPY}")
228
    set(VERILATOR_OUTDATED ON)
229
  else()
230
    file(READ "${VARGS_FILE}" PREVIOUS_VERILATOR_COMMAND)
231
    if(NOT VERILATOR_COMMAND STREQUAL PREVIOUS_VERILATOR_COMMAND)
232
      set(VERILATOR_OUTDATED ON)
233
    endif()
234
  endif()
235

236
  if (VERILATOR_OUTDATED)
237
    message(STATUS "Executing Verilator...")
238
    execute_process(
239
      COMMAND ${VERILATOR_COMMAND}
240
      WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
241
      RESULT_VARIABLE _VERILATOR_RC
242
      OUTPUT_VARIABLE _VERILATOR_OUTPUT
243
      ERROR_VARIABLE _VERILATOR_OUTPUT)
244
    if (_VERILATOR_RC)
245
      string(REPLACE ";" " " VERILATOR_COMMAND_READABLE "${VERILATOR_COMMAND}")
246
      message("Verilator command: \"${VERILATOR_COMMAND_READABLE}\"")
247
      message("Output:\n${_VERILATOR_OUTPUT}")
248
      message(FATAL_ERROR "Verilator command failed (return code=${_VERILATOR_RC})")
249
    endif()
250
    execute_process(COMMAND "${CMAKE_COMMAND}" -E copy "${VCMAKE}" "${VCMAKE_COPY}")
251
  endif()
252
  file(WRITE "${VARGS_FILE}" "${VERILATOR_COMMAND}")
253

254
  include("${VCMAKE_COPY}")
255

256
  set(GENERATED_C_SOURCES ${${VERILATE_PREFIX}_CLASSES_FAST}
257
                          ${${VERILATE_PREFIX}_CLASSES_SLOW}
258
                          ${${VERILATE_PREFIX}_SUPPORT_FAST}
259
                          ${${VERILATE_PREFIX}_SUPPORT_SLOW})
260
  # No need for .h's as the .cpp will get written same time
261
  set(GENERATED_SOURCES ${GENERATED_C_SOURCES})
262

263
  add_custom_command(OUTPUT ${GENERATED_SOURCES} "${VCMAKE}"
264
                     COMMAND ${VERILATOR_COMMAND}
265
                     WORKING_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}"
266
                     DEPENDS "${VERILATOR_BIN}" ${${VERILATE_PREFIX}_DEPS} VERBATIM)
267
  # Reconfigure if file list has changed
268
  # (check contents rather than modified time to avoid unnecessary reconfiguration)
269
  add_custom_command(OUTPUT "${VCMAKE_COPY}"
270
                     COMMAND "${CMAKE_COMMAND}" -E copy_if_different
271
                     "${VCMAKE}" "${VCMAKE_COPY}"
272
                     DEPENDS "${VCMAKE}" VERBATIM)
273

274
  if (${VERILATE_PREFIX}_COVERAGE)
275
    # If any verilate() call specifies COVERAGE, define VM_COVERAGE in the final build
276
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_COVERAGE ON)
277
  endif()
278

279
  if (${VERILATE_PREFIX}_TRACE_VCD)
280
    # If any verilate() call specifies TRACE, define VM_TRACE in the final build
281
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_TRACE ON)
282
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_TRACE_VCD ON)
283
  endif()
284

285
  if (${VERILATE_PREFIX}_TRACE_FST)
286
    # If any verilate() call specifies TRACE_FST, define VM_TRACE_FST in the final build
287
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_TRACE ON)
288
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_TRACE_FST ON)
289
  endif()
290

291
  if (${VERILATE_PREFIX}_SC)
292
    # If any verilate() call specifies SYSTEMC, define VM_SC in the final build
293
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_SYSTEMC ON)
294
  endif()
295

296
  if (${VERILATE_PREFIX}_TRACE_STRUCTS)
297
    set_property(TARGET ${TARGET} PROPERTY VERILATOR_TRACE_STRUCTS ON)
298
  endif()
299

300
    # Add the compile flags only on Verilated sources
301
  target_include_directories(${TARGET} PUBLIC ${VDIR})
302
  target_sources(${TARGET} PRIVATE ${GENERATED_SOURCES} "${VCMAKE_COPY}"
303
                                   ${${VERILATE_PREFIX}_GLOBAL}
304
                                   ${${VERILATE_PREFIX}_USER_CLASSES})
305
  foreach(_VSOURCE ${VERILATE_SOURCES} ${${VERILATE_PREFIX}_DEPS})
306
    get_filename_component(_VSOURCE "${_VSOURCE}" ABSOLUTE BASE_DIR)
307
    list(APPEND VHD_SOURCES "${_VSOURCE}")
308
  endforeach()
309
  target_sources(${TARGET} PRIVATE ${VHD_SOURCES})
310

311
  # Add the compile flags only on Verilated sources
312
  foreach(VSLOW ${${VERILATE_PREFIX}_CLASSES_SLOW} ${${VERILATE_PREFIX}_SUPPORT_SLOW})
313
    foreach(OPT_SLOW ${VERILATE_OPT_SLOW} ${${VERILATE_PREFIX}_USER_CFLAGS})
314
      set_property(SOURCE "${VSLOW}" APPEND_STRING PROPERTY COMPILE_FLAGS " ${OPT_SLOW}")
315
    endforeach()
316
  endforeach()
317
  foreach(VFAST ${${VERILATE_PREFIX}_CLASSES_FAST} ${${VERILATE_PREFIX}_SUPPORT_FAST})
318
    foreach(OPT_FAST ${VERILATE_OPT_FAST} ${${VERILATE_PREFIX}_USER_CFLAGS})
319
      set_property(SOURCE "${VFAST}" APPEND_STRING PROPERTY COMPILE_FLAGS " ${OPT_FAST}")
320
    endforeach()
321
  endforeach()
322
  foreach(VGLOBAL ${${VERILATE_PREFIX}_GLOBAL})
323
    foreach(OPT_GLOBAL ${VERILATE_OPT_GLOBAL} ${${VERILATE_PREFIX}_USER_CFLAGS})
324
      set_property(SOURCE "${VGLOBAL}" APPEND_STRING PROPERTY COMPILE_FLAGS " ${OPT_GLOBAL}")
325
    endforeach()
326
  endforeach()
327

328
  target_include_directories(${TARGET} PUBLIC "${VERILATOR_ROOT}/include"
329
                                               "${VERILATOR_ROOT}/include/vltstd")
330
  target_compile_definitions(${TARGET} PRIVATE
331
    VM_COVERAGE=$<BOOL:$<TARGET_PROPERTY:VERILATOR_COVERAGE>>
332
    VM_SC=$<BOOL:$<TARGET_PROPERTY:VERILATOR_SYSTEMC>>
333
    VM_TRACE=$<BOOL:$<TARGET_PROPERTY:VERILATOR_TRACE>>
334
    VM_TRACE_VCD=$<BOOL:$<TARGET_PROPERTY:VERILATOR_TRACE_VCD>>
335
    VM_TRACE_FST=$<BOOL:$<TARGET_PROPERTY:VERILATOR_TRACE_FST>>
336
  )
337

338
  target_link_libraries(${TARGET} PUBLIC
339
    ${${VERILATE_PREFIX}_USER_LDLIBS}
340
  )
341

342
  target_link_libraries(${TARGET} PUBLIC
343
    ${VERILATOR_MT_CFLAGS}
344
  )
345

346
  target_compile_features(${TARGET} PRIVATE cxx_std_11)
347

348
  if (${VERILATE_PREFIX}_TIMING)
349
    check_cxx_compiler_flag(-fcoroutines-ts COROUTINES_TS_FLAG)
350
    target_compile_options(${TARGET} PRIVATE $<IF:$<BOOL:${COROUTINES_TS_FLAG}>,-fcoroutines-ts,-fcoroutines>)
351
  endif()
352
endfunction()
353

354
function(_verilator_find_systemc)
355
  if (NOT TARGET Verilator::systemc)
356
    # Find SystemC include file "systemc.h" in the following order:
357
    # 1. SYSTEMC_INCLUDE (environment) variable
358
    # 2. SYSTEMC_ROOT (environment) variable
359
    # 3. SYSTEMC (environment) variable
360
    # 4. Use CMake module provided by SystemC installation
361
    #    (eventually requires CMAKE_PREFIX_PATH set)
362

363
    find_path(SYSTEMC_INCLUDEDIR NAMES systemc.h
364
      HINTS "${SYSTEMC_INCLUDE}   " ENV SYSTEMC_INCLUDE)
365
    find_path(SYSTEMC_INCLUDEDIR NAMES systemc.h
366
      HINTS "${SYSTEMC_ROOT}" ENV SYSTEMC_ROOT
367
      PATH_SUFFIXES include)
368
    find_path(SYSTEMC_INCLUDEDIR NAMES systemc.h
369
      HINTS "${SYSTEMC}" ENV SYSTEMC
370
      PATH_SUFFIXES include)
371

372
    # Find SystemC library in the following order:
373
    # 1. SYSTEMC_LIBDIR (environment) variable
374
    # 2. SYSTEMC_ROOT (environment) variable
375
    # 3. SYSTEMC (environment) variable
376
    # 4. Use CMake module provided by SystemC installation
377
    #    (eventually requires CMAKE_PREFIX_PATH set)
378

379
    # Find SystemC using include and library paths
380
    find_library(SYSTEMC_LIBRARY NAMES systemc
381
      HINTS "${SYSTEMC_LIBDIR}" ENV SYSTEMC_LIBDIR)
382
    find_library(SYSTEMC_LIBRARY NAMES systemc
383
      HINTS "${SYSTEMC_ROOT}" ENV SYSTEMC_ROOT
384
      PATH_SUFFIXES lib)
385
    find_library(SYSTEMC_LIBRARY NAMES systemc
386
      HINTS "${SYSTEMC}" ENV SYSTEMC
387
      PATH_SUFFIXES lib)
388

389
    if (SYSTEMC_INCLUDEDIR AND SYSTEMC_LIBRARY)
390
      add_library(Verilator::systemc INTERFACE IMPORTED)
391
      set_target_properties(Verilator::systemc
392
        PROPERTIES
393
          INTERFACE_INCLUDE_DIRECTORIES "${SYSTEMC_INCLUDEDIR}"
394
          INTERFACE_LINK_LIBRARIES "${SYSTEMC_LIBRARY}")
395
      return()
396
    endif()
397

398
    find_package(SystemCLanguage QUIET)
399
    if (SystemCLanguage_FOUND)
400
      add_library(Verilator::systemc INTERFACE IMPORTED)
401
      set_target_properties(Verilator::systemc
402
        PROPERTIES
403
          INTERFACE_LINK_LIBRARIES "SystemC::systemc")
404
      return()
405
    endif()
406

407
    message("SystemC not found. This can be fixed by doing either of the following steps:")
408
    message("- set the SYSTEMC_INCLUDE and SYSTEMC_LIBDIR (environment) variables; or")
409
    message("- set SYSTEMC_ROOT (environment) variable; or")
410
    message("- set SYSTEMC (environment) variable; or")
411
    message("- use the CMake module of your SystemC installation (may require CMAKE_PREFIX_PATH)")
412
    message(FATAL_ERROR "SystemC not found")
413
  endif()
414
endfunction()
415

416
function(verilator_link_systemc TARGET)
417
  _verilator_find_systemc()
418
  target_link_libraries("${TARGET}" PUBLIC Verilator::systemc)
419
  target_compile_options(${TARGET} PRIVATE $ENV{SYSTEMC_CXX_FLAGS} ${SYSTEMC_CXX_FLAGS})
420
endfunction()
421

422
function(verilator_generate_key OUTPUT_VARIABLE)
423
  execute_process(COMMAND ${VERILATOR_BIN} --generate-key
424
                  OUTPUT_VARIABLE KEY_VAL
425
                  RESULT_VARIABLE KEY_RET)
426
  if (KEY_RET)
427
    message(FATAL_ERROR "verilator --generate-key failed")
428
  endif()
429
  string(STRIP ${KEY_VAL} KEY_VAL)
430
  set(${OUTPUT_VARIABLE} ${KEY_VAL} PARENT_SCOPE)
431
endfunction()
432