christoph/failnix
1
Fork 0
Code Releases Activity

Add wasm tacle-bench targets

Browse Source
This commit is contained in:
Christoph Urlacher
2026-06-12 20:06:22 +02:00
parent 30daa8a00c
commit 08c2e9c13d
1122 changed files with 520422 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/host-build.sh Executable file
View File

@ -0,0 +1,52 @@
#!/bin/sh
#
# Script to compile "debie1" on the host Intel/Linux system
# using the target-specific code for mpc5554/gcc. This is
# meant to check that the MPC5554 port has no target-specific
# behaviour and (by default) no output; it does not generate
# an executable for the MPC5554.
#
# Any command-line arguments go into the CCOPT (eg. -Wpadded).
# As default, the trace output from the harness and target
# modules are disabled.
# Set tpd to the Test Program Directory:
tpd=../..
# Set hnd to the "harness" directory:
hnd=${tpd}/harness
# Native gcc and options:
export CC="gcc"
export CCOPT="-g -O2 -I. -I${hnd} -Wall $*"
export LD="gcc"
export LDOPT=
${CC} ${CCOPT} -c ${tpd}/class.c
${CC} ${CCOPT} -c ${tpd}/classtab.c
${CC} ${CCOPT} -c ${tpd}/debie.c
${CC} ${CCOPT} -c -I${tpd} ${hnd}/harness.c
${CC} ${CCOPT} -c ${tpd}/health.c
${CC} ${CCOPT} -c ${tpd}/hw_if.c
${CC} ${CCOPT} -c ${tpd}/measure.c
${CC} ${CCOPT} -c -I${tpd} target.c
${CC} ${CCOPT} -c ${tpd}/tc_hand.c
${CC} ${CCOPT} -c ${tpd}/telem.c
${CC} ${LDOPT} \
-o debie1 \
class.o \
classtab.o \
debie.o \
harness.o \
health.o \
hw_if.o \
measure.o \
target.o \
tc_hand.o \
telem.o

166
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/keyword.h Normal file
View File

@ -0,0 +1,166 @@
/*------------------------------------------------------------------------------
Copyright (C) 1998 : Space Systems Finland Ltd.
Space Systems Finland Ltd (SSF) allows you to use this version of
the DEBIE-I DPU software for the specific purpose and under the
specific conditions set forth in the Terms Of Use document enclosed
with or attached to this software. In particular, the software
remains the property of SSF and you must not distribute the software
to third parties without written and signed authorization from SSF.
System Name: DEBIE DPU SW
Subsystem : DNI (DEBIE Null Interface)
Module : keyword.h
Macro definitions for Keil specific keywords to be used
in portable parts of the DEBIE DPU software.
This version adapted to the GNU C compiler for the MPC5554.
Based on the SSF DHI file keyword.h, revision 1.9, Tue Mar 09 12:37:20 1999.
- * --------------------------------------------------------------------------
*/
#ifndef KEYWORD_H
#define KEYWORD_H
#include <string.h>
/* For memcpy (). */
/* Integer type definitions for native types that can hold integer
values of at least a given number of bits. These types are used
as loop counters to give the most natural and speedy code for
the current target. This is Not the C99 stdint.h, but the types
have similar names.
There is a particular form of this file for each (kind of) target
processor. The present form is for MPC5554/gcc, where the
widths the integer types are the following (as observed from the
code of the function Check_Type_Size in harness.c):
Type Octets Bits
char 1 8
short 2 16
int 4 32
long 4 32
This processor/compiler also has alignment concerns, so here we
define all telemetry data as octets and access it using memcpy()
instead of direct assignment.
*/
/* General types */
typedef int int_least8_t;
/* A signed integer covering at least -128 .. +127. */
typedef unsigned int uint_least8_t;
/* An unsigned integer covering at least 0 .. 255. */
typedef unsigned short uint16_t;
/* An unsigned 16-bit integer. */
typedef int int_least16_t;
/* A signed integer covering at least -2**15 .. +2**15 - 1. */
typedef unsigned int uint_least16_t;
/* An unsigned integer covering at least 0 .. 2**16 - 1. */
typedef uint16_t uskew16_t;
/* A 16-bit type, perhaps not an integer, perhaps not 16-bit aligned. */
/* If it is an integer type, it is unsigned. */
typedef unsigned int uint32_t;
/* An unsigned 32-bit integer. */
typedef uint32_t uskew32_t;
/* A 32-bit type, perhaps not an integer, perhaps not 32-bit aligned. */
/* If it is an integer type, it is unsigned. */
/* DEBIE-specific types */
typedef uint16_t data_address_t;
/* An address into external data memory. */
typedef uint16_t code_address_t;
/* An address into code memory. */
/* Macros for accessing the DPU data memory by numeric address. */
extern unsigned char *Data_Pointer ( uint16_t address );
#define DATA_POINTER(ADDR) Data_Pointer (ADDR)
/* Macros for accessing and copying multi-octet data. */
/* These may need target-specific adjustment if there are */
/* alignment restrictions on multi-octet integer values, */
/* because the operands in these macros may not be aligned */
/* in the required way. */
#define COPY(DEST,SOURCE) memcpy (&(DEST), &(SOURCE), sizeof(DEST))
/* Copies the value of SOURCE to the location DEST. */
extern unsigned short Short_Value ( uskew16_t *x );
#define VALUE_OF(SOURCE) Short_Value (&(SOURCE))
/* Returns the (integer) value of SOURCE, type uskew16_t. */
/* Macros for struct (aggregate) assignment. Some compilers */
/* may not support assignment statements for such types. */
#define STRUCT_ASSIGN(DEST,SOURCE,TYPE) DEST = SOURCE
/* Macros for calling "patch" functions */
typedef code_address_t fptr_t;
/* A function that is to be called after patching code memory. */
/* The function may or may not be part of the patched code. */
/* In the real SW this is "typedef void (*fptr_t)(void);" */
extern void Call_Patch ( fptr_t func );
/* "Call" the patch func. */
#define CALL_PATCH(FUNCTION) Call_Patch (FUNCTION)
/* Jump to the patched memory. */
/* Some macros for task and interrupt management */
#define TASK(TASK_NUMBER)
#define PRIORITY(LEVEL)
#define INTERRUPT(SOURCE)
#define USED_REG_BANK(BANK)
/* Macro for declaring re-entrant function */
#define REENTRANT_FUNC
/* Memory model handling macros */
#define COMPACT_DATA
#define COMPACT
#define PROGRAM
#define EXTERNAL
#define DIRECT_INTERNAL
#define INDIRECT_INTERNAL
#define LOCATION(ADDRESS)
/* Dealing with the benchmark target system */
#define TARGET_INIT {}
#define TARGET_MARK {}
#define TARGET_REBOOT {}
#define TARGET_START_TEST {}
#define TARGET_REPEAT_TEST 0
#endif

254
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/linker-mpc55xx-gcc.ld Normal file
View File

@ -0,0 +1,254 @@
/* Default linker script, for normal executables */
OUTPUT_FORMAT("elf32-powerpc", "elf32-powerpc", "elf32-powerpc")
OUTPUT_ARCH(powerpc:common)
ENTRY(_start)
/* where to search for stuff */
SEARCH_DIR("=/usr/local/lib");
SEARCH_DIR("=/lib");
SEARCH_DIR("=/usr/lib");
/* end of stack */
__stack = 0x4000fff8;
___stack = 0x4000fff8;
/* sections */
SECTIONS
{
/* read-only sections, merged into text segment: */
PROVIDE (__executable_start = 0x000002000);
. = 0x00002000 + SIZEOF_HEADERS;
.interp : { *(.interp) }
.hash : { *(.hash) }
.dynsym : { *(.dynsym) }
.dynstr : { *(.dynstr) }
.gnu.version : { *(.gnu.version) }
.gnu.version_d : { *(.gnu.version_d) }
.gnu.version_r : { *(.gnu.version_r) }
.rel.init : { *(.rel.init) }
.rela.init : { *(.rela.init) }
.rel.text : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
.rela.text : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
.rel.fini : { *(.rel.fini) }
.rela.fini : { *(.rela.fini) }
.rel.rodata : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
.rela.rodata : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
.rel.data.rel.ro : { *(.rel.data.rel.ro*) }
.rela.data.rel.ro : { *(.rel.data.rel.ro*) }
.rel.data : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
.rela.data : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
.rel.tdata : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
.rela.tdata : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
.rel.tbss : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
.rela.tbss : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
.rel.ctors : { *(.rel.ctors) }
.rela.ctors : { *(.rela.ctors) }
.rel.dtors : { *(.rel.dtors) }
.rela.dtors : { *(.rela.dtors) }
.rel.got : { *(.rel.got) }
.rela.got : { *(.rela.got) }
.rela.got1 : { *(.rela.got1) }
.rela.got2 : { *(.rela.got2) }
.rel.sdata : { *(.rel.sdata .rel.sdata.* .rel.gnu.linkonce.s.*) }
.rela.sdata : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
.rel.sbss : { *(.rel.sbss .rel.sbss.* .rel.gnu.linkonce.sb.*) }
.rela.sbss : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
.rel.sdata2 : { *(.rel.sdata2 .rel.sdata2.* .rel.gnu.linkonce.s2.*) }
.rela.sdata2 : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
.rel.sbss2 : { *(.rel.sbss2 .rel.sbss2.* .rel.gnu.linkonce.sb2.*) }
.rela.sbss2 : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
.rel.bss : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
.rela.bss : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
.rel.plt : { *(.rel.plt) }
.rela.plt : { *(.rela.plt) }
.init :
{
KEEP (*(.init))
} =0
.text :
{
*(.text .stub .text.* .gnu.linkonce.t.*)
KEEP (*(.text.*personality*))
/* .gnu.warning sections are handled specially by elf32.em. */
*(.gnu.warning)
} =0
.fini :
{
KEEP (*(.fini))
} =0
PROVIDE (__etext = .);
PROVIDE (_etext = .);
PROVIDE (etext = .);
.rodata : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
.rodata1 : { *(.rodata1) }
.sdata2 : { *(.sdata2 .sdata2.* .gnu.linkonce.s2.*) }
.sbss2 : { *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*) }
.eh_frame_hdr : { *(.eh_frame_hdr) }
.eh_frame : ONLY_IF_RO { KEEP (*(.eh_frame)) }
.gcc_except_table : ONLY_IF_RO { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }
/* Exception handling */
.eh_frame : ONLY_IF_RW { KEEP (*(.eh_frame)) }
.gcc_except_table : ONLY_IF_RW { KEEP (*(.gcc_except_table)) *(.gcc_except_table.*) }
/* Ensure the __preinit_array_start label is properly aligned. We
could instead move the label definition inside the section, but
the linker would then create the section even if it turns out to
be empty, which isn't pretty. */
. = ALIGN(32 / 8);
PROVIDE (__preinit_array_start = .);
.preinit_array : { KEEP (*(.preinit_array)) }
PROVIDE (__preinit_array_end = .);
PROVIDE (__init_array_start = .);
.init_array : { KEEP (*(.init_array)) }
PROVIDE (__init_array_end = .);
PROVIDE (__fini_array_start = .);
.fini_array : { KEEP (*(.fini_array)) }
PROVIDE (__fini_array_end = .);
.ctors :
{
/* gcc uses crtbegin.o to find the start of
the constructors, so we make sure it is
first. Because this is a wildcard, it
doesn't matter if the user does not
actually link against crtbegin.o; the
linker won't look for a file to match a
wildcard. The wildcard also means that it
doesn't matter which directory crtbegin.o
is in. */
KEEP (*crtbegin*.o(.ctors))
/* We don't want to include the .ctor section from
from the crtend.o file until after the sorted ctors.
The .ctor section from the crtend file contains the
end of ctors marker and it must be last */
KEEP (*(EXCLUDE_FILE (*crtend*.o ) .ctors))
KEEP (*(SORT(.ctors.*)))
KEEP (*(.ctors))
}
.dtors :
{
KEEP (*crtbegin*.o(.dtors))
KEEP (*(EXCLUDE_FILE (*crtend*.o ) .dtors))
KEEP (*(SORT(.dtors.*)))
KEEP (*(.dtors))
}
.jcr : { KEEP (*(.jcr)) }
.data.rel.ro : { *(.data.rel.ro.local) *(.data.rel.ro*) }
.fixup : { *(.fixup) }
.got1 : { *(.got1) }
.got2 : { *(.got2) }
.dynamic : { *(.dynamic) }
.got : { *(.got.plt) *(.got) }
.plt : { *(.plt) }
/* put some stuff into external ram */
. = 0x20000000;
.externalram : { *(.externalram) }
/* put data segment into internal sram */
. = 0x40000000;
. = DATA_SEGMENT_ALIGN (0x10000, 0x1000);
/* thread Local Storage sections */
.tdata : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
.tbss : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
.data :
{
*(.data .data.* .gnu.linkonce.d.*)
KEEP (*(.gnu.linkonce.d.*personality*))
SORT(CONSTRUCTORS)
}
.data1 : { *(.data1) }
/* We want the small data sections together, so single-instruction offsets
can access them all, and initialized data all before uninitialized, so
we can shorten the on-disk segment size. */
.sdata :
{
*(.sdata .sdata.* .gnu.linkonce.s.*)
}
_edata = .;
PROVIDE (edata = .);
__bss_start = .;
.sbss :
{
PROVIDE (__sbss_start = .);
PROVIDE (___sbss_start = .);
*(.dynsbss)
*(.sbss .sbss.* .gnu.linkonce.sb.*)
*(.scommon)
PROVIDE (__sbss_end = .);
PROVIDE (___sbss_end = .);
}
.bss :
{
*(.dynbss)
*(.bss .bss.* .gnu.linkonce.b.*)
*(COMMON)
/* Align here to ensure that the .bss section occupies space up to
_end. Align after .bss to ensure correct alignment even if the
.bss section disappears because there are no input sections. */
. = ALIGN(32 / 8);
}
. = ALIGN(32 / 8);
_end = .;
__end = .;
PROVIDE (end = .);
. = DATA_SEGMENT_END (.);
/* Stabs debugging sections. */
.stab 0 : { *(.stab) }
.stabstr 0 : { *(.stabstr) }
.stab.excl 0 : { *(.stab.excl) }
.stab.exclstr 0 : { *(.stab.exclstr) }
.stab.index 0 : { *(.stab.index) }
.stab.indexstr 0 : { *(.stab.indexstr) }
.comment 0 : { *(.comment) }
/* DWARF debug sections.
Symbols in the DWARF debugging sections are relative to the beginning
of the section so we begin them at 0. */
/* DWARF 1 */
.debug 0 : { *(.debug) }
.line 0 : { *(.line) }
/* GNU DWARF 1 extensions */
.debug_srcinfo 0 : { *(.debug_srcinfo) }
.debug_sfnames 0 : { *(.debug_sfnames) }
/* DWARF 1.1 and DWARF 2 */
.debug_aranges 0 : { *(.debug_aranges) }
.debug_pubnames 0 : { *(.debug_pubnames) }
/* DWARF 2 */
.debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
.debug_abbrev 0 : { *(.debug_abbrev) }
.debug_line 0 : { *(.debug_line) }
.debug_frame 0 : { *(.debug_frame) }
.debug_str 0 : { *(.debug_str) }
.debug_loc 0 : { *(.debug_loc) }
.debug_macinfo 0 : { *(.debug_macinfo) }
/* SGI/MIPS DWARF 2 extensions */
.debug_weaknames 0 : { *(.debug_weaknames) }
.debug_funcnames 0 : { *(.debug_funcnames) }
.debug_typenames 0 : { *(.debug_typenames) }
.debug_varnames 0 : { *(.debug_varnames) }
/DISCARD/ : { *(.note.GNU-stack) }
}

20
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/problems.h Normal file
View File

@ -0,0 +1,20 @@
/*
problems.h for mpc5554/gcc.
Part of the DEBIE-1 benchmark.
*/
#ifndef PROBLEMS_H
#define PROBLEMS_H
#define FOR_PROBLEM(P) {}
/* A marker to indicate that the program is about to execute */
/* a test case that is to be included in the analysis problem */
/* identified by P. */
#define END_PROBLEM {}
/* A marker to indicate the end of a test case that is to be */
/* included in the analysis problem identified by the last */
/* executed FOR_PROBLEM. */
#endif

12
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/readme.txt Normal file
View File

@ -0,0 +1,12 @@
This folder contains header files and a build script
that compile and link the DEBIE-1 DPU SW benchmark for
execution on an MPC5554 processor. The completed
executable file is also provided.
The generated executable runs the test cases defined
in harness.c once and then stops. The executable does not
generate any output.
This port was contributed by Simon Wegener of AbsInt Angewandte
Informatik GmbH.

49
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/target-build.sh Executable file
View File

@ -0,0 +1,49 @@
#!/bin/sh
#
# Script to cross-compile "debie1" for the MPC5554 with the
# CodeSourcery "G++ lite" GCC package.
#
# Any command-line arguments go into the CCOPT (eg. -Wpadded).
# As default, the trace output from the harness and target
# modules are disabled.
#
# One has to set the path to the compiler (i.e. CC) accordingly.
# Set tpd to the Test Program Directory:
tpd=../..
# Set hnd to the "harness" directory:
hnd=${tpd}/harness
# Target gcc and options:
export CC="/local/swegener/CodeSourcery/Sourcery_G++_Lite/bin/powerpc-eabi-gcc"
export CCOPT="-te500v1 -fshort-double -g -O2 -I. -I${hnd} -Wall -Wextra $*"
export LD="/local/swegener/CodeSourcery/Sourcery_G++_Lite/bin/powerpc-eabi-gcc"
export LDOPT="-te500v1 -fshort-double -Wl,-T./linker-mpc55xx-gcc.ld -static"
${CC} ${CCOPT} -c ${tpd}/class.c
${CC} ${CCOPT} -c ${tpd}/classtab.c
${CC} ${CCOPT} -c ${tpd}/debie.c
${CC} ${CCOPT} -c -I${tpd} ${hnd}/harness.c
${CC} ${CCOPT} -c ${tpd}/health.c
${CC} ${CCOPT} -c ${tpd}/hw_if.c
${CC} ${CCOPT} -c ${tpd}/measure.c
${CC} ${CCOPT} -c -I${tpd} target.c
${CC} ${CCOPT} -c ${tpd}/tc_hand.c
${CC} ${CCOPT} -c ${tpd}/telem.c
${CC} ${LDOPT} \
-o debie1.elf \
class.o \
classtab.o \
debie.o \
harness.o \
health.o \
hw_if.o \
measure.o \
target.o \
tc_hand.o \
telem.o

84
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/target.c Normal file
View File

@ -0,0 +1,84 @@
/*------------------------------------------------------------------------------
Copyright (C) 1998 : Space Systems Finland Ltd.
Space Systems Finland Ltd (SSF) allows you to use this version of
the DEBIE-I DPU software for the specific purpose and under the
specific conditions set forth in the Terms Of Use document enclosed
with or attached to this software. In particular, the software
remains the property of SSF and you must not distribute the software
to third parties without written and signed authorization from SSF.
System Name: DEBIE DPU SW, test harness for WCET analysis
Subsystem : DNI (DEBIE Null Interface)
Module : target.c
Target-specific implementations of the DNI operations, specifically
for the mpc5554/gcc target.
Options: if the preprocessor symbol TRACE_TARGET is defined,
these operations generate trace message on stdout.
Based, with extensive changes, on parts of the SSF file rtx_if.c,
rev 1.13, Fri May 21 00:14:00 1999.
- * --------------------------------------------------------------------------
*/
/* This file contains one set of operations, as follows:
> memory operations: dpu_ctrl.h
*/
#if defined(TRACE_TARGET)
#include <stdio.h>
#endif
#include "keyword.h"
/* Memory operations : dpu_ctrl.h */
#include "dpu_ctrl.h"
static char data_memory[ 65536 ] __attribute__( ( section( ".externalram" ) ) );
/* Simulated 80C32 external data RAM. */
unsigned char *Data_Pointer ( uint16_t address )
{
return &data_memory[ address ];
}
void Set_Data_Byte ( data_address_t addr, unsigned char value )
{
#if defined(TRACE_TARGET)
printf ( "Set_Data_Byte 0x%x to %d = 0x%x\n", addr, value, value );
#endif
data_memory[ addr ] = value;
}
unsigned char Get_Data_Byte ( data_address_t addr )
{
unsigned char value = data_memory[ addr ];
#if defined(TRACE_TARGET)
printf ( "Get_Data_Byte 0x%x is %d = 0x%x\n", addr, value, value );
#endif
return value;
}
unsigned char Get_Code_Byte ( code_address_t addr )
{
#if defined(TRACE_TARGET)
/* printf ("Get_Code_Byte 0x%x\n", addr); */
/* This would be to much output. Skip. */
#endif
return 0;
}

31
targets/wasm-tacle/parallel/DEBIE/code/arch/mpc5554/target_tm_data.h Normal file
View File

@ -0,0 +1,31 @@
/*------------------------------------------------------------------------------
Copyright (C) 1998 : Space Systems Finland Ltd.
Space Systems Finland Ltd (SSF) allows you to use this version of
the DEBIE-I DPU software for the specific purpose and under the
specific conditions set forth in the Terms Of Use document enclosed
with or attached to this software. In particular, the software
remains the property of SSF and you must not distribute the software
to third parties without written and signed authorization from SSF.
System Name: DEBIE DPU SW
Module : target_tm_data.h
The target-specific aspects of the Telemetry Data Structure.
This version for the target mpc5554/gcc.
Based on the SSF file tm_data.h, rev 1.22, Mon May 31 10:10:12 1999.
- * --------------------------------------------------------------------------
*/
#ifndef TARGET_TM_DATA_H
#define TARGET_TM_DATA_H
#define MAX_EVENTS 1261
/* Same as in the original DEBIE-1 SW, although there limited
by the size of the data memory.
*/
#endif