nintendoswitch: fix import cycle on dynamic_arm64.go

src/runtime/dynamic_arm64.go

@@ -1,37 +1,53 @@
 package runtime
 
 import (
-	"debug/elf"
 	"unsafe"
 )
 
 const debugLoader = false
 
+const (
+	R_AARCH64_RELATIVE = 1027
+	DT_NULL            = 0 /* Terminating entry. */
+	DT_RELA            = 7 /* Address of ElfNN_Rela relocations. */
+	DT_RELASZ          = 8 /* Total size of ElfNN_Rela relocations. */
+)
+
+/* ELF64 relocations that need an addend field. */
+type Rela64 struct {
+	Off    uint64 /* Location to be relocated. */
+	Info   uint64 /* Relocation type and symbol index. */
+	Addend int64  /* Addend. */
+}
+
+// ELF64 Dynamic structure. The ".dynamic" section contains an array of them.
+type Dyn64 struct {
+	Tag int64  /* Entry type. */
+	Val uint64 /* Integer/address value */
+}
+
 //export __dynamic_loader
-func dynamicLoader(base uintptr, dyn *elf.Dyn64) {
+func dynamicLoader(base uintptr, dyn *Dyn64) {
-	var rela *elf.Rela64
+	var rela *Rela64
 	relasz := uint64(0)
 
 	if debugLoader {
 		println("ASLR Base: ", base)
 	}
 
-	for dyn.Tag != int64(elf.DT_NULL) {
+	for dyn.Tag != DT_NULL {
-		switch elf.DynTag(dyn.Tag) {
+		switch dyn.Tag {
-		case elf.DT_RELA:
+		case DT_RELA:
-			rela = (*elf.Rela64)(unsafe.Pointer(base + uintptr(dyn.Val)))
+			rela = (*Rela64)(unsafe.Pointer(base + uintptr(dyn.Val)))
-		case elf.DT_RELASZ:
+		case DT_RELASZ:
-			relasz = uint64(dyn.Val) / uint64(unsafe.Sizeof(elf.Rela64{}))
+			relasz = uint64(dyn.Val) / uint64(unsafe.Sizeof(Rela64{}))
 		}
 
 		ptr := uintptr(unsafe.Pointer(dyn))
-		ptr += unsafe.Sizeof(elf.Dyn64{})
+		ptr += unsafe.Sizeof(Dyn64{})
-		dyn = (*elf.Dyn64)(unsafe.Pointer(ptr))
+		dyn = (*Dyn64)(unsafe.Pointer(ptr))
 	}
 
-	if rela == nil {
-		runtimePanic("bad reloc")
-	}
 	if rela == nil {
 		runtimePanic("bad reloc")
 	}
@@ -41,15 +57,15 @@ func dynamicLoader(base uintptr, dyn *elf.Dyn64) {
 	}
 
 	for relasz > 0 && rela != nil {
-		switch elf.R_AARCH64(rela.Info) {
+		switch rela.Info {
-		case elf.R_AARCH64_RELATIVE:
+		case R_AARCH64_RELATIVE:
 			ptr := (*uint64)(unsafe.Pointer(base + uintptr(rela.Off)))
 			*ptr = uint64(base + uintptr(rela.Addend))
 		}
 
 		rptr := uintptr(unsafe.Pointer(rela))
-		rptr += unsafe.Sizeof(elf.Rela64{})
+		rptr += unsafe.Sizeof(Rela64{})
-		rela = (*elf.Rela64)(unsafe.Pointer(rptr))
+		rela = (*Rela64)(unsafe.Pointer(rptr))
 		relasz--
 	}
 }