cheery / g386 / changeset / 4ce524aa90f3

Up to file-list dev/shared.asm:

 bits 32
 ; nasm -f elf shared.asm
 ; ld shared.o -melf_i386 -o libshared.so -shared
 extern _GLOBAL_OFFSET_TABLE_
 global example_function:function
 example_function:
     mov eax, 5000
     ret

Up to file-list examples/shared.py:

 # -*- coding: utf-8 -*-
 """
     shared
     ~~~~~~
     :copyright: 2010 by Henri Tuhola <henri.tuhola@gmail.com>
     Produces a position independent executable.
 """
 from g386 import (
     X86, Bytes, elf,
     r0,r1,r2,r3,r4,r5,r6,r7,
     Deref, Index,
+)
 unused_regs = [r0, r1, r2, r3, r6, r7]
 program = []
 def code():
     x86 = X86(unused_regs)
     program.append(x86)
     return x86
 x = example_function = code()
 x.move(r0, 1234)
 x.ret()
 lib = elf.Dynamic(['libc.so.6'], shared=True)
 x = entry = code()
 x.store(Deref(r4), 1)
 x.call(Deref(x.pic(lib['exit'])))
 lib.export('example_function', example_function)
 if __name__ == '__main__':
     elf.executable(open('libshared.so', 'w'), program, entry, lib)

Up to file-list g386/__init__.py:

 """
 from core import (
     Assembly, Instruction, Register,
-    Imm32, Imm8, Rel32, Indirect,
+    Imm32, Imm8, Rel32, IPR32, Indirect,
     ModRM, Bytes,
     isconst, isnum, isreg,
+)
@@ -25,6 +25,16 @@ ccs = [
+]
 @X86.instruction
 def pic(gen, source):
     reg = gen.get_gpr()
     gen.emit('\xe8\x00\x00\x00\x00')
     gen.emit(
         '\x8f', ModRM(0, reg),
         '\x81', ModRM(0, reg), IPR32(source)
+    )
     return reg
 @X86.instruction
 def cmov(gen, mode, dst, src):
     dst = gen.to_reg(dst)
     src = gen.to_indirect(src)

Up to file-list g386/core.py:

@@ -94,6 +94,18 @@ class Rel32(object):
     def __repr__(self):
         return "Rel32(%r)" % self.value
 class IPR32(object):
     size = 4
     def __init__(self, value):
         self.value = value
     def compose(self, instr):
         origin = instr.address
         return struct.pack('i', self.value.address - origin)
     def __repr__(self):
         return "Rel32(%r)" % self.value
 class Register(object):
     def __init__(self, index):
         self.index = index

Up to file-list g386/elf.py:

@@ -34,8 +34,8 @@ def buildheader(**data):
         data.get('ehdrsize', headersize),
         data.get('phdrsize', loadersize),
         data.get('phdrnum', 1),
         data.get('shdrsize', 0),
         data.get('shdrnum', 1),
         data.get('shdrsize', 40),
         data.get('shdrnum', 0),
         data.get('shstrndx', 0),
+    )
@@ -73,9 +73,10 @@ class Strings(object):
 class SymbolTable(object):
     first_sym = 2
     entsize = struct.calcsize('3i2H')
-    def __init__(self, strtab, symbols):
+    def __init__(self, strtab, symbols, exports):
         self.strtab = strtab
         self.symbols = symbols
         self.exports = exports
         self.indices = dict(
             (sym, i+self.first_sym)
             for i, sym in enumerate(symbols)
@@ -89,7 +90,12 @@ class SymbolTable(object):
             self.strtab['_DYNAMIC'], self.dynamic.address, 0, 0x11, 0xfff1
+        )
         for symbol in self.symbols:
-            entries += struct.pack('3i2H', self.strtab[symbol], 0, 0, 0x12, 0)
+            value = 0
             ndx = 0
             if symbol in self.exports:
                 value = self.exports[symbol].address
                 ndx = 0xfff1
             entries += struct.pack('3i2H', self.strtab[symbol], value, 0, 0x12, ndx)
         return entries
 class DynTab(object):
@@ -154,23 +160,33 @@ class Dynamic(object):
     You can think of it as an address of a location that tells where
     the 'sleep' -function is in your process image.
     """
-    def __init__(self, libraries):
+    def __init__(self, libraries, shared=False):
         self.libraries = libraries
-        self.keys = dict()
+        self.shared = shared
         self.globals = dict()
         self.exports = dict()
     def __getitem__(self, key):
         if key in self.keys:
             return self.keys[key]
         if key in self.globals:
             return self.globals[key]
         else:
             cell = core.Bytes('\x00'*4)
-            self.keys[key] = cell
+            self.globals[key] = cell
             return cell
     def export(self, name, assembly):
         self.exports[name] = assembly
         self.shared = True
     def build(self):
         externals = self.keys.keys()
         dynstr = Strings(self.libraries + externals + ['_DYNAMIC'])
         dynsym = SymbolTable(dynstr, externals)
         reltext = RelTab(dynsym, self.keys.items())
         symbol_names = set()
         symbol_names.update(self.globals)
         symbol_names.update(self.exports)
         symbol_names = list(symbol_names)
         dynstr = Strings(self.libraries + symbol_names + ['_DYNAMIC'])
         dynsym = SymbolTable(dynstr, symbol_names, self.exports)
         reltext = RelTab(dynsym, self.globals.items())
         needed = [[1, dynstr[library]] for library in self.libraries]
         hashtab = HashTable(dynsym)
         dynamic = DynTab(needed + [
@@ -184,7 +200,7 @@ class Dynamic(object):
             [19, reltext.entsize], # relent
         ])
         dynsym.dynamic = dynamic # hack used to complete the vicious ELF cycle.
-        librarytab = core.Assembly(self.keys.values())
+        librarytab = core.Assembly(self.globals.values())
         self.section = dynamic
         return core.Assembly([
             hashtab, dynamic, dynsym, reltext, librarytab, dynstr,
@@ -198,6 +214,9 @@ def executable(file, program, entry, dyn
     entry: program entry, object with an offset.
     dynamic: optional dynamic library extension.
     """
     physaddr = 0x800000
     exec_type = 2
     phdr_count = 1
     if dynamic:
         phdr_count = 3
@@ -205,14 +224,17 @@ def executable(file, program, entry, dyn
         program = [
             dynamic.build(),
             interp,
             core.Assembly(program)
+        ]
         ] + program
         if dynamic.shared == True:
             exec_type = 3
     physaddr = 0x800000
     headers = headersize + phdr_count*loadersize
     textsize = core.pass0(program, physaddr + headers)
     filesize = textsize + headers
-    file.write(buildheader(entry = entry.address, phdrnum = phdr_count))
+    file.write(buildheader(
         entry = entry.address, phdrnum = phdr_count,
         type = exec_type,
     ))
     if dynamic:
         file.write(buildloader(

Up to file-list usage_example.c:

 /*
 gcc usage_example.c -o usage_example ./libshared.so -m32
 LD_LIBRARY_PATH=. ./usage_example
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <dlfcn.h>
 extern int example_function();
 int main(){
     printf("hello %d\n", example_function());
+}

Up to file-list usage_example2.c:

 /*
 gcc usage_example2.c -o usage_example2 -m32 -ldl
 ./usage_example
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <dlfcn.h>
 int (*example_function)();
 int main(){
     void* handle = dlopen("./libshared.so", RTLD_LAZY);
     if (!handle)
+    {
         fprintf(stderr, "Cannot open libshared.so: %s\n", dlerror());
         exit(1);
+    }
     example_function = dlsym(handle, "example_function");
     printf("hello %d\n", example_function());
+}

commit 17:	4ce524aa90f3
parent 16:	9750486c98ad
branch:	default