llext: add fixes for various tests on mwdt / harvard arch

Adds fixes to get LLEXT tests to work for NSIM VPX on MWDT.

Excludes prelocated extensions for MWDT for now.

Signed-off-by: Lauren Murphy <[email protected]>

Author: laurenmurphyx64

cmake/linker/arcmwdt/linker_flags.cmake

@@ -36,6 +36,8 @@ check_set_linker_property(TARGET linker PROPERTY orphan_error
                           ${LINKERFLAGPREFIX},--orphan-handling=error
 )
 
+set_property(TARGET linker PROPERTY partial_linking "-r")
+
 # Extra warnings options for twister run
 set_property(TARGET linker PROPERTY warnings_as_errors -Wl,--fatal-warnings)
 

samples/subsys/llext/modules/sample.yaml

@@ -7,7 +7,9 @@ common:
     - mps2/an385              # ARM Cortex-M3 (ARMv7-M ISA)
     - mps2/an521/cpu0         # ARM Cortex-M33 (ARMv8-M ISA)
     - qemu_xtensa/dc233c
+    - qemu_arc/qemu_arc_em
   integration_platforms:
+    - qemu_arc/qemu_arc_em
     - qemu_xtensa/dc233c
     - mps2/an385
     - qemu_cortex_a53
@@ -26,6 +28,7 @@ tests:
       # security benefits.
       - arch:arm:CONFIG_ARM_MPU=n
       - arch:arm:CONFIG_ARM_AARCH32_MMU=n
+      - arch:arc:CONFIG_ARC_MPU_ENABLE=n
     harness_config:
       type: one_line
       regex:

subsys/llext/llext_load.c

@@ -312,6 +312,21 @@ static int llext_map_sections(struct llext_loader *ldr, struct llext *ext,
 		 * regions.
 		 */
 		if (ldr_parm->section_detached && ldr_parm->section_detached(shdr)) {
+			if (mem_idx == LLEXT_MEM_TEXT &&
+			    !INSTR_FETCHABLE(llext_peek(ldr, shdr->sh_offset), shdr->sh_size)) {
+#ifdef CONFIG_ARC
+				LOG_ERR("ELF buffer's detached text section %s not in instruction "
+					"memory: %p-%p",
+					name, (void *)(llext_peek(ldr, shdr->sh_offset)),
+					(void *)((char *)llext_peek(ldr, shdr->sh_offset) +
+						 shdr->sh_size));
+				return -ENOEXEC;
+#else
+				LOG_WRN("Unknown if ELF buffer's detached text section %s is in "
+					"instruction memory; proceeding...",
+					name);
+#endif
+			}
 			continue;
 		}
 

subsys/llext/llext_mem.c

@@ -127,8 +127,10 @@ static int llext_copy_region(struct llext_loader *ldr, struct llext *ext,
 			/* Region has data in the file, check if peek() is supported */
 			ext->mem[mem_idx] = llext_peek(ldr, region->sh_offset);
 			if (ext->mem[mem_idx]) {
-				if (IS_ALIGNED(ext->mem[mem_idx], region_align) ||
-				    ldr_parm->pre_located) {
+				if ((IS_ALIGNED(ext->mem[mem_idx], region_align) ||
+				     ldr_parm->pre_located) &&
+				    ((mem_idx != LLEXT_MEM_TEXT) ||
+				     INSTR_FETCHABLE(ext->mem[mem_idx], region_alloc))) {
 					/* Map this region directly to the ELF buffer */
 					llext_init_mem_part(ext, mem_idx,
 							    (uintptr_t)ext->mem[mem_idx],
@@ -137,8 +139,18 @@ static int llext_copy_region(struct llext_loader *ldr, struct llext *ext,
 					return 0;
 				}
 
-				LOG_WRN("Cannot peek region %d: %p not aligned to %#zx",
-					mem_idx, ext->mem[mem_idx], (size_t)region_align);
+				if ((mem_idx == LLEXT_MEM_TEXT) &&
+				    !INSTR_FETCHABLE(ext->mem[mem_idx], region_alloc)) {
+					LOG_WRN("Cannot reuse ELF buffer for region %d, not "
+						"instruction memory: %p-%p",
+						mem_idx, ext->mem[mem_idx],
+						(void *)((uintptr_t)(ext->mem[mem_idx]) +
+							 region->sh_size));
+				}
+				if (!IS_ALIGNED(ext->mem[mem_idx], region_align)) {
+					LOG_WRN("Cannot peek region %d: %p not aligned to %#zx",
+						mem_idx, ext->mem[mem_idx], (size_t)region_align);
+				}
 			}
 		} else if (ldr_parm->pre_located) {
 			/*

subsys/llext/llext_priv.h

@@ -11,6 +11,26 @@
 #include <zephyr/llext/llext.h>
 #include <zephyr/llext/llext_internal.h>
 #include <zephyr/sys/slist.h>
+#include <zephyr/device.h>
+#include <zephyr/devicetree.h>
+
+/*
+ * Macro to determine if section / region is in instruction memory
+ * Will need to be updated if any non-ARC boards using Harvard architecture is added
+ */
+#if CONFIG_HARVARD && CONFIG_ARC
+#define IN_NODE(inst, compat, base_addr, alloc)                                                    \
+	(((uintptr_t)(base_addr) >= DT_REG_ADDR(DT_INST(inst, compat)) &&                          \
+	  (uintptr_t)(base_addr + alloc) <=                                                        \
+		  DT_REG_ADDR(DT_INST(inst, compat)) + DT_REG_SIZE(DT_INST(inst, compat)))) ||
+#define INSTR_FETCHABLE(base_addr, alloc)                                                          \
+	DT_COMPAT_FOREACH_STATUS_OKAY_VARGS(arc_iccm, IN_NODE, base_addr, alloc) false
+#elif CONFIG_HARVARD && !CONFIG_ARC
+/* Unknown if section / region is in instruction memory; warn or compensate */
+#define INSTR_FETCHABLE(base_addr, alloc) false
+#else /* all non-Harvard architectures */
+#define INSTR_FETCHABLE(base_addr, alloc) true
+#endif
 
 /*
  * Global extension list

tests/subsys/llext/CMakeLists.txt

@@ -74,7 +74,7 @@ get_property(COMPILER_TOPT TARGET compiler PROPERTY linker_script)
 set_ifndef(  TOPT "${COMPILER_TOPT}")
 set_ifndef(  TOPT -Wl,-T) # Use this if the compiler driver doesn't set a value
 
-if (CONFIG_LLEXT_TYPE_ELF_RELOCATABLE AND NOT CONFIG_ARM AND NOT CONFIG_RISCV)
+if (CONFIG_LLEXT_TYPE_ELF_RELOCATABLE AND CONFIG_XTENSA)
   # Manually fix the pre_located extension's text address at a multiple of 4
   get_target_property(pre_located_target pre_located_ext lib_target)
   get_target_property(pre_located_file pre_located_ext pkg_input)

tests/subsys/llext/src/test_llext.c

@@ -267,7 +267,8 @@ LLEXT_LOAD_UNLOAD(hello_world,
 	.kernel_only = true
 )
 
-#ifndef CONFIG_LLEXT_TYPE_ELF_SHAREDLIB
+/* When compiled with CCAC, init_fini's sections are unfixably out of order */
+#if !defined(CONFIG_LLEXT_TYPE_ELF_SHAREDLIB) && !defined(__CCAC__)
 static LLEXT_CONST uint8_t init_fini_ext[] ELF_ALIGN = {
 	#include "init_fini.inc"
 };
@@ -375,10 +376,24 @@ ZTEST(llext, test_inspect)
 	res = llext_load(ldr, "inspect", &ext, &ldr_parm);
 	zassert_ok(res, "load should succeed");
 
+	/* MWDT puts variables that are supposed to go into .bss into .data,
+	 * and, when Harvard / CCM is enabled, puts rodata in data-type sections.
+	 */
+#ifdef __CCAC__
+	do_inspect_checks(ldr, ext, LLEXT_MEM_DATA, ".data", "number_in_bss");
+#else
 	do_inspect_checks(ldr, ext, LLEXT_MEM_BSS, ".bss", "number_in_bss");
-	do_inspect_checks(ldr, ext, LLEXT_MEM_DATA, ".data", "number_in_data");
+#endif
+
+#if defined(CONFIG_HARVARD) && defined(__CCAC__)
+	do_inspect_checks(ldr, ext, LLEXT_MEM_DATA, ".rodata_in_data", "number_in_rodata");
+	do_inspect_checks(ldr, ext, LLEXT_MEM_DATA, ".my_rodata", "number_in_my_rodata");
+#else
 	do_inspect_checks(ldr, ext, LLEXT_MEM_RODATA, ".rodata", "number_in_rodata");
 	do_inspect_checks(ldr, ext, LLEXT_MEM_RODATA, ".my_rodata", "number_in_my_rodata");
+#endif
+
+	do_inspect_checks(ldr, ext, LLEXT_MEM_DATA, ".data", "number_in_data");
 	do_inspect_checks(ldr, ext, LLEXT_MEM_TEXT, ".text", "function_in_text");
 
 	max_alloc_bytes = ext->alloc_size;
@@ -526,7 +541,12 @@ ZTEST(llext, test_find_section)
 	llext_unload(&ext);
 }
 
+/* For Harvard architectures, the detached section must be placed in instruction memory. */
+#ifdef CONFIG_HARVARD
+static LLEXT_CONST uint8_t test_detached_ext[] Z_GENERIC_SECTION(.text) ELF_ALIGN = {
+#else
 static LLEXT_CONST uint8_t test_detached_ext[] ELF_ALIGN = {
+#endif
 	#include "detached_fn.inc"
 };