#lost · 2015-08-14

631 Nachrichten · Seite 3 von 4 · Original-CSV herunterladen

  1. JonathanAußerdem muss eine cdecl-Funktion ebx, esi, edi und ebp auch nicht unbedingt sichern
  2. darklink_ja gut
  3. JonathanWenn die Funktion diese Register nämlich gar nicht verändert, ist das Sichern zwecklos :P
  4. JonathanUnd wenn eine Funktion alle ihre locals in eax, ecx und edx unterbringen kann, und keine weiteren Funktionen aufruft, braucht sie gar keinen Prolog/Epilog *g*
  5. Jonathan(Gut, ich bin ja schon still)
  6. darklink_pastebin.com/YZs6bZrj nein. Gcc speichert die register nicht, die er später wieder benötigt
  7. JonathanÄääähm
  8. JonathanWenn du Inline-Assembler verwendest, ist das natürlich auch klar...
  9. darklink_(OK inline assembly ist auch fies. Der c compiler muss den code ja nur ausgeben
  10. JonathanJa.
  11. JonathanDer Compiler garantiert dir nicht, dass Register zwischen zwei Inline-Assembly-Blöcken gleich bleiben.
  12. JonathanDas ist undefiniertes Verhalten. Und genau das bekommst du dann halt auch.
  13. JonathanMach doch mal ne lokale Variable ^^
  14. Jonathanz.B. vor dem Call "volatile int i = 3;" und danach "i++;"
  15. JonathanIch wette mit dir, das wird in ebx/edi/esi gespeichert :P
  16. Jonathan(Sofern der Compiler es nicht weg optimiert.)
  17. darklink_Wird aufm stack gespeichert
  18. JonathanStimmt, da sie volatile ist, muss der Compiler das machen
  19. JonathanDann mach folgendes
  20. JonathanVorher "int i = funktionDieIntZurueckgibt();"
  21. darklink_ja
  22. JonathanHinterher "return i;"
  23. Jonathan(Musst die Funktion halt von void auf int ändern)
  24. JonathanDann sollte der Compiler die lokale Variable in nem Register speichern :D
  25. darklink_nö
  26. JonathanImmer noch aufm Stack?
  27. darklink_ja
  28. JonathanOptimierungen an?
  29. darklink_ne
  30. JonathanMach mal an *g*
  31. darklink_dann wird 0 zurückgegeben
  32. JonathanUnd der Call in die Funktion wegoptimiert? :D
  33. darklink_ja
  34. JonathanHmmm xD
  35. JonathanAlso, der Call in "funktionDieIntZurueckgibt"?
  36. darklink_funktion ist { int i; return i; }
  37. darklink_ja
  38. JonathanGut
  39. Jonathanvolatile int i = 3; return i;
  40. JonathanDas müsste gehen
  41. darklink_http://pastebin.com/EWhRvjCL *kotz* vieleicht
  42. JonathanOkay, der hat die Funktion ge-inline-t *g*
  43. darklink_Lol
  44. darklink_ja
  45. JonathanAber rate mal, wo er den Returnwert speichert: ebx *g*
  46. darklink_und ebx wird nicht gepusht
  47. JonathanExakt
  48. JonathanAlles schön brav, wie cdecl vorschreibt :P
  49. darklink_vieleicht sollte ich das mit zwei variablen machen
  50. JonathanMach das
  51. JonathanDann sollten die beiden in ebx und edi (oder esi) sein
  52. Jonathan:D
  53. darklink_bei 4en nutzt er den stack
  54. JonathanJa
  55. JonathanEntweder er pusht z.B. ecx, oder er lässt die Variable dann gleich aufm Stack
  56. JonathanJe nachdem, was effizienter ist ^^
  57. Jonathan"guck mal da explodiert ein trafo, sowas gibts bei euch embedded leuten nich"
  58. Jonathan*g* *g* *g*
  59. darklink_^^
  60. darklink_bei arm sind register r0-r3 für funktionen gesichert
  61. darklink_da kann ich mir sicher sein, dass gcc dort r4-r7 im THUMB-modus bzw. r4-r13 im ARM-modus genutzt wird :P
  62. Jonathan:P
  63. darklink_Äh lol
  64. darklink_Ja macht er wirklich
  65. darklink_gcc ist zu faul zu pushen
  66. darklink_Und ohne optimierung macht er irgend ein stackpointer-mist
  67. darklink_Dabei ist der code kleiner
  68. darklink_mov r0, r4 : mov r4, r0 : pop {r4, ip} ist 4 bytes größer als push {r0} : pop {r0, ip}
  69. masterq32okay, wieder da
  70. masterq32war ja ne ganz schöne WOT was ihr da produziert habt
  71. masterq32mal anfangen die fehler rauszuklauben
  72. darklink_WoT
  73. masterq32stimmt :D
  74. masterq32wie wars? das erste [esp+0x10] war richtig?
  75. darklink_Ich sag nein, jonathan sagt ja
  76. masterq32ich sag nein
  77. masterq32weil wenn ich 0x18 nehme
  78. darklink_Und da sind noch andere sachen kaputt
  79. masterq32und dann den parameter von 0 auf 1 beim aufruf ändere, ändert sich ein B auf A und wieder zurück
  80. masterq32so, schritt 1 tut :D
  81. darklink_Ich würd ebx pushen
  82. masterq32joar is jetzt "erst mal" nich so wichtig
  83. darklink_eax, ecx und edx werden von gcc nicht gepusht (da nicht verwendet)
  84. masterq32sobald der call durchkommt und geht hab ich mehr erfahrung :D
  85. masterq32hab jetzt auch alle registerinits mal vor das sub esp, ebx gesetzt
  86. masterq32okay
  87. masterq320x18 -> stacksize
  88. masterq320x14 -> stack
  89. masterq320x10 -> func
  90. masterq32argumente werden von hinten nach vorne auf den stack gelegt
  91. masterq32also ist das letzte element ganz oben
  92. Jonathanmasterq32: Ich sag auch nein :D
  93. masterq32haha :D
  94. JonathanAußerdem darfst du nach deinem "sub esp, whatever" *keine Argumente mehr vom Stack holen*
  95. masterq32ja
  96. JonathanAlles, was du nach "sub esp, whatever" mit dem Stack machst, ist *falsch*
  97. masterq32is mir jetzt auch klar :D
  98. Jonathank :P
  99. JonathanGut ^^
  100. masterq32eigentlich hab ich das wissen auch wie das alles geht
  101. masterq32nur ich hab es noch nie angewendet
  102. masterq32und dann macht man natürlich fehler
  103. JonathanJo
  104. darklink_Man kann übrigens register vom stack holen, wenn du die stackgröße in z.b. ebx hast
  105. JonathanMein Kernel muss den Stack von Programmen im Adressraum ummappen und dabei Pointer anpassen... Das ganze im Assembler, und ab und zu ist der Stack komplett ausgeblendet *g*
  106. JonathanDas hat auch tagelang nicht funktioniert :P
  107. darklink_kannst du mov ecx, [esp+ebx+disp] machen glaub ich
  108. JonathanJa, gut, das ginge
  109. masterq32okay? CISC :D
  110. JonathanAber wenn es sich vermeiden lässt, würde ich das nicht machen :D
  111. JonathanSondern einfach die Argumente vorher in Register laden und fertig
  112. JonathanIst am einfachsten
  113. darklink_ARM sieht teilweise wie vliw aus
  114. masterq32vliw?
  115. JonathanVery Large Instruction Word
  116. masterq32ah :D
  117. JonathanD.h. verdammt riesige Instruktionen mit mehreren Operationen pro Instruktion :D
  118. masterq32hehe
  119. darklink_add r0, r1, r2, lsl r3; ldmia r0!,{r4,r5,r6,r7}
  120. masterq32wat?
  121. masterq32eine instruction? :D
  122. JonathanJo
  123. Jonathan*g*
  124. masterq32was tut das?
  125. Jonathanldmia kenn ich nicht
  126. JonathanAber add und lsl sind klar
  127. JonathanDie CPU führt diese drei Operationen halt komplett parallel aus ^^
  128. darklink_Das erste macht r0=r1+(r2>>r3); und das zweite macht r4=*(r0--); r5=*(r0--); r6=*(r0--); r7=*(r0--);
  129. masterq32what the flying fuck? geil :D
  130. JonathanItanium kann das auch :P
  131. masterq32wo wir grade bei instruction sets sind
  132. JonathanAuweia *g*
  133. masterq32sekunde, ich will hier nicht ohne referenzen auftauchen :D
  134. masterq32http://www.digikey.com/Web%20Export/Supplier%20Content/Parallax_149/PDF/Parallax_PropellerManual.pdf?redirected=1
  135. masterq32seite 251
  136. masterq32parallax propeller
  137. darklink_Aber am besten finde ich natürlich funktionsaufrufe beim arm
  138. darklink_absolut unprofessionell
  139. masterq32der propeller hat keine compare instruction
  140. darklink_push {lr}; mov lr, pc; jmp ziel; pop {lr}
  141. darklink_und als return: bx lr
  142. masterq32äääähm
  143. masterq32hab meinen code grade mal ausgeführt
  144. masterq32gebe eine 1337 in die funktion, er kopiert erfolgreich und jetzt hab ich ne 8224 im parameter stehen
  145. masterq32wat? :D
  146. masterq32okay, ist ein nachvollziehbares ergebnis
  147. masterq32bzw. reproduzierbar
  148. masterq32nachvollziehbar noch nicht
  149. masterq32okay
  150. masterq32hatte nochmal nen stack modification error drin
  151. masterq32örm
  152. masterq32ich bekomm ne "invalid opcode" Exception bei
  153. masterq32double d;
  154. masterq32int i = (int)double;
  155. masterq32:D
  156. SHyx0rmZ-mno-sse -mno-sse2 -mno-mmx
  157. SHyx0rmZviellleicht
  158. masterq32AAAAH ICH IDIOT! :D
  159. masterq32copy paste auf tablet
  160. masterq32am pc
  161. masterq32paste
  162. masterq32äääärm
  163. masterq32why no work? :D
  164. masterq32ich danke kevin, darklink_ und Jonathan :)
  165. masterq32es tut :)
  166. Jonathanmasterq32: Gern geschehen ^^
  167. JonathanNächste Baustelle: Returnwerte ;)
  168. Jonathan(Aber die sind vergleichsweise harmlos)
  169. masterq32yep
  170. masterq32habs gesehen
  171. masterq3232 bit in eax
  172. masterq32bis zu 64 bit in eax und edx(?)
  173. JonathanJap
  174. masterq32und alles mit mehr in nem speicher den die funktion reserviert hat
  175. masterq32und nen pointer darauf zurückgeben
  176. JonathanNaja, mehr als 64 Bit Returnwert geht (normalerweise) gar nicht ;)
  177. masterq32joar
  178. JonathanWenn man das trotzdem will, schubst der Compiler der Funktion einen temporären Puffer als Argument rein
  179. JonathanIn den sie dann den Returnwert schreibt ^^
  180. masterq32da ich nach dem nur noch esp, edi, esi un ebx anfasse, sollte das schon gehen :D
  181. masterq32jo
  182. JonathanAber um so Verrücktheiten solltest du dich nicht kümmern :P
  183. JonathanDas macht alles nur unnötig kompliziert, und man kann auch darauf verzichten
  184. masterq32yep
  185. masterq32seh ich auch so
  186. JonathanNa dann ^^
  187. JonathanBtw
  188. JonathanBei den Returnwerten kannst du jetzt auch *sinnvoll* ein Union einsetzen
  189. Jonathanz:B. so:
  190. JonathanHmmmm
  191. JonathanVielleicht doch nicht *g*
  192. masterq32:D
  193. masterq32okay, pagefault irgendwann im code :D
  194. JonathanDeine Assemblerfunktion kann ja die Returnwerte einfach in eax und edx lassen
  195. JonathanHmm *g*
  196. JonathanDann deklarierst du sie als uint64
  197. Jonathan...oder so *g*
  198. masterq32:D
  199. JonathanOder noch besser
  200. JonathanDu machst zwei Funktionen