WebSVN – Kolibri OS – Diff – /programs/system/os/peloader.inc

         cmp     byte [esi], 'M'
         jz      .parse_mz
         cmp     [esi+STRIPPED_PE_HEADER.NumberOfRvaAndSizes], SPE_DIRECTORY_EXPORT
         jbe     @f
         mov     edx, [esi+sizeof.STRIPPED_PE_HEADER+SPE_DIRECTORY_EXPORT*sizeof.IMAGE_DATA_DIRECTORY+IMAGE_DATA_DIRECTORY.VirtualAddress]
+        mov     edx, [esi+edx+IMAGE_EXPORT_DIRECTORY.TimeDateStamp]
 @@:
         mov     [eax+MODULE.timestamp], edx
         mov     edx, esi
         sub     edx, [esi+STRIPPED_PE_HEADER.ImageBase]
         mov     [eax+MODULE.basedelta], edx
         jbe     .pagedone
         push    esi
         fpo_delta = fpo_delta + 4
 ; 2c. Check whether we have mprotect-ed the current page at the previous step.
 ; If so, go to 2e.
+        add     edx, esi
         cmp     [.next_page_addr+fpo_delta], edx
         jz      .mprotected_earlier
 ; 2d. We are going to modify data, so mprotect the current page to be writable.
 ; Save the old protection, we will restore it after the block is processed.
 ; Ignore any error.
 PROT_EXEC = 4
         push    ecx
         mov     eax, 68
         mov     ebx, 30
         mov     ecx, PROT_READ+PROT_WRITE
-        add     edx, esi
         mov     esi, 0x1000
         call    FS_SYSCALL_PTR
         pop     ecx
         jmp     .mprotected
 ; 2e. We have already mprotect-ed the current page,
         jmp     .relocloop
 .relocdone:
 ; 2i. Restore memory protection changed in 2d.
         pop     ecx
         fpo_delta = fpo_delta - 4
-        cmp     ecx, -1
-        jz      @f
         mov     eax, 68
         mov     ebx, 30
         mov     esi, 0x1000
         call    FS_SYSCALL_PTR
-@@:
         pop     esi
         fpo_delta = fpo_delta - 4
 .pagedone:
         cmp     [.sizeleft+fpo_delta], 0
         jnz     .pageloop
 locals
 export_base             dd      ?
 export_ptr              dd      ?
 export_size             dd      ?
 import_module           dd      ?
-import_dir              dd      ?
 import_descriptor       dd      ?
+next_forwarder          dd      ?
+bound_import_descriptor dd      ?
 bound_import_dir        dd      ?
-bound_import_cur_module dd      ?
+bound_modules_count     dd      ?
-relocated_bound_modules_count   dd      ?
+bound_modules_ptr       dd      ?
+bound_module            dd      ?
-relocated_bound_modules_ptr     dd      ?
+bound_modules_left      dd      ?
 cur_page                dd      -0x1000 ; the page at 0xFFFFF000 is never allocated
 cur_page_old_access     dd      ?
 next_page               dd      -1
 next_page_old_access    dd      ?
 endl
 ; it is impossible to bind such a binary, but it is still valid.
 ; If OriginalFirstThunk is absent, use FirstThunk as source array.
         mov     ebx, [ebp+IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk]
         mov     ebp, [ebp+IMAGE_IMPORT_DESCRIPTOR.FirstThunk]
         test    ebx, ebx
-        jnz     .label1
+        jnz     @f
         mov     ebx, ebp
-.label1:
+@@:
 ; FirstThunk and OriginalFirstThunk are RVAs.
         add     ebx, [esi+MODULE.base]
         add     ebp, [esi+MODULE.base]
 ; Source array is terminated with zero dword.
 .loop:
 ;   and forwarded exports.
 ; * New-style bound import:
 ;   we have two parallel arrays of import descriptors and bound descriptors,
 ;   pointed to by two directories. Timestamp field has a special value -1
 ;   in import descriptors, real timestamps are in bound descriptors.
-;   There can be different strategies; we loop over bound descriptors
-;   and scan for corresponding import descriptors only if needed,
-;   this accelerates the fast path where all timestamps are correct and
-;   dependencies are not relocated.
 ; * No import: not really different from normal import with no descriptors.
+; Forwarded exports are the part where binding goes really interesting.
+; The address of forwarded export can change with any library in the chain.
+; In old-style bound import, a descriptor can list only the library itself,
+; so it is impossible to bind forwarded exports at all; thunks that point to
+; forwarded exports are linked in the list starting from ForwarderChain in import descriptor.
+; New-style bound import exists exactly to address this problem; it allows to
-; There are two large parts in this function:
+; list several related libraries for one imported module.
-; step 2 handles unbound and old-style bound import, where we loop over import descriptors;
+; However, even with new-style bound import, some forwarded exports can
+; still remain unbound: binding tool can fail to load dependent libraries
+; during binding time; the tool from MS SDK for unknown reason just refuses to
+; bind forwarded exports except for built-in white list if subsystem version is
-; step 3 handles new-style bound import, where we loop over bound descriptors.
+; < 6.0. So even with new-style bound import, ForwarderChain still can be non-empty.
+; Thus, we always need to look at old-style import descriptor.
 ; 1. Fetch addresses of two directories. We are not interested in their sizes.
 ; ebp = import RVA
 ; ebx = bound import RVA
         xor     ebx, ebx
         xor     ebp, ebp
         mov     ebp, [eax+IMAGE_NT_HEADERS.OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_IMPORT*sizeof.IMAGE_DATA_DIRECTORY]
         cmp     [eax+IMAGE_NT_HEADERS.OptionalHeader.NumberOfDirectories], IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT
         jbe     .common
         mov     ebx, [eax+IMAGE_NT_HEADERS.OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT*sizeof.IMAGE_DATA_DIRECTORY]
 .common:
-        mov     [import_dir], ebp
-; If bound import is present, go to 3.
-; If both directories are absent, no import - nothing to do.
+; If import directory is not present, no import - nothing to do.
-; Otherwise, advance to 2.
+; Ignore bound import directory in this case.
-        test    ebx, ebx
-        jnz     .bound_import
         test    ebp, ebp
         jz      .done
-; 2. Unbound import or old-style bound import.
-; Repeat 2a-2h for all descriptors in the directory.
         add     ebp, [esi+MODULE.base] ; directories contain RVA
+        add     ebx, [esi+MODULE.base] ; directories contain RVA
+        mov     [bound_import_dir], ebx
+        mov     [bound_import_descriptor], ebx
+; Repeat remaining steps for all descriptors in the directory.
-.normal_import_loop:
+.descriptor_loop:
-; 2a. Check whether this descriptor is an end mark with zero fields.
+; 2. Check whether this descriptor is an end mark with zero fields.
 ; Look at Name field.
         mov     edi, [ebp+IMAGE_IMPORT_DESCRIPTOR.Name]
         test    edi, edi
         jz      .done
-; 2b. Load the target module.
+; 3. Load the target module.
         add     edi, [esi+MODULE.base] ; Name field is RVA
         call    load_imported_module ; should preserve esi,ebp
         test    eax, eax
         jz      .failed
         mov     [import_module], eax
-; 2c. Check whether the descriptor has a non-stale old-style binding.
+; 4. Check whether the descriptor has a non-stale old-style binding.
 ; Zero timestamp means "not bound".
+; Timestamp 0xFFFFFFFF means "new-style binding".
 ; Mismatched timestamp means "stale binding".
-; In both cases, go to 2g.
+; In first and third cases, go to 9.
+; In second case, go to 10 for further checks.
         mov     edx, [ebp+IMAGE_IMPORT_DESCRIPTOR.TimeDateStamp]
         test    edx, edx
-        jz      .resolve_normal_import
+        jz      .resolve_generic
+        cmp     edx, -1
+        jz      .new_binding
         cmp     edx, [eax+MODULE.timestamp]
-        jnz     .resolve_normal_import
+        jnz     .resolve_generic
-; 2d. The descriptor has a non-stale old-style binding.
+; 5. The descriptor has a non-stale old-style binding.
 ; There are two cases when we still need to do something:
 ; * if the target module has been relocated, we need to add
 ;   relocation delta to all addresses;
-; * if some exports are forwarded, old-style binding cannot bind them:
+; * if some exports are forwarded, we need to resolve them.
-;   there is only one timestamp field, we can't verify timestamps
-;   of forward targets.
 ;   Thunks for forwarded exports contain index of next forwarded export
 ;   instead of target address, making a single-linked list terminated by -1.
 ;   ForwarderChain is the head of the list.
-; If both problems are present, we resort to 2g as if binding is stale,
+; Check for the first problem first; the corresponding code can handle both.
-; it shouldn't be encountered normally anyway: relocations should be avoided,
-; and forwarded exports should be new-style bound.
-; If the target module is not relocated, go to 2f.
+; If the target module is relocated, go to 8.
-; If the target module is relocated and there are no forwarded exports,
+; If the target module is not relocated, but has forwarded exports, go to 7.
-; advance to 2e.
+; Otherwise, advance to 6.
+.old_binding:
         cmp     [eax+MODULE.basedelta], 0
-        jz      .normal_import_check_forwarders
+        jnz     .old_binding_relocate
+.check_forwarder_chain:
         cmp     [ebp+IMAGE_IMPORT_DESCRIPTOR.ForwarderChain], -1
-        jnz     .resolve_normal_import
+        jnz     .resolve_forward_chain
-; 2e. Binding is correct, but we need to add MODULE.basedelta
-; to all imported addresses in FirstThunk array.
-; For consistency with generic-case resolve_import_from_module,
-; check for end of thunks by looking at OriginalFirstThunk array.
-; After that, go to 2h.
+.next_descriptor:
-        mov     edx, [ebp+IMAGE_IMPORT_DESCRIPTOR.FirstThunk]
-        add     edx, [esi+MODULE.base]
+; 6. Advance to next descriptor and continue the loop.
-        mov     ebx, [ebp+IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk]
+        add     ebp, sizeof.IMAGE_IMPORT_DESCRIPTOR
-        add     ebx, [esi+MODULE.base]
-        mov     edi, [eax+MODULE.basedelta]
-.normal_import_add_delta:
-        cmp     dword [ebx], 0
-        jz      .normal_import_next
+        jmp     .descriptor_loop
-        call    .ensure_writable ; should preserve esi,edi,ebp,ebx,edx
-        add     dword [edx], edi
-        add     edx, 4
-        add     ebx, 4
-        jmp     .normal_import_add_delta
-.normal_import_check_forwarders:
+.resolve_forward_chain:
-; 2f. The target module is not relocated.
-; Exports that are not forwarded are correct.
+; 7. Resolve all thunks from ForwarderChain list.
-; Go through ForwarderChain list and resolve all exports from it.
-; After that, go to 2h.
-        mov     edi, [ebp+IMAGE_IMPORT_DESCRIPTOR.ForwarderChain]
-        cmp     edi, -1
-        jz      .normal_import_next ; don't prepare_import_from_module for empty list
         mov     eax, [import_module]
         mov     eax, [eax+MODULE.base]
         call    prepare_import_from_module
+        mov     edi, [ebp+IMAGE_IMPORT_DESCRIPTOR.ForwarderChain]
-.normal_import_forward_chain:
+.resolve_forward_chain_loop:
         mov     ebx, [ebp+IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk]
         add     ebx, [esi+MODULE.base]
         mov     ecx, [ebx+edi*4]
         get_address_for_thunk ; should preserve esi,edi,ebp
         test    eax, eax
         lea     edx, [edx+edi*4]
         call    .ensure_writable ; should preserve edx,ebx,esi,ebp
         mov     edi, [edx] ; next forwarded export
         mov     [edx], ebx ; store the address
         cmp     edi, -1
-        jnz     .normal_import_forward_chain
+        jnz     .resolve_forward_chain_loop
+; After resolving, we are done with this import descriptor, go to 6.
+        jmp     .next_descriptor
+.done:
+        call    .restore_protection
+        xor     eax, eax
+        ret
+.old_binding_relocate:
+; 8. The descriptor has a non-stale old-style binding,
+; but the target module is relocated, so we need to add MODULE.basedelta to
+; all addresses. Also, there can be forwarded exports.
+; For consistency with generic-case resolve_import_from_module,
+; check for end of thunks by looking at OriginalFirstThunk array.
+; Note: we assume here that ForwarderChain list is ordered.
+; After that, go to 6.
+        mov     edi, [eax+MODULE.basedelta]
+        cmp     [ebp+IMAGE_IMPORT_DESCRIPTOR.ForwarderChain], -1
+        jz      @f
+        mov     eax, [import_module]
+        mov     eax, [eax+MODULE.base]
+        call    prepare_import_from_module
+@@:
+        mov     edx, [ebp+IMAGE_IMPORT_DESCRIPTOR.FirstThunk]
+        add     edx, [esi+MODULE.base]
+        mov     ebx, [ebp+IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk]
+        add     ebx, [esi+MODULE.base]
+        mov     eax, [ebp+IMAGE_IMPORT_DESCRIPTOR.ForwarderChain]
+        lea     eax, [edx+eax*4]
+        mov     [next_forwarder], eax
+.old_binding_relocate_loop:
+        cmp     dword [ebx], 0
+        jz      .next_descriptor
+        call    .ensure_writable ; should preserve esi,edi,ebp,ebx,edx
+        cmp     edx, [next_forwarder]
+        jz      .old_binding_relocate_forwarder
+        add     dword [edx], edi
+.old_binding_relocate_next:
+        add     edx, 4
+        add     ebx, 4
+        jmp     .old_binding_relocate_loop
+.old_binding_relocate_forwarder:
+        mov     ecx, [ebx]
+        get_address_for_thunk
+        test    eax, eax
+        jz      .failed
+        mov     edx, [next_forwarder]
+        mov     ecx, [edx]
+        mov     [edx], eax
+        mov     eax, [ebp+IMAGE_IMPORT_DESCRIPTOR.FirstThunk]
+        add     eax, [esi+MODULE.base]
+        lea     eax, [eax+ecx*4]
+        mov     [next_forwarder], eax
-        jmp     .normal_import_next
+        jmp     .old_binding_relocate_next
-.resolve_normal_import:
+.resolve_generic:
-; 2g. Run generic-case resolver.
+; 9. Run generic-case resolver.
         mov     [import_descriptor], ebp
         resolve_import_from_module .failed ; should preserve esi
         mov     ebp, [import_descriptor]
-.normal_import_next:
+; After that, go to 6.
-; 2h. Advance to next descriptor and continue the loop.
-        add     ebp, sizeof.IMAGE_IMPORT_DESCRIPTOR
-        jmp     .normal_import_loop
+        jmp     .next_descriptor
-.bound_import:
+.new_binding:
-; 3. New-style bound import.
+; New-style bound import.
+; 10. Locate the new-style descriptor corresponding to the current
+; import descriptor.
+; 10a. Check the current new-style descriptor: the one that follows
+; previous one, if there was the previous one, or the first one.
-; Repeat 3a-3o for all descriptors in bound import directory.
+; In most cases, new-style descriptors are in the same order as
+; import descriptors, so full loop in 10b can be avoided.
-        mov     [bound_import_dir], ebx
+        mov     edx, [ebp+IMAGE_IMPORT_DESCRIPTOR.Name]
-        add     ebx, [esi+MODULE.base]
+        add     edx, [esi+MODULE.base]
-.bound_import_loop:
+        mov     ebx, [bound_import_descriptor]
-; 3a. Check whether this descriptor is an end mark with zero fields.
         movzx   edi, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.OffsetModuleName]
-        mov     [bound_import_cur_module], edi
         test    edi, edi
+        jz      .look_new_binding_hard
+        add     edi, [bound_import_dir]
+        xor     ecx, ecx
+@@:
+        mov     al, [edx+ecx]
+        cmp     al, [edi+ecx]
+        jnz     .look_new_binding_hard
+        test    al, al
+        jz      .new_binding_found
+        inc     ecx
-        jz      .done
+        jmp     @b
+.look_new_binding_hard:
+; 10b. We are out of luck with the current new-style descriptor,
+; so loop over all of them looking for the matching one.
+        mov     ebx, [bound_import_dir]
+.look_new_binding_loop:
+        movzx   edi, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.OffsetModuleName]
+        add     edi, [bound_import_dir]
+        xor     ecx, ecx
+@@:
+        mov     al, [edx+ecx]
+        cmp     al, [edi+ecx]
+        jnz     .look_new_binding_next
+        test    al, al
+        jz      .new_binding_found
+        inc     ecx
+        jmp     @b
+.look_new_binding_next:
+        movzx   ecx, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.NumberOfModuleForwarderRefs]
+        lea     ebx, [ebx+(ecx+1)*sizeof.IMAGE_BOUND_IMPORT_DESCRIPTOR]
+        jmp     .look_new_binding_loop
+.new_binding_found:
+; 10c. Store the next descriptor for subsequent scans.
+        movzx   ecx, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.NumberOfModuleForwarderRefs]
+        lea     eax, [ebx+(ecx+1)*sizeof.IMAGE_BOUND_IMPORT_DESCRIPTOR]
+        mov     [bound_import_descriptor], eax
 ; Bound import descriptors come in groups.
 ; The first descriptor in each group corresponds to the main imported module.
 ; If some exports from the module are forwarded, additional descriptors
 ; are created for modules where those exports are forwarded to.
 ; Number of additional descriptors is given by one field in the first descriptor.
-; 3b. Prepare for loop at 3c-3f with loading targets of all exports.
+; 11. We have already loaded the main module, validate its timestamp.
-; This includes the target module and all modules in chains of forwarded exports.
+; If timestamp does not match, go to 9 to run generic-case resolver.
+        mov     eax, [import_module]
+        mov     edx, [eax+MODULE.timestamp]
-        movzx   ebp, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.NumberOfModuleForwarderRefs]
+        cmp     edx, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.TimeDateStamp]
-        mov     [relocated_bound_modules_count], 0
+        jnz     .resolve_generic
+; 12. If there are no additional libraries,
+; the situation is exactly same as old-style binding, so go to 5.
+        test    ecx, ecx
+        jz      .old_binding
+; 13. Load additional libraries and validate their timestamps.
+; If at least one timestamp is invalid, resort to generic-case resolving.
+; 13a. Allocate memory for all bound modules, including the main module.
+        lea     ecx, [(ecx+1)*4]
+        stdcall malloc, ecx
+        test    eax, eax
+        jz      .failed
-        mov     [relocated_bound_modules_ptr], 0
+        mov     [bound_modules_ptr], eax
+; 13b. Store the main module.
-        mov     [import_module], 0
+        mov     edx, [import_module]
-.bound_import_forwarder_loop:
+        mov     [eax], edx
-; 3c. Load a referenced module.
+        xor     ecx, ecx
-; Names in bound import descriptors are relative to bound import directory,
+; 13c. Loop over all additional descriptors.
+.newstyle_load_loop:
-; not RVAs.
+        inc     ecx
+        mov     [bound_modules_count], ecx
+        movzx   edi, [ebx+ecx*sizeof.IMAGE_BOUND_IMPORT_DESCRIPTOR+IMAGE_BOUND_IMPORT_DESCRIPTOR.OffsetModuleName]
         add     edi, [bound_import_dir]
         call    load_imported_module ; should preserve ebx,esi,ebp
         test    eax, eax
-        jz      .bound_import_failed
+        jz      .newstyle_failed
-; The target module is first in the list.
+        mov     ecx, [bound_modules_count]
+        mov     edx, [ebx+ecx*sizeof.IMAGE_BOUND_IMPORT_DESCRIPTOR+IMAGE_BOUND_IMPORT_DESCRIPTOR.TimeDateStamp]
-        cmp     [import_module], 0
+        cmp     [eax+MODULE.timestamp], edx
-        jnz     @f
+        jnz     .newstyle_stale
-        mov     [import_module], eax
+        mov     edx, [bound_modules_ptr]
-@@:
-; 3d. Check whether timestamp in the descriptor matches module timestamp.
+        mov     [edx+ecx*4], eax
-; If not, go to 3h which after some preparations will resort to generic-case
+        cmp     cx, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.NumberOfModuleForwarderRefs]
-; resolve_import_from_module; in this case, we stop processing the group,
-; resolve_import_from_module will take care about additional modules anyway.
-        mov     edx, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.TimeDateStamp]
+        jb      .newstyle_load_loop
-        test    edx, edx
+        inc     ecx
-        jz      .bound_import_wrong_timestamp
+        mov     [bound_modules_count], ecx
-        cmp     edx, [eax+MODULE.timestamp]
+; New-style binding has correct timestamp.
-        jnz     .bound_import_wrong_timestamp
+; There still can be same two problems as in step 5 with old-style binding.
-; 3e. Collect all referenced modules that have been relocated.
+; 14. Check whether at least one module is relocated. If so, go to 16.
+.newstyle_check_reloc:
+        mov     eax, [edx]
         cmp     [eax+MODULE.basedelta], 0
-        jz      .bound_import_forwarder_next
-        mov     edi, eax
-; We don't want to reallocate too often, since reallocation
-; may involve copying our data to a new place.
-; We always reserve space that is a power of two; in this way,
-; the wasted space is never greater than the used space,
-; and total time of copying the data is O(number of modules).
-        mov     eax, [relocated_bound_modules_ptr]
-        mov     edx, [relocated_bound_modules_count]
-; X is a power of two or zero if and only if (X and (X - 1)) is zero
-        lea     ecx, [edx-1]
-        test    ecx, edx
-        jnz     .bound_import_norealloc
+        jnz     .newstyle_need_reloc
-; if the current size is zero, allocate 1 item,
-; otherwise double number of items.
-; Item size is 4 bytes.
-        lea     edx, [edx*8]
-        test    edx, edx
-        jnz     @f
-        mov     edx, 4
+        add     edx, 4
-@@:
-        stdcall realloc, [relocated_bound_modules_ptr], edx
-        test    eax, eax
-        jz      .bound_import_failed
-        mov     [relocated_bound_modules_ptr], eax
-.bound_import_norealloc:
-        mov     edx, [relocated_bound_modules_count]
-        inc     [relocated_bound_modules_count]
-        mov     [eax+edx*4], edi
-.bound_import_forwarder_next:
-; 3f. Advance to the next descriptor in the group.
-        add     ebx, sizeof.IMAGE_BOUND_IMPORT_DESCRIPTOR
-        movzx   edi, [ebx+IMAGE_BOUND_IMPORT_DESCRIPTOR.OffsetModuleName]
-        dec     ebp
+        dec     ecx
-        jns     .bound_import_forwarder_loop
+        jnz     .newstyle_check_reloc
-; 3g. All timestamps are correct.
+; 15. Bound modules are not relocated.
-; If all targets are not relocated, then we have nothing to do
+; The only remaining problem could be unbound forwarders.
-; with exports from the current module, so continue loop at 3a;
+; Free memory allocated at 13a and let steps 6 and 7 do their work.
-; ebx already points to the next descriptor.
-; Otherwise, go to 3i.
-        cmp     [relocated_bound_modules_count], 0
+        stdcall free, [bound_modules_ptr]
-        jz      .bound_import_loop
-        jmp     .bound_import_fix
+        jmp     .check_forwarder_chain
-.bound_import_wrong_timestamp:
-; 3h. We have aborted the loop over the group;
-; advance ebx so that it points to the first descriptor of the next group,
-; make a mark so that 3l will know that we need to reimport everything.
-; We don't need [relocated_bound_modules_count] in this case anymore,
-; use zero value as a mark.
-        lea     ebx, [ebx+(ebp+1)*sizeof.IMAGE_BOUND_IMPORT_DESCRIPTOR]
-        mov     [relocated_bound_modules_count], 0
-.bound_import_fix:
+.newstyle_stale:
-; 3i. We need to do something with exported addresses.
-; Find corresponding import descriptors; there can be more than one.
-; Repeat 3j-3n for all import descriptors.
-        mov     ebp, [import_dir]
-        add     ebp, [esi+MODULE.base]
-.look_related_descriptors:
-; 3j. Check whether we have reached end of import table.
-; If so, go to 3o.
-        mov     edx, [ebp+IMAGE_IMPORT_DESCRIPTOR.Name]
-        test    edx, edx
-        jz      .bound_import_next
-; 3k. Check whether the current import descriptor matches the current
-; bound import descriptor. Check Name fields.
-; If so, advance to 3l.
-; Otherwise, advance to the next import descriptor and return to 3j.
-        add     edx, [esi+MODULE.base]
-        mov     edi, [bound_import_cur_module]
+        stdcall free, [bound_modules_ptr]
-@@:
-        mov     al, [edx]
-        cmp     [edi], al
-        jnz     .next_related_descriptor
-        test    al, al
-        jz      .found_related_descriptor
-        inc     edx
-        inc     edi
-        jmp     @b
-.next_related_descriptor_restore:
-        mov     ebp, [import_descriptor]
-.next_related_descriptor:
-        add     ebp, sizeof.IMAGE_IMPORT_DESCRIPTOR
-        jmp     .look_related_descriptors
+        jmp     .resolve_generic
-.found_related_descriptor:
-; 3l. Check what we should do:
-; advance to 3m, if we need to reimport everything,
+; 16. The descriptor has a non-stale new-style binding,
-; go to 3n, if we just need to relocate something.
+; but at least one of target modules is relocated, so we need to add
-        mov     [import_descriptor], ebp
-        cmp     [relocated_bound_modules_count], 0
-        jnz     .bound_import_add_delta
-; 3m. Apply resolve_import_from_module and return to 3j.
+; MODULE.basedelta to addresses from relocated modules.
-        resolve_import_from_module .bound_import_failed ; should preserve ebx,esi
-        jmp     .next_related_descriptor_restore
-.bound_import_add_delta:
-; 3n. Loop over all imported symbols.
+; Also, there can be forwarded exports.
-; For every imported symbol, check whether it fits within one of relocated
-; modules, and if so, apply relocation to it.
 ; For consistency with generic-case resolve_import_from_module,
-; determine end of thunks from OriginalFirstThunk array.
+; check for end of thunks by looking at OriginalFirstThunk array.
+; Note: we assume here that ForwarderChain list is ordered.
+; After that, go to 6.
+.newstyle_need_reloc:
+        mov     eax, [import_module]
+        mov     eax, [eax+MODULE.base]
+        call    prepare_import_from_module
         mov     edx, [ebp+IMAGE_IMPORT_DESCRIPTOR.FirstThunk]
         add     edx, [esi+MODULE.base]
         mov     ebx, [ebp+IMAGE_IMPORT_DESCRIPTOR.OriginalFirstThunk]
         add     ebx, [esi+MODULE.base]
+        mov     eax, [ebp+IMAGE_IMPORT_DESCRIPTOR.ForwarderChain]
+        lea     eax, [edx+eax*4]
+        mov     [next_forwarder], eax
-.bound_import_add_delta_loop:
+.new_binding_relocate_loop:
         cmp     dword [ebx], 0
-        jz      .next_related_descriptor_restore
+        jz      .new_binding_relocate_done
+        cmp     edx, [next_forwarder]
+        jz      .new_binding_resolve_thunk
-        mov     ecx, [relocated_bound_modules_ptr]
+        mov     [bound_module], 0
-        mov     ebp, [relocated_bound_modules_count]
+        mov     eax, [bound_modules_count]
+        mov     [bound_modules_left], eax
-        push    esi
+        mov     edi, [bound_modules_ptr]
+; There should be at least one module containing address [edx].
+; There can be more than one if preferred address ranges for two modules intersect;
+; in this case, we are forced to resolve address from scratch.
-.find_delta_module:
+.new_binding_lookup_module:
-        mov     esi, [ecx]
+        mov     ecx, [edx]
-        mov     eax, [edx]
+        mov     eax, [edi]
-        sub     eax, [esi+MODULE.base]
+        sub     ecx, [eax+MODULE.base]
-        add     eax, [esi+MODULE.basedelta]
+        add     ecx, [eax+MODULE.basedelta]
-        cmp     eax, [esi+MODULE.size]
+        cmp     ecx, [eax+MODULE.size]
+        jae     @f
-        jb      .found_delta_module
+        cmp     [bound_module], 0
+        jnz     .new_binding_resolve_thunk
+        mov     [bound_module], eax
+@@:
-        add     ecx, 4
+        add     edi, 4
-        dec     ebp
+        dec     [bound_modules_left]
-        jnz     .find_delta_module
+        jnz     .new_binding_lookup_module
+        mov     edi, [bound_module]
+        mov     edi, [edi+MODULE.basedelta]
-        pop     esi
+        test    edi, edi
-.bound_import_add_delta_next:
+        jz      .new_binding_relocate_next
+        call    .ensure_writable ; should preserve esi,edi,ebp,ebx,edx
-        add     ebx, 4
+        add     dword [edx], edi
+.new_binding_relocate_next:
         add     edx, 4
+        add     ebx, 4
-        jmp     .bound_import_add_delta_loop
+        jmp     .new_binding_relocate_loop
-.found_delta_module:
+.new_binding_resolve_thunk:
-        mov     ebp, [esi+MODULE.basedelta]
+        mov     [bound_modules_left], edx
+        call    .ensure_writable
-        pop     esi
+        mov     ecx, [ebx]
-        call    .ensure_writable ; should preserve esi,ebp,ebx,edx
+        get_address_for_thunk
-        add     [edx], ebp
+        test    eax, eax
+        jz      .newstyle_failed
-        jmp     .bound_import_add_delta_next
+        mov     edx, [bound_modules_left]
-.bound_import_next:
+        mov     ecx, [edx]
-; 3o. Free the data we might have allocated and return to 3a.
+        mov     [edx], eax
-        cmp     [relocated_bound_modules_ptr], 0
+        cmp     edx, [next_forwarder]
-        jz      .bound_import_loop
+        jnz     .new_binding_relocate_next
-        stdcall free, [relocated_bound_modules_ptr]
+        mov     eax, [ebp+IMAGE_IMPORT_DESCRIPTOR.FirstThunk]
-        jmp     .bound_import_loop
+        add     eax, [esi+MODULE.base]
-.done:
-        call    .restore_protection
+        lea     eax, [eax+ecx*4]
-        xor     eax, eax
+        mov     [next_forwarder], eax
-        ret
+        jmp     .new_binding_relocate_next
-.bound_import_failed:
+.new_binding_relocate_done:
-        cmp     [relocated_bound_modules_ptr], 0
+        stdcall free, [bound_modules_ptr]
-        jz      .failed
+        jmp     .next_descriptor
+.newstyle_failed:
-        stdcall free, [relocated_bound_modules_ptr]
+        stdcall free, [bound_modules_ptr]
 .failed:
         call    .restore_protection
         xor     eax, eax
         dec     eax
         ret
         cmp     byte [eax], 'M'
         jz      .parse_mz
         cmp     [eax+STRIPPED_PE_HEADER.NumberOfRvaAndSizes], SPE_DIRECTORY_EXPORT
         jbe     .noexport
         mov     edx, [eax+sizeof.STRIPPED_PE_HEADER+SPE_DIRECTORY_EXPORT*sizeof.IMAGE_DATA_DIRECTORY+IMAGE_DATA_DIRECTORY.VirtualAddress]
+        test    edx, edx
+        jz      .noexport
         add     edx, eax
         mov     [export_ptr], edx
         mov     edx, [eax+sizeof.STRIPPED_PE_HEADER+SPE_DIRECTORY_EXPORT*sizeof.IMAGE_DATA_DIRECTORY+IMAGE_DATA_DIRECTORY.isize]
         mov     [export_size], edx
         ret
         mov     ecx, [eax+3Ch]
         add     ecx, eax
         cmp     [ecx+IMAGE_NT_HEADERS.OptionalHeader.NumberOfDirectories], IMAGE_DIRECTORY_ENTRY_EXPORT
         jbe     .noexport
         mov     edx, [ecx+IMAGE_NT_HEADERS.OptionalHeader.DataDirectory.VirtualAddress+IMAGE_DIRECTORY_ENTRY_EXPORT*sizeof.IMAGE_DATA_DIRECTORY]
+        test    edx, edx
+        jz      .noexport
         add     edx, eax
         mov     [export_ptr], edx
         mov     edx, [ecx+IMAGE_NT_HEADERS.OptionalHeader.DataDirectory.isize+IMAGE_DIRECTORY_ENTRY_EXPORT*sizeof.IMAGE_DATA_DIRECTORY]
         mov     [export_size], edx
         ret
         mov     edi, [ebx+edx*4]
         add     edi, [export_base]
         push    ecx esi
         repz cmpsb
         pop     esi ecx
-        jz      .found
+        jz      .hint_ok
 .ignore_hint:
 ; 4. Binary search over name table.
 ; Export names are sorted with respect to repz cmpsb.
 ; edi <= (the target index) < edx
         xor     edi, edi
         mov     edx, eax
         jmp     .export_name_search.loop
 ; Generic error handler.
 .export_name_not_found:
         mov     ebx, esi
-        mov     esi, [module]
-        test    esi, esi
-        jnz     @f
-        mutex_lock modules_mutex
-        mov     ecx, [export_base]
-        call    find_module_by_addr
+        call    .get_module_name
-        mutex_unlock modules_mutex
-@@:
-        mov     eax, msg_unknown
-        test    esi, esi
-        jz      @f
-        mov     eax, [esi+MODULE.filename]
-@@:
         ccall   loader_say_error, msg_export_name_not_found, ebx, msg_export_not_found, eax, 0
 .return0:
         xor     eax, eax
         ret
+.hint_ok:
+        mov     eax, edx
 .found:
 ; 5. We have found an index in AddressOfNames/AddressOfNameOrdinals arrays,
 ; convert it to index in AddressOfFunctions array.
         mov     edx, [export_ptr]
         mov     ebx, [edx+IMAGE_EXPORT_DIRECTORY.AddressOfNameOrdinals]
 .check_forwarded:
 ; This part of code is also used by get_exported_function_by_ordinal.
 ; 7. Check whether the address is inside the export directory.
 ; If not, we are done.
         add     eax, [export_base]
-        mov     esi, eax
+        mov     ebx, eax
-        sub     esi, edx
+        sub     ebx, edx
-        cmp     esi, [export_size]
+        cmp     ebx, [export_size]
         jb      .export_is_forwarded
         ret
 .export_is_forwarded:
 ; The export is forwarded to another module.
 ; The address we have got points to the string "."
         inc     eax
         cmp     byte [eax-1], '.'
         jz      .dot_found
         cmp     byte [eax-1], 0
         jnz     @b
-        jmp     .export_name_not_found
+        call    .get_module_name
+        ccall   loader_say_error, msg_invalid_forwarder, eax, 0
+        xor     eax, eax
+        ret
 .dot_found:
 ; 8b. Allocate the memory.
         sub     eax, ebx
         mov     edi, eax
         add     eax, 4 ; dll + terminating zero
         mutex_unlock modules_mutex
 @@:
         stdcall free, edi
         xor     eax, eax
         ret
+        fpo_delta = fpo_delta + 4
+.get_module_name:
+        mov     esi, [module]
+        test    esi, esi
+        jnz     @f
+        mutex_lock modules_mutex
+        mov     ecx, [export_base]
+        call    find_module_by_addr
+        mutex_unlock modules_mutex
+@@:
+        mov     eax, msg_unknown
+        test    esi, esi
+        jz      @f
+        mov     eax, [esi+MODULE.filename]
+@@:
+        retn
 endp
 ; Resolve symbol from a module by name.
 ; prepare_import_from_module should be called beforehand.

Subversion Repositories Kolibri OS

(root)/programs/system/os/peloader.inc – Rev 6767 → 6810