- 12V Akku mit 280 Ah bauen         
Seite 2 von 2 ErsteErste 12
Ergebnis 11 bis 17 von 17

Thema: ASM clobber register?

  1. #11
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.802
    Anzeige

    Powerstation Test
    RTL umwandeln in Pseudo-Code?

    RTL ist doch bereits Pseudo-Code... Du kannst auch nicht hingehen, und ein Programm in RTL schreiben und GCC das weiterbearbeiten lassen.

    Welche Aussagen/Tests sollen denn ausgeführt werden? Geht's dabei um die Verifikation des von GCC emittierten RTL gegen die (preprozesste) C/C++/Java/Fortran/Ada-Quelle? Jedenfalls solltest du bedenken, daß nicht die gesamte Information eines Programmes (bzw. eines Moduls) in RTL vorliegt, auch nicht das gesamte "Wissen", daß GCC intern über die Quelle hat.

    Ob ein RTL sinnvoll/gültig ist, ist stark maschinenabhängig und hängt auch davon ab, ob du nonstrict-RTL betrachtest (darauf scheinst du dich ja beschränken zu wollen) oder strict-RTL.

    Für eine Einteilung und einen Überblick schau mal ins ./gcc/rtl.def
    Disclaimer: none. Sue me.

  2. #12
    Neuer Benutzer Öfters hier
    Registriert seit
    04.09.2007
    Beiträge
    13
    Also wie ich eben gelesen habe, bezieht sich RTL auf eine abstrakte Maschine!


    Kennst du links oder dokumente wo man nachlesen kann wie diese funktionieren soll!

    Ich habe eben ein weinig Probleme die Funktionsweise zu verstehen.


    zum Beispiel

    (insn 8 6 9 1 (set (reg:SI 61)
    (mem/c/i:SI (plus:SI (reg/f:SI 53 virtual-incoming-args)
    (const_int 4 [0x4])) [0 b+0 S4 A32])) -1 (nil) (nil))
    wird ja der Wert der Variable b (die als zweites Arg. dieser Funktion) in das Reg61 geladen!


    Code:
    (insn 9 8 10 1 (parallel [
                (set (reg:SI 60)
                    (plus:SI (mem/c/i:SI (reg/f:SI 53 virtual-incoming-args) [0 a+0 S4 A32])
                        (reg:SI 61)))
                (clobber (reg:CC 17 flags))
            ]) -1 (nil)
        (nil))
    in diesem schritt wird dann der Wert der Variable a zum wert der Variable b addiert und dann in Reg60 gespeichert


    nun meine Frage:
    ist also die Funktionsweise dieser "RTL" Maschine gleich dem Funktionsprinzip der Maschine die dem Assemblercode zugrunde liegt. Also was ich wissen möchte ist, ob sie nur auf einem virtuellem stack arbeitet, so wie man im Assembler mit push and pop arbeitet, oder ex da unterschiede??


    Gruss Matze

  3. #13
    Neuer Benutzer Öfters hier
    Registriert seit
    04.09.2007
    Beiträge
    13
    kann man den annehmen das

    Code:
    push %ebp
    und

    Code:
    (insn 10 9 12 1 (set (mem/c/i:SI (plus:SI (reg/f:SI 54 virtual-stack-vars)
                    (const_int -4 [0xfffffffc])) [0 sum+0 S4 A32])
            (reg:SI 60)) -1 (nil)     
            (nil)))
    die selbe Funtionsweise in bezug zu einem Stack zugrundeliegt?[/quote]

  4. #14
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.802
    Daß die Funktionsweise identisch ist, kann man dann annehmen, wenn man eine genaue Umschreibung dessen hat, was push bedeuten soll.

    Genau diesem Zweck dient RTL: Algebraische Umschreibungen der Maschine (bzw. ihres Instruktionssatzes) zu ermöglichen.

    Auf RTL sind dann Transormationen möglch, die zB gewisse Insns bzw. Insn-Sequenzen als äquivalent betrachten.

    Die Zuordnung einer asm-Instruktionssequenz zu einer Insn geschieht wie du weißt im md-File. Ob Transormationen erlaubt sind bzw. äquivalente RTXe ergeben, sieht man nicht unbedingt am md. Hier geht auch ganz viel über das h- und das c-File, zB was gültige Register-Operanden und Adressen sind, welche Pseudos auf welche Hard-Regs abgebildet werden dürfen, etc. Und ob zB ein CALL korrekt in asm umgesetzt wurde, lässt sich am RTL nicht erkennen, weil die argumente eines CALL nicht in RTL auftauchen.

    Mir ist jetzt nicht ganz klar, was du mit "virtuellem Stack" meinst.

    Der Maschine sind einige besondere "virtuelle" Hard-Register bekannt wie
    virtual-incoming-args, virtual-stack-vars, virtual-stack-dynamic, virtual-outgoing-args, virtual-cfa, ... die für besondere Zwecke verwendet werden und irgendwann auf Hard-Register abgebildet oder eliminiert werden.

    Wenn einer Funktion zB Argumente über den Stack übergeben werden, zeigt virtual-incoming-args auf das erste Argument; virtual-incoming-args wird aber für praktisch alle Maschinen auf den Frame-Pointer oder den Stack-Pointer abgebildet (und der Frame-Pointer dann auch auf den Stack-Pointer), wobei natürlich noch die richtigen Offsets drauf müssen.

    Das einzige Dokument, daß dies ansazuweise zum Thema hat, ist m.W das GCC internals. Ansonsten helfen nur die GCC-Quellen.
    Disclaimer: none. Sue me.

  5. #15
    Neuer Benutzer Öfters hier
    Registriert seit
    04.09.2007
    Beiträge
    13
    Wow Danke Du hast mir schon weiter geholfen!!!!!

    Gibt es denn irgendwo eine Aussage wie die Abbildung von den pseudoregistern in die entsprechenden Hardregister definiert ist??

    ich habe in den dump dateien gelesen

    Code:
    Registers live at start: 6 [bp] 7 [sp] 16 [argp] 20 [frame]
    Registers live at end: 0 [ax] 6 [bp] 7 [sp] 16 [argp] 20 [frame]
    das doch eine gewisse Zuordung nachvollziebar sein könnte, bin mir aber nicht sicher ob diese immer so ist

  6. #16
    Erfahrener Benutzer Robotik Einstein Avatar von SprinterSB
    Registriert seit
    09.06.2005
    Ort
    An der Saar
    Beiträge
    2.802
    Zitat Zitat von matzeed7
    Gibt es denn irgendwo eine Aussage wie die Abbildung von den pseudoregistern in die entsprechenden Hardregister definiert ist??
    So ganz verstehe ich deine Frage nicht.

    Für eine Maschine ist dies angegeben in den Comstraints zu dem jeweiligen Operanden, wobei in den Constraint noch mehr steht: Constraints beziehen sich ja auf Operanden allgemein, also nicht nur auf REG-Operanden, sondern auch auf Adressen, MEM, Konstanten, und Teilmengen/Vereinigungen davon, etc. AUsserdem stehen in den Constrains Dinge wie: early clobber, ob Operanden Kommutieren, Kosten von Constraints, ob eine Constraint Nebeneffekte hat, ...

    Für eine konkrete Insn wird die Abbildung notiert, sobald sie erfolgt ist; hier eine Insn von avr-gcc 3.4.6 nach .25.greg:
    Code:
    (insn 15 39 17 1 (set (reg:HI 24 r24 [orig:41 <result> ] [41])
            (plus:HI (reg/v:HI 24 r24 [orig:42 a ] [42])
                (reg/v:HI 22 r22 [orig:43 b ] [43]))) 25 {*addhi3} (nil)
        (nil))
    Pseudo 41 enthält den Return-Wert (<result>), der aber schon auf Hard-Reg 24 (durch REGISTER_NAMES[] benamt zu "r24") abgebildet wurde. Variable "a" in 42 lebt auch in 24 und b lebt in 43, jetzt in 22.

    Hier siehst du schon ein Problem: Sowohl <result> als auch a leben in r24. Das geht ok weil a nach der Insn nicht mehr gebraucht wird. Eine REG_DEAD Note für 24 gibt's an der Insn aber keine, weil 24 nach der Insn nicht tot ist (danach lebt <result> drin).

    In .24.lreg gabt's noch Dead-Notes für a in insn 15:
    Code:
    (insn 15 39 17 1 (set (reg:HI 41 [ <result> ])
            (plus:HI (reg/v:HI 42 [ a ])
                (reg/v:HI 43 [ b ]))) 25 {*addhi3} (nil)
        (expr_list:REG_DEAD (reg/v:HI 42 [ a ])
            (expr_list:REG_DEAD (reg/v:HI 43 [ b ])
                (nil))))
    Wo a wirklich lebt, sieht man aber erst in der Assembler-Ausgabe (-S -dP -fverbose-asm), denn nach .26.postreload kommen noch einige Passes.
    Code:
     ; (insn 15 39 47 (set (reg:HI 24 r24 [orig:41 <result> ] [41])
     ;         (plus:HI (reg/v:HI 24 r24 [orig:42 a ] [42])
     ;             (reg/v:HI 22 r22 [orig:43 b ] [43]))) 25 {*addhi3} (nil)
     ;     (expr_list:REG_DEAD (reg/v:HI 22 r22 [orig:43 b ] [43])
     ;         (nil)))
    	add r24,r22	 ;  <result>, b	 ;  15	*addhi3/1	[length = 2]
    	adc r25,r23	 ;  <result>, b
    Auch wenn dir das alles weiterhelfen mag, möchte ich nochmals erwähnen, daß es nicht sonderlich sinnvoll ist, Informationen aus den -da Dateien rauszuziehen, um sie auszuwerten! Diese Dateien dienen den gcc-Entwicklern u.a. zum Auffinden von Bugs und beim Implementieren neuer Features. Wenn man wirklich Informationen haben will, sollte man eher versuchen, GCC zu instrumentieren als seinen -da-Ausgaben hinterherzulaufen. Von daher ist wohl ein Wörtchen mit deinem Auftraggeber angebracht, der dich diese Studienarbeit schreiben lässt.

    Es bringt dir nähmlich mehr, etwas von den Interna vom GCC zu lernen/verstehen, als dich mit dem lisp-Parser rumzuärgern für ne Ausgabe, die du nicht klar spezifiziert bekommst. Un wenn du es hinbekommst, dann rekonstruierst du lediglich die Informationen, die GCC intern schon (sicherlich vollständiger) hat!

    Was den lisp-Parser angeht, so gibt's den schon in ./gcc/read-rtl.c, dem Gegenstück zu ./gcc/print-rtl.c. Der RTL-Reader dient aber AFAIK zum Lesen des md-Files.
    Disclaimer: none. Sue me.

  7. #17
    Neuer Benutzer Öfters hier
    Registriert seit
    04.09.2007
    Beiträge
    13
    ja danke erst mal!!!!

    gruss matze

Seite 2 von 2 ErsteErste 12

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

LiFePO4 Speicher Test