Intel® Simics® Simulator for Intel® FPGAs: User Guide

Download PDF
ID 784383
Date 11/16/2024
Public
Document Table of Contents
Document Table of Contents x
1. About This Document 2. Intel® Simics® Simulator and Virtual Platforms 3. Intel® Simics® Simulator for Intel® FPGAs Device Portfolio 4. Installing the Intel® Simics® Simulator for Intel® FPGAs 5. Getting Started with Intel® Simics® Simulator 6. Debugging Target Software 7. Networking with the Simulated Target System 8. Intel® Simics® Scripting 9. Software Debug Examples with Intel® Simics® Simulator 10. Document Revision History for Intel® Simics® Simulator for Intel FPGAs User Guide A. Intel® Simics® Simulator Command Reference
1. About This Document x
1.1. Documentation Conventions for Examples 1.2. Terminology 1.3. List of Acronyms
2. Intel® Simics® Simulator and Virtual Platforms x
2.1. Device Model and Virtual Platforms 2.2. Intel® Simics® Simulator 2.3. Intel® Simics® Simulator Architecture
2.2. Intel® Simics® Simulator x
2.2.1. Intel® Simics® Simulator for Intel FPGAs Capabilities
4. Installing the Intel® Simics® Simulator for Intel® FPGAs x
4.1. Installing the Intel® Simics® Simulator for Intel® FPGAs on Linux* Systems 4.2. Installing the Intel® Simics® Simulator for Intel® FPGAs on Microsoft Windows* Systems 4.3. Installing Ashling* RiscFree* IDE for Intel® FPGAs 4.4. Intel® Simics® Simulator for Intel® FPGAs Support
5. Getting Started with Intel® Simics® Simulator x
5.1. Simulation Set Up 5.2. Starting the Simulation 5.3. Intel® Simics® Simulator Command-Line Interface (CLI) 5.4. Hardware Inspection 5.5. Intel® Simics® Simulator Timing
5.1. Simulation Set Up x
5.1.1. Initializing an Intel® Simics® Project and Deploying a Virtual Platform 5.1.2. Understanding Target Scripts
5.2. Starting the Simulation x
5.2.1. Starting a Simulation from a Command Prompt 5.2.2. Starting a Simulation with Ashling* RiscFree* IDE
5.3. Intel® Simics® Simulator Command-Line Interface (CLI) x
5.3.1. Version of the Intel® Simics® Simulator for Intel FPGAs Software 5.3.2. Simulation Run Control from CLI 5.3.3. Intel® Simics® Simulator Command Scope 5.3.4. Intel® Simics® Simulator CLI Variables and Operations 5.3.5. Intel® Simics® Simulator CLI Command Completion and Command History 5.3.6. Intel® Simics® Command-Line Interface Help 5.3.7. Capture of CLI Session to a File 5.3.8. Intel® Simics® Simulator File Location and Intel® Simics® Search Path
5.4. Hardware Inspection x
5.4.1. Listing Objects in the Target System 5.4.2. Processor (CPU) Inspection 5.4.3. Device Inspection 5.4.4. Memory Mapping and Memory Inspection 5.4.5. Logging
5.4.2. Processor (CPU) Inspection x
5.4.2.1. Listing Processors 5.4.2.2. Inspect Processor Registers
5.4.3. Device Inspection x
5.4.3.1. Retrieve List of Devices 5.4.3.2. Inspecting Device Registers
5.4.4. Memory Mapping and Memory Inspection x
5.4.4.1. Memory Mapping Inspection 5.4.4.2. Memory Inspection
5.4.5. Logging x
5.4.5.1. Breakpoints on CLI Log Messages
5.5. Intel® Simics® Simulator Timing x
5.5.1. CPU Frequency 5.5.2. CPU Cycles and Steps 5.5.3. Events 5.5.4. Enable Real Time
6. Debugging Target Software x
6.1. Intel® Simics® Debugger and Debug Context 6.2. Capturing Serial Console Output 6.3. Breakpoints 6.4. Debugging Target Software with Symbol Files 6.5. Debugging Target Software with Ashling* RiscFree* Debugger 6.6. Capturing CPU Instruction Execution Trace
6.3. Breakpoints x
6.3.1. Memory Breakpoints 6.3.2. Temporal Breakpoints 6.3.3. CPU Control Register Breakpoints 6.3.4. Hardware Access Breakpoints 6.3.5. CPU Register Breakpoints 6.3.6. Tracing Breakpoints 6.3.7. Text Console Activity Breakpoints
6.4. Debugging Target Software with Symbol Files x
6.4.1. Loading Symbol Files in a Simulation
6.5. Debugging Target Software with Ashling* RiscFree* Debugger x
6.5.1. Remote Debugging with RiscFree* IDE
6.5.1. Remote Debugging with RiscFree* IDE x
6.5.1.1. Remote Debugging With Intel® Simics® Simulation and RiscFree* IDE on the Same System 6.5.1.2. Remote Debugging With Intel® Simics® Simulation and RiscFree* IDE on Different Systems 6.5.1.3. Remote Access to the Target System Serial Console
7. Networking with the Simulated Target System x
7.1. Network Simulation and Service Node 7.2. Connectivity Between Host PC and Target System
7.2. Connectivity Between Host PC and Target System x
7.2.1. Port Forwarding 7.2.2. Transferring Files Between Host PC and Target System 7.2.3. Accessing Target System from Host PC Through HTTP 7.2.4. Networking Commands Reference Table
7.2.1. Port Forwarding x
7.2.1.1. Incoming Port Forwarding 7.2.1.2. Outgoing Port Forwarding
7.2.1.1. Incoming Port Forwarding x
7.2.1.1.1. Example of an SSH Connection with Incoming Port Forwarding
7.2.1.2. Outgoing Port Forwarding x
7.2.1.2.1. Example of SSH Connection With Outgoing Port Forwarding 7.2.1.2.2. Example of SSH Connection via NAPT
7.2.2. Transferring Files Between Host PC and Target System x
7.2.2.1. Transferring Files with SCP service 7.2.2.2. Transferring Files with TFTP service
7.2.2.1. Transferring Files with SCP service x
7.2.2.1.1. Transferring Files With SCP Service via Forwarding Ports 7.2.2.1.2. Transferring Files with SCP from Target System to Host PC via NAPT
7.2.2.2. Transferring Files with TFTP service x
7.2.2.2.1. TFTP Using Forwarding Port 7.2.2.2.2. TFTP via NAPT 7.2.2.2.3. TFTP Using TFTP Server in Intel® Simics® Service Node
8. Intel® Simics® Scripting x
8.1. Scripts in CLI
8.1. Scripts in CLI x
8.1.1. Variables 8.1.2. Command Return Values 8.1.3. Control Flow Commands 8.1.4. Local Variables 8.1.5. Integer Conversion 8.1.6. Accessing Configuration Parameters 8.1.7. Error Handling in Scripts 8.1.8. Script Branches
8.1.8. Script Branches x
8.1.8.1. Script Branches Commands 8.1.8.2. Variables in Script Branches 8.1.8.3. Branch Synchronization 8.1.8.4. Canceling Script Branches 8.1.8.5. Script Branches Restrictions
9. Software Debug Examples with Intel® Simics® Simulator x
9.1. Debugging Linux* User-Mode Application
9.1. Debugging Linux* User-Mode Application x
9.1.1. Debugging a Linux Application with GDB 9.1.2. Debugging a Linux Application with RiscFree* IDE
9.1.1. Debugging a Linux Application with GDB x
9.1.1.1. Debugging with GDB Debug from Host PC Using Forwarding Ports 9.1.1.2. Debugging with GDB from Host PC with Intel® Simics® Simulator GDB Server
1. About This Document
2. Intel® Simics® Simulator and Virtual Platforms
3. Intel® Simics® Simulator for Intel® FPGAs Device Portfolio
4. Installing the Intel® Simics® Simulator for Intel® FPGAs
5. Getting Started with Intel® Simics® Simulator
6. Debugging Target Software
7. Networking with the Simulated Target System
8. Intel® Simics® Scripting
9. Software Debug Examples with Intel® Simics® Simulator
10. Document Revision History for Intel® Simics® Simulator for Intel FPGAs User Guide
A. Intel® Simics® Simulator Command Reference

9.1.2. Debugging a Linux Application with RiscFree* IDE

This section describes how to debug a Linux application using the RiscFree* debugger. The Linux application to debug is the same presented in Debugging a Linux Application with GDB. In this case, you also require having the symbols file of the application and the source code of the application so the debugger can access and perform the source code debug.

These are the items used for this debug example:

  • TestSymFile.c: Source code of the Linux application.
  • TestSymFile: Binary of the Linux application that must be executed from the Linux shell (ELF file). This was built to include the debug symbols embedded so this is also the symbols file.
  • /home/simicsUser/SimicsInstallDir/SymDbg: Directory where the source code of the Linux application is located and also where the application binary is located.

The steps to perform the Linux application debug are shown in the following:

  1. Start a new RiscFree* session using an Intel® Simics® project directory in which the binaries allow us to boot to Linux. For the example used in this topic, reuse the projectRiscFree Intel® Simics® project from Starting a Simulation with Ashling* RiscFree* IDE.
  2. Launch a debug configuration as follows:
    1. Select Run > Debug Configurations menu or click the down arrow in the Debug icon:
    2. Expand Intel® Simics® Session and double-click the debug configuration that you want to launch.
      If you have no Intel® Simics® sessions to launch, create a new one as follows:
      1. In the Debug Configurations window, double-click Intel® Simics® Session. This creates a new debug configuration called New_configuration.

        To create a new debug configuration, you can also select Intel® Simics® Session and click the New Launch Configuration icon:

      2. Edit the debug configuration as follows:
        • Name your debug configuration LinuxApplicationDebug.
        • In the Main tab, select Script and select your .simics target script that launches your simulation. In this example, you are launching uboot-linux_sdcard.simics. Ensure that the Start simulation at launch checkbox is cleared.
    3. Click Debug to launch the simulation and switch the RiscFree* IDE to the Debug perspective.
  3. Load the debug symbols for the application by adding the following line to the target script where you can also setup all your debug configuration:
    add-symbol-file "/home/simicsUser/SimicsInstallDir/SymDbg/TestSymFile"

    You can also load the debug symbols from the Symbols tab of the Debug Configuration. Select the core that runs the application from the Debug context field and click Add to add a path to the debug symbols file. Accept the default path to the symbols file.

    If you are unsure about which core executes your Linux application, you can add the same symbol file to each core by changing the selected core in the Debug context field and clicking Add again.

  4. Select File > Open File to open the test application source code file (TestSymFile.c) and set a breakpoint at the entry point of the main() function by double-clicking the line that display the function. The breakpoint is visible from the source code window and also from the Breakpoints window.
  5. Run the simulation by clicking Resume and waiting until the Linux prompt appears.
  6. Take the Linux application to the Linux kernel with the tftp command. To use tftp command, set the TFTP directory from the Service Node from the Intel® Simics® CLI:
    #Intel Simics simulator CLI 
running> service_node_cmp0.set-tftp-directory "/home/simicsUser/SimicsInstallDir/SymDbg"
    # Linux shell
root@dhcp0:~# tftp -gr testSymFile 10.10.0.1
root@dhcp0:~# chmod +x testSymFile
root@dhcp0:~# ls
README intelFPGA testSymFile
  7. Run the Linux application and wait for the breakpoint at the entry point of the main() function.
    # Linux shell
root@dhcp0:~# ./testSymFile

    Observe that, after the breakpoint triggers, the Debug window shows the program counter of the CPU 0 in which the source code execution stopped. Also, the function, file and line number are shown.

    The Source code window shows the current line in which the simulation stopped, and the Variables window shows the variables defined under this function including their types and current values. In this example, these variables have not been initialized yet.

  8. Advance the simulation using the Step-over button until it reaches the while loop. The value of the exitVar variable is initialized to 0, so the code remains in the loop forever. Also observe that the variable x has also been initialized to 1000, while the a,b, and c variables were not initialized so they might have any value. In the serial console, the debug message is already shown.
  9. Update the value of the exitVar variable to 1 so that the code execution leaves the while loop by clicking the variable value and entering a new value. Also, change the value of x variable to 2000, so you can modify the expected value from normal code execution. Click the Step-over button to observe that the code execution leaves the loop.
  10. Continue moving forward in the simulation using the Step-over button and observe how the variables are updated with the new value of x variable. The final value of the c variable is 4000. This value is printed in the serial console at the end of the execution of the Linux application.

    The RiscFree* IDE also has an Expressions window where you can define expressions using the variables defined in the source code and evaluate them.

    In the example that follows, observe the value of adding a, b, and c variables, or check if the current value of c is 4000 as expected.

With this example, the following features were demonstrated:

  • Create a debug configuration. You can launch this debug configuration later in other simulations to speed up the debug process.
  • Load symbol files and observe how the simulation advances in the execution of the source code.
  • Set breakpoints in the source code.
  • Control code execution using the Step-over button.
  • Observe the current value of the variables in the source code and update their values.
  • Observe and evaluate expressions related to the source code.
Level Two Title