Export a global symbol from a Delphi DLL

Question

I'm trying to create a Gecko 2.0-compatible DLL in Delphi.

Previously (pre-Gecko 2.0) the DLL needed to export a NSGetModule() function. This worked flawlessly.

Starting with Firefox 4, my DLL is getting loaded (I have verified this though a breakpoint in my initialization section), but my NSGetModule() function does not get called anymore. This is the designed behavior because starting with Gecko 2.0 (Firefox 4), a binary component is not supposed to export a NSGetModule() function:

https://developer.mozilla.org/en/XPCOM/XPCOM_changes_in_Gecko_2.0#Binary_components

According to these docs, my DLL needs to export a NSModule data symbol which points to a struct. In Delphi terminology, I assume this is a global variable which points to a Delphi record.

In C++, this is how you export the (global) data symbol:

define NSMODULE_DEFN(_name) extern "C" NS_EXPORT mozilla::Module const *const NSModule

My question: how do I accomplish this in Delphi? How do I export a global variable?

I appreciate your feedback.

Answer 1

Delphi exports global variables from DLLs in a similar way to how it exports functions:

library exp;
var
  global: Integer;
exports global;
end.

Delphi can import global variables from DLLs, but it's a bit of a hack: declare a DLL import procedure of the same name as the global to import, then get the address of the procedure and adjust it appropriately. DLL imported procedures, from Delphi's perspective, are stubs that do an indirect jump through the DLL import table. Exported variables are linked by the OS loader by putting the address of the exported global in the import table, almost exactly like how addresses of exported procedures are similarly patched in.

For example:

{$apptype console}

procedure global; external 'exp.dll';

function GetGlobalAddr: PInteger;
type
  PPPointer = ^PPointer;
var
  p: PByte;
begin
  p := @global;
  Assert(p^ = $FF); // $FF $25 => indirect jump m32
  Inc(p);
  Assert(p^ = $25);
  Inc(p);
  Result := PPPointer(p)^^
end;

begin
  Writeln(GetGlobalAddr^);
end.

Of course, the latter details are implementation and platform dependent etc. Probably a safer approach is to use LoadLibrary with GetProcAddress, which will return the address of the global variable when passed its name. Of course, that's also platform dependent.

64-bit update:

In 64-bit on Windows, the code is slightly different. The opcodes are the same, but the addressing mode for the same instruction sequence is different; instead of a 32-bit absolute offset, it's a 32-bit relative offset.

function GetGlobalAddr: PInteger;
type
  PPPointer = ^PPointer;
var
  p: PByte;
  ofs: Integer;
begin
  p := @global;
  Assert(p^ = $FF); // $FF $25 => indirect jump m32
  Inc(p);
  Assert(p^ = $25);
  Inc(p);
  // 32-bit offset follows
  ofs := PInteger(p)^;
  // offset is relative to next instruction
  Inc(p, SizeOf(ofs) + ofs);
  Result := PPPointer(p)^^
end;