arm64: make dynamic loader structs and constants private

src/runtime/dynamic_arm64.go

@@ -7,45 +7,45 @@ import (
 const debugLoader = false
 
 const (
-	R_AARCH64_RELATIVE = 1027
+	rAARCH64_RELATIVE = 1027
-	DT_NULL            = 0 /* Terminating entry. */
+	dtNULL            = 0 /* Terminating entry. */
-	DT_RELA            = 7 /* Address of ElfNN_Rela relocations. */
+	dtRELA            = 7 /* Address of ElfNN_Rela relocations. */
-	DT_RELASZ          = 8 /* Total size of ElfNN_Rela relocations. */
+	dtRELASZ          = 8 /* Total size of ElfNN_Rela relocations. */
 )
 
 /* ELF64 relocations that need an addend field. */
-type Rela64 struct {
+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 {
+type dyn64 struct {
 	Tag int64  /* Entry type. */
 	Val uint64 /* Integer/address value */
 }
 
 //export __dynamic_loader
-func dynamicLoader(base uintptr, dyn *Dyn64) {
+func dynamicLoader(base uintptr, dyn *dyn64) {
-	var rela *Rela64
+	var rela *rela64
 	relasz := uint64(0)
 
 	if debugLoader {
 		println("ASLR Base: ", base)
 	}
 
-	for dyn.Tag != DT_NULL {
+	for dyn.Tag != dtNULL {
 		switch dyn.Tag {
-		case DT_RELA:
+		case dtRELA:
-			rela = (*Rela64)(unsafe.Pointer(base + uintptr(dyn.Val)))
+			rela = (*rela64)(unsafe.Pointer(base + uintptr(dyn.Val)))
-		case DT_RELASZ:
+		case dtRELASZ:
-			relasz = uint64(dyn.Val) / uint64(unsafe.Sizeof(Rela64{}))
+			relasz = uint64(dyn.Val) / uint64(unsafe.Sizeof(rela64{}))
 		}
 
 		ptr := uintptr(unsafe.Pointer(dyn))
-		ptr += unsafe.Sizeof(Dyn64{})
+		ptr += unsafe.Sizeof(dyn64{})
-		dyn = (*Dyn64)(unsafe.Pointer(ptr))
+		dyn = (*dyn64)(unsafe.Pointer(ptr))
 	}
 
 	if rela == nil {
@@ -58,14 +58,14 @@ func dynamicLoader(base uintptr, dyn *Dyn64) {
 
 	for relasz > 0 && rela != nil {
 		switch rela.Info {
-		case R_AARCH64_RELATIVE:
+		case rAARCH64_RELATIVE:
 			ptr := (*uint64)(unsafe.Pointer(base + uintptr(rela.Off)))
 			*ptr = uint64(base + uintptr(rela.Addend))
 		}
 
 		rptr := uintptr(unsafe.Pointer(rela))
-		rptr += unsafe.Sizeof(Rela64{})
+		rptr += unsafe.Sizeof(rela64{})
-		rela = (*Rela64)(unsafe.Pointer(rptr))
+		rela = (*rela64)(unsafe.Pointer(rptr))
 		relasz--
 	}
 }