Fix DTPMOD relocation

src/ld_so/dso.rs

···
             (None, None)
         };
 
-        let (s, t) = sym
+        let (s, t, tls_id) = sym
             .as_ref()
-            .map(|(sym, obj)| (sym.as_ptr() as usize, obj.tls_offset))
-            .unwrap_or((0, 0));
+            .map(|(sym, obj)| (sym.as_ptr() as usize, obj.tls_offset, obj.tls_module_id))
+            //TODO: is self.tls_module_id the right fallback?
+            .unwrap_or((0, 0, self.tls_module_id));
 
         let ptr = if self.pie {
             (b + reloc.offset) as *mut u8
···
         };
 
         match reloc.kind {
-            RelocationKind::DTPMOD => set_usize(self.tls_module_id),
+            RelocationKind::DTPMOD => set_usize(tls_id),
             //TODO: Subtract DTP_OFFSET, which is 0x800 on riscv64, 0 on x86?
             RelocationKind::DTPOFF => {
                 if reloc.sym.0 > 0 {
···
                 } else {
                     set_usize(a);
                 }
-            },
+            }
             RelocationKind::GOT => set_usize(s),
             RelocationKind::OFFSET => set_usize((s + a).wrapping_sub(p)),
             RelocationKind::RELATIVE => set_usize(b + a),
···
 
                     let resolved = resolve_sym(name, &[global_scope, self.scope()])
                         .map(|(sym, _, _)| sym.as_ptr() as usize)
-                        .unwrap_or_else(|| panic!("unresolved symbol: {name} for soname {:?}", self.dynamic.soname));
+                        .unwrap_or_else(|| {
+                            panic!(
+                                "unresolved symbol: {name} for soname {:?}",
+                                self.dynamic.soname
+                            )
+                        });
 
                     unsafe {
                         *ptr = resolved + reloc.addend.unwrap_or(0);