### Configure Simics Module: sample-pcie-device-old

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-device-old/CMakeLists.txt

This snippet configures the 'sample-pcie-device-old' Simics module. It defines the classes, source files (pcie.dml, module_load.py), and the Simics API version to be used. Dependencies include the 'dml-lib'.

```python
simics_add_module(sample-pcie-device-old
  CLASSES sample_pcie_device_old
  SOURCES pcie.dml module_load.py
  SIMICS_API 6
)
target_link_libraries(sample-pcie-device-old
  PRIVATE dml-lib
)
add_subdirectory(test)
```

--------------------------------

### Link Target Libraries for Simics Module

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-device/CMakeLists.txt

Links the 'dml-lib' library to the 'sample-pcie-device' target. This is essential for ensuring that the module has access to the necessary runtime libraries provided by Simics, particularly for Device Modeling Language (DML) components.

```cmake
target_link_libraries(sample-pcie-device PRIVATE dml-lib)

```

--------------------------------

### Add Subdirectory for Tests

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-device/CMakeLists.txt

Includes a subdirectory named 'test' into the build process. This is a standard practice for organizing and building associated test cases or test suites for the 'sample-pcie-device' module.

```cmake
add_subdirectory(test)

```

--------------------------------

### Add Simics Module Configuration

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-device/CMakeLists.txt

Configures a new Simics module named 'sample-pcie-device'. It specifies the classes associated with the module and lists the source files (endpoint.dml and module_load.py). This is a core step in integrating custom hardware models into Simics.

```tcl
simics_add_module(sample-pcie-device
    CLASSES  sample-pcie-device
    SOURCES endpoint.dml module_load.py
)

```

--------------------------------

### Add Simics Sanitizers Configuration

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-device/CMakeLists.txt

Applies sanitizers to the 'sample-pcie-device' Simics module. Sanitizers help detect memory errors and other common programming mistakes during runtime, improving the reliability of the simulation.

```tcl
simics_add_sanitizers(sample-pcie-device)

```

--------------------------------

### Link Simics Module to Libraries

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/test-generic-message-device/CMakeLists.txt

Links the 'test-generic-message-device' module to the 'generic-message-interfaces' library, ensuring that necessary interfaces and definitions are available during the build process. This is a standard CMake command for managing dependencies.

```cmake
target_link_libraries(test-generic-message-device
  PRIVATE generic-message-interfaces::includes
)
```

--------------------------------

### Define Simics Module and Sources

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/test-generic-message-device/CMakeLists.txt

Defines a Simics module named 'test-generic-message-device', listing its associated C source file and the Simics API version to use. This is essential for building and integrating custom devices into Simics.

```simics-config
simics_add_module(test-generic-message-device
  CLASSES test_generic_message_device
  SOURCES test-generic-message-device.c
  INIT_LOCAL
  SIMICS_API latest
)
```

--------------------------------

### Custom Interface Definition and Implementation in C for Simics

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Illustrates defining and implementing a custom interface for a Simics device in C. This includes declaring the interface in a header file and providing method implementations in the device's C source file. The example defines a 'sample' interface with 'simple_method' and 'object_method'.

```c
// Header file: sample-interface.h
#ifndef SAMPLE_INTERFACE_H
#define SAMPLE_INTERFACE_H

#include <simics/device-api.h>

SIM_INTERFACE(sample) {
    void (*simple_method)(conf_object_t *obj, int arg);
    void (*object_method)(conf_object_t *obj, conf_object_t *arg);
};

#define SAMPLE_INTERFACE "sample"

#endif

// Implementation: sample-device.c
static void
simple_method(conf_object_t *obj, int arg)
{
    sample_device_t *sample = (sample_device_t *)obj;
    SIM_LOG_INFO(1, &sample->obj, 0,
                 "'simple_method' called with arg %d", arg);
}

void
init_local()
{
    // ... class creation ...

    static const sample_interface_t sample_iface = {
        .simple_method = simple_method
    };
    SIM_REGISTER_INTERFACE(class, SAMPLE_INTERFACE, &sample_iface);
}

```

--------------------------------

### Enable Simics Tests from Packages

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/i-synchronizer/test/CMakeLists.txt

Conditionally enables tests like info-status, sync-basic-test, and sync-e2l-test if the SIMICS_ENABLE_TESTS_FROM_PACKAGES macro is defined. This is useful for integrating and running tests directly from installed Simics packages.

```simics-script
if(SIMICS_ENABLE_TESTS_FROM_PACKAGES)
  simics_add_test(info-status)
  simics_add_test(sync-basic-test)
  simics_add_test(sync-e2l-test)
endif()
```

--------------------------------

### C Device Attribute Registration with Simics API

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Shows how to register attributes for a Simics C device, enabling get and set operations for device properties. This example focuses on registering an 'value' attribute, which is an integer. It relies on the previously defined device structure and class.

```c
static set_error_t
set_value_attribute(conf_object_t *obj, attr_value_t *val)
{
    sample_device_t *sample = (sample_device_t *)obj;
    sample->value = SIM_attr_integer(*val);
    return Sim_Set_Ok;
}

static attr_value_t
get_value_attribute(conf_object_t *obj)
{
    sample_device_t *sample = (sample_device_t *)obj;
    return SIM_make_attr_uint64(sample->value);
}

void
init_local()
{
    // ... class creation code ...

    SIM_REGISTER_ATTRIBUTE(
        class, "value",
        get_value_attribute, set_value_attribute,
        Sim_Attr_Optional, "i",
        "The <i>value</i> field.");
}

```

--------------------------------

### DML Display Device with Graphics Console

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Implements a display unit for simulated panels with graphics console support. It imports simulator API, memory space, and graphics interface modules, alongside a custom drawing interface. It defines adjustable width and height attributes with clipping logic and error handling for changes after initial setup.

```dml
dml 1.4;

device p_display;

param desc = "display unit for simulated panel";
param documentation = "Simple display unit specialized for simulated panels";

import "utility.dml";
import "simics/simulator-api.dml";
import "simics/devs/memory-space.dml";
import "simics/model-iface/gfx-console.dml";
import "simics/model-iface/video-interface.dml";

import "p-display-draw-interface.dml";

loggroup display;
loggroup drawing;
loggroup buffer_memory;

header %{
#include "manage-png-images.h"
%}

extern uint64 load_png_image_impl(conf_object_t *obj, char * filename);
extern int    get_loaded_image_height(conf_object_t *obj, uint64 id);
extern int    get_loaded_image_width(conf_object_t *obj, uint64 id);
extern uint32 *get_loaded_image_data(conf_object_t *obj, uint64 id);

template value_clip {
    method clip(int v) -> (int) {
        if(v >= this.val -1) {
            return this.val -1;
        }
        if(v < 0) {
            return 0;
        }
        return v;
    }
}

attribute width is (uint64_attr, value_clip) "Display width" {
    param configuration = "required";
    method set(attr_value_t value) throws {
        if(this.val==0) {
            default(value);
        } else {
            if (!SIM_is_restoring_state(obj)) {
                log error : "Cannot change display size once set";
                throw;
            }
        }
    }
}

attribute height is (uint64_attr, value_clip) "Display height" {
    param configuration = "required";
    method set(attr_value_t value) throws {
        if(this.val==0) {
            default(value);
        } else {
            if (!SIM_is_restoring_state(obj)) {
                log error : "Cannot change display size once set";
                throw;
            }
        }
    }
}

```

--------------------------------

### Enable Simics Tests from Packages (Simics Script)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-serial-device/test/CMakeLists.txt

This snippet shows how to conditionally enable tests from Simics packages. It uses the SIMICS_ENABLE_TESTS_FROM_PACKAGES variable to control whether the simics_add_test command is executed. No external dependencies are required beyond the Simics environment.

```simics-script
if(SIMICS_ENABLE_TESTS_FROM_PACKAGES)
  simics_add_test(sample-serial-device)
endif()
```

--------------------------------

### Add Simics Module: test-usb-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/test-usb-device/CMakeLists.txt

This snippet demonstrates how to add a new module to the Simics simulator. It specifies the module name, the classes it provides, the source files containing its definition, and the Simics API version to be used. Ensure that 'test-usb-device.dml' is accessible and the 'latest' SIMICS_API is compatible with your Simics installation.

```simics
simics_add_module(test-usb-device
  CLASSES test_usb_device
  SOURCES test-usb-device.dml
  SIMICS_API latest
)

```

--------------------------------

### I2C Link Device Implementation in C

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Implements the I2C link device functionality, defining structures for link and endpoint, and functions for broadcasting start commands, handling read responses, and initializing endpoints. Uses Simics device API and vector utilities.

```c
#include "i2c-link-v2.h"
#include <simics/device-api.h>
#include <simics/util/hashtab.h>

typedef struct {
    conf_object_t obj;
    unsigned num_slaves;
} i2c_link_impl_t;

typedef struct {
    conf_object_t obj;

    const i2c_master_v2_interface_t *master_iface;
    const i2c_slave_v2_interface_t *slave_iface;

    VECT(uint64) pending_start_responses;
    VECT(uint64) slave_list;
    uint8 slave_list_counter;
    i2c_ack_t slave_list_ack;
    int16 address_pattern;
    uint64 current_master;
    uint64 current_slave;
    bool waiting_for_synchronous_response;
} i2c_endpoint_t;

static void
broadcast_start(i2c_link_impl_t *link, i2c_endpoint_t *master_ep,
                uint8 address, i2c_direction_t direction)
{
    VECT_FOREACH(link->endpoints, ep_id) {
        i2c_endpoint_t *ep = get_endpoint(link, ep_id);
        if (ep != master_ep && ep->slave_iface) {
            ep->slave_iface->start(ep->obj, address);
        }
    }
}

static void
handle_read_response(i2c_endpoint_t *master_ep, uint8 data)
{
    if (master_ep->master_iface) {
        master_ep->master_iface->read_response(&master_ep->obj, data);
    }
}

static void
init_endpoint(i2c_endpoint_t *ep)
{
    VINIT(ep->pending_start_responses);
    VINIT(ep->slave_list);
    ep->slave_list_counter = 0;
    ep->slave_list_ack = I2C_noack;
    ep->address_pattern = -1;
    ep->current_master = 0;
    ep->current_slave = 0;
    ep->waiting_for_synchronous_response = false;
}

```

--------------------------------

### Simics Test Suite Configuration and Execution

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/gml-link/test/CMakeLists.txt

This snippet configures a Simics test suite by enabling tests from packages, defining the start and end of the suite, adding specific tests, and setting properties like dependencies between tests. It is executed conditionally based on SIMICS_ENABLE_TESTS_FROM_PACKAGES.

```simics
if(SIMICS_ENABLE_TESTS_FROM_PACKAGES)
  simics_test_suite_begin()
    simics_add_test(checkpoint-0)
    simics_add_test(checkpoint-1)
    simics_add_test(tx-rx)
  simics_test_suite_end()

  set_tests_properties(gml-link::checkpoint-1
    PROPERTIES DEPENDS gml-link::checkpoint-0)
endif()
```

--------------------------------

### DML I2C Button Device Structure

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Defines a basic I2C device that simulates a button's status. It imports necessary utility and device modules, defines connection interfaces, and implements I2C slave methods for start, read, write, and stop operations. Logging is enabled for I2C communications.

```dml
dml 1.4;

device button_i2c;

param desc = "button on I2C bus";
param documentation = "I2C device that reports button status";

import "utility.dml";
import "simics/devs/i2c.dml";
import "simics/devs/signal.dml";

loggroup i2c_comms;

connect i2c_link {
    param desc = "I2C link Connection";
    param configuration = "optional";
    interface i2c_master_v2;
    interface i2c_slave_v2;
}

port i2c_in {
    param desc = "Inbound I2C traffic";

    implement i2c_slave_v2 {
        method start(uint8 address) {
            log info, 3, i2c_comms: "i2c_slave.start_request([%d][%d])",
                address[7:1], address[0];

            if (address[7:1] == dev.address.val) {
                log info, 2, i2c_comms: "start message received (addr=0x%.2x)",
                    address;
                i2cregs.i2c_slave_state.active.set_val(1);
                i2c_link.i2c_master_v2.acknowledge(I2C_ack);
            } else {
                i2cregs.i2c_slave_state.active.set_val(0);
                i2c_link.i2c_master_v2.acknowledge(I2C_noack);
            }
        }

        method read() {
            log info, 3, i2c_comms: "read incoming";
            if (i2cregs.i2c_slave_state.active.val == 1) {
                local uint8 button_state = i2cregs.button_status.val;
                i2c_link.i2c_master_v2.read_response(button_state);
            }
        }

        method write(uint8 value) {
            log info, 3, i2c_comms: "write incoming: 0x%.2x", value;
            if (i2cregs.i2c_slave_state.active.val == 1) {
                i2cregs.button_status.set_val(value);
                i2c_link.i2c_master_v2.acknowledge(I2C_ack);
            }
        }

        method stop() {
            log info, 3, i2c_comms: "stop received";
            i2cregs.i2c_slave_state.active.set_val(0);
            i2cregs.i2c_slave_state.busy.set_val(0);
        }
    }
}

```

--------------------------------

### Link Libraries for Sample Firewire Device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-firewire-device/CMakeLists.txt

This code specifies the libraries that the 'sample-firewire-device' module needs to link against. It indicates a private dependency on the 'firewire-bus::imports' library.

```simics-build
target_link_libraries(sample-firewire-device
  PRIVATE firewire-bus::imports
)
```

--------------------------------

### Simics Module Definition and Build Configuration

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-timer-device/CMakeLists.txt

Defines a Simics module named 'sample-timer-device' using the simics_add_module command. It specifies the device class, source files (DML and Python), and the Simics API version. The add_subdirectory command includes build instructions from a 'test' directory.

```simics-build
simics_add_module(sample-timer-device
  CLASSES sample_timer_device
  SOURCES sample-timer-device.dml module_load.py
  SIMICS_API latest
)
add_subdirectory(test)
```

--------------------------------

### Add Simics Module

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-device-c/CMakeLists.txt

Defines a new module named 'sample-device-c' for Simics. It lists the source files (.c and .py) and specifies class definitions. The INIT_LOCAL directive indicates local initialization.

```simics_build
simics_add_module(sample-device-c
  CLASSES sample-device-c
  SOURCES sample-device.c module_load.py
  INIT_LOCAL
)
```

--------------------------------

### Manage Build Subdirectories and Dependencies (CMake)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-display/CMakeLists.txt

Includes a 'test' subdirectory into the build process and manages dependencies between build targets. It ensures that the 'p-display' module is included in the 'all-training-modules' target.

```cmake
add_subdirectory(test)

if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules p-display)
```

--------------------------------

### Basic C Device Implementation with Simics API

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Demonstrates the fundamental structure for a C-based device model in Simics, including object allocation, transaction handling (reads and writes), and basic logging. It requires the Simics device-api and model-iface/transaction headers.

```c
#include <simics/device-api.h>
#include <simics/model-iface/transaction.h>

typedef struct {
    conf_object_t obj;
    unsigned value;
} sample_device_t;

static conf_object_t *
alloc_object(conf_class_t *cls)
{
    sample_device_t *sample = MM_ZALLOC(1, sample_device_t);
    return &sample->obj;
}

static exception_type_t
issue(conf_object_t *obj, transaction_t *t, uint64 addr)
{
    sample_device_t *sample = (sample_device_t *)obj;

    if (SIM_transaction_is_read(t)) {
        SIM_set_transaction_value_le(t, sample->value);
        SIM_LOG_INFO(1, &sample->obj, 0, "read from offset %lld: 0x%x",
                     addr, sample->value);
    } else {
        sample->value = SIM_get_transaction_value_le(t);
        SIM_LOG_INFO(1, &sample->obj, 0, "write to offset %lld: 0x%x",
                     addr, sample->value);
    }
    return Sim_PE_No_Exception;
}

void
init_local()
{
    const class_info_t funcs = {
        .alloc = alloc_object,
        .short_desc = "sample C device",
        .description = "Memory-mapped device example"
    };
    conf_class_t *class = SIM_CREATE_CLASS("sample-device-c", &funcs);

    static const transaction_interface_t transaction_iface = {
        .issue = issue,
    };
    SIM_REGISTER_INTERFACE(class, transaction, &transaction_iface);
}

```

--------------------------------

### Add Simics Module: Sample i3c Devices

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-i3c-devices/CMakeLists.txt

Adds a new module to Simics, named 'sample-i3c-devices'. It specifies the device classes ('sample-i3c-target', 'sample_i3c_master') and the source description files ('sample-i3c-master.dml', 'sample-i3c-target.dml') and a Python script for module loading ('module_load.py').

```tcl
simics_add_module(sample-i3c-devices
  CLASSES sample-i3c-target sample_i3c_master
  SOURCES sample-i3c-master.dml sample-i3c-target.dml module_load.py
)
```

--------------------------------

### Add Simics Test from Package

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-notifier-dml/test/CMakeLists.txt

This snippet demonstrates how to conditionally add a test suite from a Simics package. It relies on the `SIMICS_ENABLE_TESTS_FROM_PACKAGES` macro to determine if tests should be included. The `simics_add_test` function is used to register the test suite.

```simics-script
if(SIMICS_ENABLE_TESTS_FROM_PACKAGES)
  simics_add_test(sample-notifier-dml)
endif()
```

--------------------------------

### Add Simics Module and Sources

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-device-dml/CMakeLists.txt

This snippet demonstrates how to add a Simics module named 'sample-device-dml' and specify its associated DML and Python source files. It ensures that the module and its components are recognized by the Simics environment.

```simics
simics_add_module(sample-device-dml
  CLASSES sample_device_dml
  SOURCES sample-device-dml.dml module_load.py
)
```

--------------------------------

### Add Simics Module for Sample Firewire Device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-firewire-device/CMakeLists.txt

This code defines how to add a new module to Simics, specifically for the 'sample-firewire-device'. It lists the source files and the Simics API version required for this module.

```simics-config
simics_add_module(sample-firewire-device
  CLASSES sample_firewire_device
  SOURCES sample-firewire-device.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Link Target Libraries

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-device-c/CMakeLists.txt

Links the 'sample-interface::includes' library to the 'sample-device-c' target. This is a private link, meaning the library is only needed during the build process of 'sample-device-c'.

```simics_build
target_link_libraries(sample-device-c
  PRIVATE sample-interface::includes
)
```

--------------------------------

### Add Simics Module: sample-event-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-event-device/CMakeLists.txt

This snippet defines a new module named 'sample-event-device' for Simics. It specifies the device class 'sample_event_device', lists the source files ('sample-event-device.dml' and 'module_load.py'), and indicates the usage of the 'latest' Simics API version.

```simics_config
simics_add_module(sample-event-device
  CLASSES sample_event_device
  SOURCES sample-event-device.dml module_load.py
  SIMICS_API latest
)
add_subdirectory(test)
```

--------------------------------

### NS16x50 Multi-Device Module Initialization in C

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Provides an empty `init_local` function for a Simics module containing multiple NS16x50 devices. This indicates that device class registration is handled within individual DML files.

```c
#include <simics/device-api.h>

void
init_local()
{
    // Empty init for module containing multiple DML device classes
    // Each DML file registers its own class
}

```

--------------------------------

### Link Libraries for 'm-compute' Target

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/m-compute/CMakeLists.txt

Links the 'm-compute' target to necessary libraries, specifically 'm-compute-control-interface::imports' and 'pthread', for its private dependencies.

```cmake
target_link_libraries(m-compute
  PRIVATE m-compute-control-interface::imports pthread
)
```

--------------------------------

### Add SIMICS Module and Sources (Simics Lisp)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-qsp-x86-7.38.0/src/devices/X58-devices/CMakeLists.txt

This snippet defines a SIMICS module named 'X58-devices'. It specifies the classes included in the module, lists the source files (DML and Python) required for compilation, and sets the SIMICS API version to 'latest'. Note the comment regarding the order dependency for 'remap-unit.dml'.

```simics-lisp
simics_add_module(X58-devices
  CLASSES x58-core x58-dmi x58-ioxapic x58-pcie-port x58-pcie-port-acs x58-qpi-arch x58-qpi-port x58-remap-unit
  # NOTE: remap-unit.dml *must* come before core.dml to satisfy order dependency
  SOURCES remap-unit.dml core.dml dmi.dml ioxapic.dml pcie-port.dml pcie-port-acs.dml qpi-arch.dml qpi-port.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Handle Optional External Dependencies (CMake)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-display/CMakeLists.txt

Configures the build to ignore missing external libraries like ZLIB and PNG for the 'p-display' module. This allows the module to be built even if these libraries are not present on the system, providing flexibility for end-users.

```cmake
# To build p-display we need ZLIB and PNG; but we don't care if either is
# missing. This allows end-users to configure this module on a system without
# ZLIB and PNG.
set(IGNORE_MISSING_LIBS True)

simics_add_external_build_dependency(p-display ZLIB)
if(NOT ZLIB_FOUND)
  message(WARNING "p-display needs ZLIB; please provide ZLIB_ROOT or install ZLIB")
endif()

simics_add_external_build_dependency(p-display PNG)
if(NOT PNG_FOUND)
  message(WARNING "p-display needs PNG; please provide PNG_ROOT or install PNG")
endif()
```

--------------------------------

### Add Simics Module 'led-system-controller-bb'

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/led-system-controller-bb/CMakeLists.txt

This snippet defines how to add a new module named 'led-system-controller-bb' to the Simics environment. It specifies the associated classes, source files (DML and Python), and the Simics API version required. This is crucial for extending Simics functionality.

```cmake
simics_add_module(led-system-controller-bb
  CLASSES led_system_controller_bb
  SOURCES led_system_controller_bb.dml module_load.py
  SIMICS_API 6
)
```

--------------------------------

### Link Libraries for Simics Module

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-device-dml/CMakeLists.txt

This snippet shows how to link external libraries required by the 'sample-device-dml' Simics module. It specifically links to 'sample-interface::imports' as a private dependency, ensuring that the module has access to necessary functionalities.

```simics
target_link_libraries(sample-device-dml
  PRIVATE sample-interface::imports
)
```

--------------------------------

### Link Target Libraries (CMake)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-qsp-x86-7.38.0/src/devices/X58-devices/CMakeLists.txt

This CMake command links the 'X58-devices' target library with 'io-apic::imports' and 'dml-lib'. The 'PRIVATE' keyword indicates that these libraries are only needed for the compilation of 'X58-devices' itself.

```cmake
target_link_libraries(X58-devices
  PRIVATE io-apic::imports dml-lib
)
```

--------------------------------

### Add Simics Module Configuration

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-sriov-device/CMakeLists.txt

This snippet configures a Simics module named 'sample-pcie-sriov-device'. It specifies the classes, source files (a DML file and a Python script), and the Simics API version to be used. This is a common pattern for defining custom hardware models or device simulations within Simics.

```simics
simics_add_module(sample-pcie-sriov-device
  CLASSES sample_pcie_sriov_device
  SOURCES sample-pcie-sriov.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Define Simics Module and Sources (Simics Lisp)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-qsp-x86-7.38.0/src/devices/generic-pc-support/CMakeLists.txt

Defines a Simics module named 'generic-pc-support' with associated classes and source files. It specifies the SIMICS_API version and includes a Python script for module loading. Dependencies are managed through target_link_libraries.

```simics-lisp
simics_add_module(generic-pc-support
  CLASSES minimal_acpi_support
          cf9_handler
          pci_cf8_cfc_handler
          generic_rtc
          generic_hpet
          pci_upstream_dispatcher
  SOURCES minimal-acpi-support.dml
          cf9-handler.dml
          pci-cf8-cfc-handler.dml
          rtc.dml hpet.dml
          pci-upstream-dispatcher.dml
          module_load.py
  SIMICS_API latest
)

target_link_libraries(generic-pc-support PRIVATE io-apic::imports dml-lib)

add_subdirectory(test)
```

--------------------------------

### Configure sata-ahci Library with CMake

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-qsp-x86-7.38.0/src/devices/sata-ahci/CMakeLists.txt

This snippet shows how to configure the sata-ahci library using CMake. It defines the library as an interface target, sets the include directories to the current directory, and specifies the source file 'sata-util.c'.

```cmake
add_library(sata-ahci INTERFACE)
target_include_directories(sata-ahci INTERFACE .)
target_sources(sata-ahci INTERFACE sata-util.c)
```

--------------------------------

### Link Library to 'led-system-controller-bb' Target

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/led-system-controller-bb/CMakeLists.txt

This CMake command links the 'dml-lib' library to the 'led-system-controller-bb' target. This ensures that the module has access to the necessary library functions during compilation and linking. It's a standard practice for managing dependencies in C++ projects.

```cmake
target_link_libraries(led-system-controller-bb
  PRIVATE dml-lib
)
```

--------------------------------

### Configure Simics Module: p-display-draw-interface

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-display-draw-interface/CMakeLists.txt

This snippet configures the 'p-display-draw-interface' Simics module. It specifies the required interfaces ('p_display_draw'), the Python wrapper header file ('p-display-draw-interface.h'), and the Simics API version (6).

```simics
simics_add_module(p-display-draw-interface
  INTERFACES p_display_draw
  PYWRAP p-display-draw-interface.h
  SIMICS_API 6
)
```

--------------------------------

### Add Simics Module: test-cdrom-media-wrapper

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/test-cdrom-media-wrapper/CMakeLists.txt

This snippet demonstrates how to add a new module to the Simics simulation environment. It specifies the module name, its associated classes, the source DML file, and the Simics API version it utilizes. Ensure the DML file exists and the Simics API is compatible.

```simics
simics_add_module(test-cdrom-media-wrapper
  CLASSES test_cdrom_media_wrapper
  SOURCES test-cdrom-media-wrapper.dml
  SIMICS_API latest
)
```

--------------------------------

### Link Target Library for PCIe ATS Device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-ats-device/CMakeLists.txt

This snippet demonstrates linking the 'dml-lib' library to the 'sample-pcie-ats-device' target. This is a private link, meaning the library is only used during the build of this target.

```cmake
target_link_libraries(sample-pcie-ats-device PRIVATE dml-lib)
```

--------------------------------

### Add Simics Module for Sample I2C Device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-i2c-device/CMakeLists.txt

Defines and adds the sample I2C device module to Simics. It specifies the DML class, source files (DML and Python loader), and the Simics API version to use. This is the primary configuration step for the module.

```tcl
simics_add_module(sample-i2c-device
  CLASSES sample_i2c_device
  SOURCES sample-i2c-device.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Manage Custom Target Dependencies

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-output-image/CMakeLists.txt

Defines and manages custom build targets, specifically 'all-training-modules'. It ensures that this target exists and adds the 'p-output-image' module as a dependency, controlling build order.

```cmake
if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules p-output-image)
```

--------------------------------

### Build X58 Legacy Simics Module with CMake

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-qsp-x86-7.38.0/src/devices/X58-legacy/CMakeLists.txt

This snippet configures the Simics module 'X58-legacy' using CMake. It specifies the device classes, legacy device names, source files (DML, C, Python), Simics API version, initialization settings, and external libraries.

```cmake
simics_add_module(X58-legacy
  CLASSES ${CLASSES} ${LEGACY}
  SOURCES core-f0.dml core-f1.dml core-f2.dml core-f3.dml dmi.dml ioxapic.dml pcie-port.dml qpi-ncr-f0.dml qpi-port0-f0.dml qpi-port0-f1.dml qpi-port1-f0.dml qpi-port1-f1.dml qpi-sad-f1.dml remap-dispatcher.dml remap-unit0.dml remap-unit1.dml x58-devices.c module_load.py simics_start.py
  SIMICS_API 6
  INIT_LOCAL
)
target_link_libraries(X58-legacy
  PRIVATE io-apic::imports dml-lib
)
```

--------------------------------

### Add Dependency for 'all-training-modules'

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/m-compute/CMakeLists.txt

Adds a build dependency to the 'all-training-modules' target, ensuring that the 'm-compute' module is built before 'all-training-modules' can be completed.

```cmake
add_dependencies(all-training-modules m-compute)
```

--------------------------------

### Link Library: i-multi-writer-output

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/i-multi-writer-output/CMakeLists.txt

Links the 'i-multi-writer-output' target library with private dependencies, specifically including headers from 'i-processor-id-atom'.

```cmake
target_link_libraries(i-multi-writer-output PRIVATE i-processor-id-atom::includes)
```

--------------------------------

### CMake Build Configuration for p-display Module

Source: https://context7.com/fenghaitao/simics-7-packages-2025-38-linux64/llms.txt

Configures the build for the 'p-display' Simics module using CMake. It defines module sources, specifies Simics API version, links external libraries like ZLIB and PNG, and sets up build dependencies and custom targets.

```cmake
# CMakeLists.txt for p-display device module
simics_add_module(p-display
  CLASSES p_display
  SOURCES p-display.dml manage-png-images.c module_load.py
  INIT_LOCAL
  SIMICS_API 6
)

target_link_libraries(p-display
  PRIVATE p-display-draw-interface::imports
)

set(IGNORE_MISSING_LIBS True)

simics_add_external_build_dependency(p-display ZLIB)
if(NOT ZLIB_FOUND)
  message(WARNING "p-display needs ZLIB; please provide ZLIB_ROOT")
endif()

simics_add_external_build_dependency(p-display PNG)
if(NOT PNG_FOUND)
  message(WARNING "p-display needs PNG; please provide PNG_ROOT")
endif()

add_subdirectory(test)

if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules p-display)

```

--------------------------------

### Link Libraries for i210-v2 Module

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/i210-v2/CMakeLists.txt

Links the 'i210-v2' module to necessary libraries, including 'intel-e1000::imports' and 'dml-lib'. This ensures that the module has access to required functionalities and data structures during simulation.

```tcl
target_link_libraries(i210-v2
  PRIVATE intel-e1000::imports dml-lib
)
```

--------------------------------

### Link Simics Module Libraries

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-toggle/CMakeLists.txt

Links the 'p-toggle' module against necessary Simics interface libraries, specifically 'p-control-button-interface' and 'p-image-properties-interface'. This ensures the module has access to required Simics functionalities.

```cmake
target_link_libraries(p-toggle
  PRIVATE p-control-button-interface::imports p-image-properties-interface::imports
)
```

--------------------------------

### Link Library for i-processor-id-router

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/i-processor-id-router/CMakeLists.txt

Configures the build system to link the 'i-processor-id-router' target with the 'i-processor-id-atom::includes' library. This ensures that the necessary headers and definitions from the i-processor-id-atom component are available during the compilation of the i-processor-id-router module.

```cmake
target_link_libraries(i-processor-id-router PRIVATE i-processor-id-atom::includes)
```

--------------------------------

### Add Dependency to Target: all-training-modules

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-image-properties-interface/CMakeLists.txt

Adds a build dependency to the 'all-training-modules' target, ensuring that 'p-image-properties-interface' is built before 'all-training-modules'. This manages the build order for related components.

```cmake
add_dependencies(all-training-modules p-image-properties-interface)
```

--------------------------------

### Add Simics Module: sample-interrupt-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-interrupt-device/CMakeLists.txt

This snippet demonstrates how to add a new module to Simics, specifically 'sample-interrupt-device'. It defines the classes associated with the device, lists the source files required for its compilation and loading (including a Python script for module loading), and specifies the Simics API version to be used. This is a core configuration step for integrating custom devices into the Simics simulation environment.

```simics-config
simics_add_module(sample-interrupt-device
  CLASSES sample_interrupt_device
  SOURCES sample-interrupt-device.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Add Simics Module - sample-transaction-atoms

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-transaction-atoms/CMakeLists.txt

This code snippet demonstrates how to add a Simics module named 'sample-transaction-atoms'. It specifies the source files (C and header), the Simics API version to use ('latest'), and initializes local settings. This is a fundamental step in integrating custom modules into the Simics environment.

```simics
simics_add_module(sample-transaction-atoms
  SOURCES sample-transaction-atoms.c sample-transaction-atoms.h
  SIMICS_API latest
  INIT_LOCAL
)
```

--------------------------------

### Add Simics Module Configuration

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-output-image/CMakeLists.txt

Configures the p-output-image Simics module, specifying its classes, source files, and required Simics API version. This is a core build step for custom Simics components.

```cmake
simics_add_module(p-output-image
  CLASSES p_output_image
  SOURCES p-output-image.dml module_load.py
  SIMICS_API 6
)
```

--------------------------------

### Add Simics Module: sample-signal-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-signal-device/CMakeLists.txt

Configures the 'sample-signal-device' module for Simics. It specifies the classes, source files (DML and Python), and the Simics API version to be used. This function is essential for integrating custom devices into the Simics environment.

```simics
simics_add_module(sample-signal-device
  CLASSES sample_signal_device_impl sample_signal_device
  SOURCES sample-signal-device.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Set Build Dependency

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-control-button-interface/CMakeLists.txt

This snippet establishes a build dependency, ensuring that the 'p-control-button-interface' module is built before the 'all-training-modules' target. It utilizes CMake's `add_dependencies` command.

```cmake
add_dependencies(all-training-modules p-control-button-interface)
```

--------------------------------

### Add Simics Module 'eth-links'

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/eth-links/CMakeLists.txt

This snippet adds the 'eth-links' module to Simics. It specifies the classes, components, and source files associated with this module, along with initialization and API version information. Dependencies include 'common.c', 'eth-cable-link.c', 'eth-hub-link.c', 'eth-switch-link.c', 'module_load.py', and 'simics_start.py'.

```simics
simics_add_module(eth-links
  CLASSES eth-hub-link eth-hub-link-endpoint eth-cable-link eth-cable-link-endpoint eth-switch-link eth-switch-link-endpoint eth-link-snoop-endpoint eth-switch-link-snoop-endpoint
  COMPONENTS ethernet_hub ethernet_cable ethernet_switch ethernet_vlan_switch
  SOURCES common.c eth-cable-link.c eth-hub-link.c eth-switch-link.c module_load.py simics_start.py
  INIT_LOCAL
  SIMICS_API latest
)
```

--------------------------------

### Define Simics Module: sample-serial-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-serial-device/CMakeLists.txt

Defines a new Simics module named 'sample-serial-device'. It specifies the classes provided by the module, the source files (DML and Python), and the Simics API version used. This is crucial for integrating custom hardware models into the Simics environment.

```simics
simics_add_module(sample-serial-device
  CLASSES sample_serial_device
  SOURCES sample-serial-device.dml module_load.py
  SIMICS_API latest
)
```

--------------------------------

### Add Custom Target and Dependencies

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-display-draw-interface/CMakeLists.txt

This snippet demonstrates adding a custom build target named 'all-training-modules' if it doesn't already exist, and then adds 'p-display-draw-interface' as a dependency to this target. This ensures that the module is built when the 'all-training-modules' target is invoked.

```cmake
if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules p-display-draw-interface)
```

--------------------------------

### Add Simics Module: explore-mem-map-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/explore-mem-map-device/CMakeLists.txt

This snippet demonstrates how to add a Simics module named 'explore-mem-map-device'. It specifies the module's classes, source files (DML and Python), and the Simics API version it uses. This is a common pattern for defining and loading custom modules in Simics.

```simics-config
simics_add_module(explore-mem-map-device
  CLASSES explore-mem-map-device
  SOURCES explore-mem-map-device.dml module_load.py
  SIMICS_API 6
)

```

--------------------------------

### Enable TrainingPackage Tests (Simics Script)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/led-system-controller-bb/test/CMakeLists.txt

This snippet enables specific tests from the TrainingPackage within Simics. It relies on the SIMICS_ENABLE_TESTS_FROM_PACKAGES macro to conditionally execute the `simics_add_test` commands. The tests added are 'button-write' and 'info-status', both tagged with the 'TrainingPackage' label.

```simics
if(SIMICS_ENABLE_TESTS_FROM_PACKAGES)
  simics_add_test(button-write LABELS TrainingPackage)
  simics_add_test(info-status LABELS TrainingPackage)
endif()
```

--------------------------------

### Link Libraries for Simics Module (CMake)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-button/CMakeLists.txt

Links the 'p-button' module against required interfaces: 'p-control-button-interface' and 'p-image-properties-interface'. This ensures the module has access to necessary functionalities provided by other Simics components.

```cmake
target_link_libraries(p-button
  PRIVATE p-control-button-interface::imports p-image-properties-interface::imports
)
```

--------------------------------

### Manage Training Modules Dependency

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/p-toggle/CMakeLists.txt

Ensures a custom target 'all-training-modules' exists and adds the 'p-toggle' module as a dependency to it. This is crucial for organizing and building related Simics components together.

```cmake
if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules p-toggle)
```

--------------------------------

### Add Dependency for Training Modules (Simics Build)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/python-simple-serial/CMakeLists.txt

Establishes a build dependency, ensuring that the 'python-simple-serial' module is built before the 'all-training-modules' target. This is crucial for maintaining correct build order and ensuring that all necessary components are available when building the training modules.

```simics-build
add_dependencies(all-training-modules python-simple-serial)
```

--------------------------------

### Link Simics Module Library

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-pcie-sriov-device/CMakeLists.txt

This snippet links the 'dml-lib' library to the 'sample-pcie-sriov-device' module. The 'PRIVATE' keyword indicates that this linkage is internal to the module. This is essential for ensuring the module has access to necessary underlying Simics libraries for its operation.

```simics
target_link_libraries(sample-pcie-sriov-device
  PRIVATE dml-lib
)
```

--------------------------------

### Add Simics Module: rgb-led-i2c

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/rgb-led-i2c/CMakeLists.txt

This snippet adds the 'rgb-led-i2c' Simics module. It specifies the class, source files (DML and Python), and the Simics API version used. It also includes a subdirectory for tests and manages custom target dependencies.

```simics
simics_add_module(rgb-led-i2c
  CLASSES rgb_led_i2c
  SOURCES rgb-led-i2c.dml module_load.py
  SIMICS_API 6
)
add_subdirectory(test)

if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules rgb-led-i2c)
```

--------------------------------

### CMake Custom Target and Dependencies

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/m-display/CMakeLists.txt

Configures CMake to add a custom target 'all-training-modules' if it doesn't exist and then adds the 'm-display' module as a dependency to this target. This ensures 'm-display' is built when 'all-training-modules' is requested.

```cmake
if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules m-display)
```

--------------------------------

### Manage Custom Targets and Dependencies in Simics Build

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/explore-mem-map-device/CMakeLists.txt

This code snippet outlines how to manage custom targets and their dependencies within a Simics build system. It conditionally creates an 'all-training-modules' target if it doesn't exist and then adds 'explore-mem-map-device' as a dependency to it. This ensures modules are built in the correct order.

```cmake
if(NOT TARGET all-training-modules)
  add_custom_target(all-training-modules)
endif()

add_dependencies(all-training-modules explore-mem-map-device)

```

--------------------------------

### Add Dependency to Custom Target

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-training-7.0.0-pre.11/src/devices/button-i2c/CMakeLists.txt

Establishes a build dependency, ensuring that the 'button-i2c' module is built before the 'all-training-modules' target. This manages build order and ensures correct compilation.

```cmake
add_dependencies(all-training-modules button-i2c)
```

--------------------------------

### Link Libraries for simple-pcie-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/simple-pcie-device/CMakeLists.txt

This snippet configures the build system to link the 'dml-lib' library to the 'simple-pcie-device' target. This is a necessary step for the module to function correctly within Simics, ensuring all dependencies are resolved.

```cmake
target_link_libraries(simple-pcie-device
  PRIVATE dml-lib
)
```

--------------------------------

### Enable Simics Tests from Packages

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-firewire-device/test/CMakeLists.txt

This snippet conditionally enables tests from Simics packages. It checks for the `SIMICS_ENABLE_TESTS_FROM_PACKAGES` macro and, if defined, adds the 'sample-firewire' test to the Simics environment. This is a common pattern for feature flagging in build or configuration scripts.

```simics-config
if(SIMICS_ENABLE_TESTS_FROM_PACKAGES)
  simics_add_test(sample-firewire)
endif()
```

--------------------------------

### Add Simics Module: sample-generic-message-device

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-7.57.0/src/devices/sample-generic-message-device/CMakeLists.txt

This snippet demonstrates how to add a new Simics module named 'sample-generic-message-device'. It specifies the associated classes, source files, and the Simics API version to be used. Dependencies on 'generic-message-interfaces::imports' are handled via target linking.

```cmake
simics_add_module(sample-generic-message-device
  CLASSES sample_generic_message_device
  SOURCES sample-generic-message-device.dml module_load.py
  SIMICS_API latest
)
target_link_libraries(sample-generic-message-device
  PRIVATE generic-message-interfaces::imports
)
add_subdirectory(test)
```

--------------------------------

### Simics Module Build (CMake)

Source: https://github.com/fenghaitao/simics-7-packages-2025-38-linux64/blob/main/simics-qsp-x86-7.38.0/src/devices/io-apic/CMakeLists.txt

Configures the io-apic Simics module using CMake. It specifies classes, interfaces, source files, and API version. This snippet also defines endianness for the device.

```cmake
if(SIMICS_REPO_ROOT)
  simics_add_module(io-apic
    CLASSES io-apic
    INTERFACES ioapic
    SOURCES io-apic.cc io-apic.h module_load.py
    INIT_LOCAL
    SIMICS_API latest
  )
  add_compile_definitions(DEVICE_IS_LITTLE_ENDIAN )
else()
  add_library(io-apic-imports INTERFACE)
  target_include_directories(io-apic-imports INTERFACE .)
  add_library(io-apic::imports ALIAS io-apic-imports)
  add_library(io-apic::includes ALIAS io-apic-imports)
endif()
```