[ASM] Procedure mit mehr Parametern aufrufen als definiert

[NicTheQuick]

Hallo ASM-Freaks,

ich möchte etwas ungewöhnliches machen. Und zwar möchte ich eine Procedure mit x Parametern definieren, sie aber mit (x + 1) Parametern aufrufen und innerhalb der Procedure an den Parameter kommen, der extra übergeben wurde. Und zwar wird der vorne angehängt und ist immer ein Pointer.
Im Beispiel sieht man wahrscheinlich am besten, was ich meine. Ich habe selbst auch schon herum experimentiert, aber eigentlich habe ich nicht wirklich so den Plan, was ich da genau mache. Im Grunde sollen beide Aufrufe das selbe ausgeben.

Code: Alles auswählen

Procedure.i Normal(*a, b.i, c.i)
	Debug *a
	Debug b
	Debug c
EndProcedure

Normal(1, 2, 3)


p
Procedure.i ExtraParameter(b.i, c.i)
	EnableASM
		ADD rsp, 8
	DisableASM
	Protected *a = b
	
	Debug *a
	Debug b
	Debug c
	
	EnableASM
		SUB rsp, 8
	DisableASM
EndProcedure

Prototype.i extrab(*a, b.i, c.i)

extra.extra = @ExtraParameter()
extra(1, 2, 3)

Hat jemand eine Idee wie ich das so hin bekomme, dass ich nur am Anfang und am Ende der Procedure bzw. vor ProcedureReturn etwas ändern muss?

[STARGÅTE]

Also so wie ich das sehe, ist es unter x86 und x64 schon mal komplett anders.

Da ich bei x86 n bisschen besser dahinter steige hier mal n Möglichkeit:

Code: Alles auswählen

Global a.i, Stack.i

Procedure.i ExtraParameter(b.i, c.i)
	
	! POP dword [v_Stack] ; Stack sichern, und parameter verschieben
	! MOV eax, [esp]
	! MOV [v_a], eax
	
	Debug a
	Debug b
	Debug c
	
	! PUSH dword [v_Stack] ; Stack wiederherstellen
	
	ProcedureReturn
	 
EndProcedure

Prototype.i extrab(a.i, b.i, c.i)

extra.extrab = @ExtraParameter()
extra(1, 2, 3)

extra(4, 5, 6)

Problem bei der Sache ist, du kannst keine Protected-Variablen nutzen, da diese den Stack weiter verschieben, sodass du da alles anpassen müsstest!

PS: So oder so ist das allerdings keine Gute idee, sowas zu machen.

[ts-soft]

ESP ist der Stackpointer und reserviert. Ich hab zwar keine Ahnung von ASM,
aber das könnte bös ins Auge gehen.

[NicTheQuick]

Mir geht's darum eine Procedure eigentlich ganz normal zu deklarieren, sie aber später innerhalb eines Interfaces nutzen zu können. Es geht nur um Nutzerfreundlichkeit, sodass man sich nicht um den *this-Pointer als ersten Parameter kümmern muss.

[Helle]

Da in Windows 64-Bit die ersten 4 Prozedur-Parameter nicht über den Stack sondern per Register übermittelt werden kann man folgende Klimmzüge machen:

Code: Alles auswählen

Global.i a, b, c

Procedure.i ExtraParameter(x.i, y.i)   ;hier unbedingt neutrale Bezeichner

  !mov [v_a],rcx   ;Zeiger hin, Zeiger her
  !mov [v_b],rdx
  !mov [v_c],r8
;usw.
  *a = a           ;wenns denn unbedingt sein muss...
 
  MessageRequester("Win 64, Debugger aus!", Str(*a) + #LFCR$ + Str(b) + #LFCR$ + Str(c))  
 
EndProcedure

Prototype extrab(*a, b.i, c.i)

extra.extrab = @ExtraParameter()
extra(1, 2, 3)

Der PB-Debugger darf da aber nicht dazwischenfunken!
Für Linux sind es wieder andere Register.

[edel]

Unter Windows hatte es damals so funktioniert, ich meine aber das es da Probleme gab wenn man Strings benutzt hat.

Code: Alles auswählen

Prototype Func(a, b)

Structure Test
  Add.Func
  var.i
EndStructure

Procedure Add(a, b)
  Protected *this.Test
  !MOV dword [p.p_this],EBP    

  *this\var = a + b
  
EndProcedure

m.Test\Add = @Add()

m\Add(3,3)

Debug m\var

[mk-soft]

Beim erstellen der Methoden und Property muss man noch den Parameter *this.strutur angeben um auf das eigene Objekt zugreifen zu können.

Bein Aufruf über das Interface wird dann nicht mehr der ersten Parameter angeben.

Wie damals bei C als es noch nicht ++ gab...

Ist doch ok so.

[NicTheQuick]

Okay, Danke an alle.

Ich denke das ganze ist mir zu unsicher nur um die Benutzerfreundlichkeit zu erhöhen. Dank Helle weiß ich jetzt auch wie das mit den Registern unter 64 Bit ist. Hab mich nämlich schon gewundert als ich den ASM-Output von meinen Tests gecheckt hab.

Was ASM angeht, bin ich ja eher Laie. Gibt es da nicht ein paar gute Kochbücher für aktuelle Systeme? x86 bringt mir aktuell nicht viel, außer wenn ich meine VM auspacke. Sonst hab ich nirgendwo 32-Bit-Maschinen. Brauch doch keiner mehr, sowas.