Hallo,
ich nutze einen STM32F4 mit der EM:Blocks 2.20 IDE.
Dahinter steckt ein GCC 4.7.4..
Jetzt will ich die FPU benutzen.
Alle Defines zum anschalten sind gesetzt und die FPU wird eingeschaltet.
Alle Harken für "hard" sind gesetzt.
Aber so weit bin ich noch nicht.
Ich habe ein einfaches main Programm (ist nicht das wirkliche).
float F_Test, F_Test2;
void main (void)
{
float F_Test3;
F_Test = 1.123f;
F_Test3 = 3.456f * F_Test;
F_Test2 = F_Test / F_Test3;
}
Jetzt lase ich den Compiler laufen, im Code erwarte ich nun diese
V...Befehle. Ich habe aber smul und so weiter drin.
Lib Aufrufe sind nicht drin, nur wenn ich auf "soft..." stelle sind die
drin.
Also denke ich das der Compiler die Flags geliefert bekommt.
Ich kann leider nicht sehen wie der GCC aufgerufen wird, wird irgendwie
unterdrückt. Im der main.s steht .fpu=xxxxx-d16 drin.
Hat jemand eine Idee was ich falsch mache?
Oder was ich testen kann um da weiter zu kommen.
Viele Grüsse Peter
Peter schrieb: > void main (void) > { > float F_Test3; > > F_Test = 1.123f; > F_Test3 = 3.456f * F_Test; > F_Test2 = F_Test / F_Test3; > } Der Compiler wird das Ergebnis vorher berechnen, sodass die CPU nichts mehr zu tun hat. Evtl. optimiert er das auch komplett weg.
:
Bearbeitet durch User
Das könnte sein. Optimierung ist aber übrigens aus, damit der GCC nicht auf die Idee kommt was weg zu lassen. Ich habe das ganze auch mal zwischen anderen Codezeilen dazwischen gepackt, mit dem selben Ergebnis. Hier im Forum gab es schon einige Anfragen zu der FPU, aber da wurde dann meistens die FPU nicht angeworfen. Und die Beispiele waren nicht großartig anders wie jetzt meins.
Dann nimm doch mal keine voerher definierten Zahlen zum Multiplizieren, sondern lies mal was am AD-Wandler ein und multipliziere dese Zahlen. Dann hat der Compiler keine Chance, das schon vorher zu berechnen.
ich denke der gcc schmeißt den Code raus. Das hat nicht mal was mit Optimierung zu tun. Da die Variablen nicht gebraucht werden sind sie überflüssig. Versuch die mal als volatile zu deklarieren. Oder mach ein printf oder sprintf damit.
Ich mache nachher mal weitere Tests. In den anderen Beispielen stand aber auch nichts von volatile. Kann aber wie bei mir nur ein Beispiel sein was nicht zu 100% richtig ist. Ich teste es und berichte später, wenn ich zu hause bin.
1 | |----------|--------------------------------------------| |
2 | |Cortex-M4 | -mthumb -mcpu=cortex-m4 -mfloat-abi=hard | |
3 | |(Hard FP) | -mfpu=fpv4-sp-d16 | |
4 | | |--------------------------------------------| |
http://stackoverflow.com/questions/16768235/cortex-m4-gcc-float-behavior brauchst Du wohl.
Habe doch schon gesagt das alle Flags an sind. Nur richtig ansehen kann ich das nicht. Ich habe jetzt alles mal auf volatile und einlesen eines Port-Register geändert. Und es ändert sich nichts, fmuls wird aufgerufen aber nichts mit v.... Eigentlich blöd weil ich diese Befehle nicht im Befehlssatz finde. Ich habe noch einen Schalter gefunden um float Werte in FPU Register zu laden. Und da bekomme ich eine Warnung das das nicht unterstützt wird. Da stimmt irgend was überhaupt nicht. Ich lade mir garade die EM:Blocks 2.30 Version mal sehen ob die Jungs mist gebaut haben bei der 2.20 und einen Defekten GCC mit liefern. Hat denn niemand mit diese TOOL Kombination die FPU am laufen?
Peter schrieb:
>Hat denn niemand mit diese TOOL Kombination die FPU am laufen?
Ich verwende EmBitz 0.40 mit dem STM32F746 Discovery und da
funktionierts
(119) fa=fa*1.56789;
08001268 vldr s15, [r7, #28]
0800126C vcvt.f64.f32 d7, s15
08001270 vldr d6, [pc, #60] ; 0x80012b0 <main+216>
08001274 vmul.f64 d7, d7, d6
08001278 vcvt.f32.f64 s15, d7
0800127C vstr s15, [r7, #28]
Die Optionen sind:
-DUSE_HAL_DRIVER -DSTM32F746xx -D__FPU_PRESENT=1 -D__FPU_USED=1
-DUSE_STM32746G_DISCO -DARM_MATH_CM7
und
-mthumb -mcpu=cortex-m7 -mfpu=fpv5-d16 -mfloat-abi=hard
Nun der Cortex M7 ist ja was ganz anderes, aber schön zu wissen das es da geht. Hatte noch keine Zeit um weiter zu testen! Ob ich jemals einen wechsel zu EmBitz mache muss ich mir noch gründlich überlegen. Nicht wegen Funktionen oder so, sondern weil die Entwickler ein Lizenzsystem eingebaut haben. Eigentlich alle Projekte die ich eingesetzt hatte und sowas eingeführt haben sind platt oder dümpeln jetzt nur noch so dahin. Ich habe die meistens auch recht bald deinstalliert. Ich warte auf die .50 und sehe die mir dann an wie die Einschränkungen aussehen. Als alternative bleibt zum Glück immer noch das Basis Projekt CODE:BLOCKS.
So ich habe es gerade getestet. EM:Blocks 2.30 und EMBlitz 0.40. Beide erzeugen nicht den erwarteten Code. Welchen Windows GCC für ARM sollte ich jetzt suchen? Oder hat jemand einen passenden Link griffbereit. VG, Peter
>Welchen Windows GCC für ARM sollte ich jetzt suchen? Den hier: https://launchpad.net/gcc-arm-embedded
EmBitz 0.40 mit dem Stm32F429 Discovery geht. (86) a=1.367f; 0800070A ldr r3, [pc, #40] ; (0x8000734 <main+56>) 0800070C str r3, [r7, #4] (87) b=a*3.345f; 0800070E vldr s15, [r7, #4] 08000712 vldr s14, [pc, #36] ; 0x8000738 <main+60> 08000716 vmul.f32 s15, s15, s14 0800071A vstr s15, [r7] (88) b=b*b; 0800071E vldr s14, [r7] 08000722 vldr s15, [r7] 08000726 vmul.f32 s15, s14, s15 0800072A vstr s15, [r7] allerdings müssen Konstanten als float gekennzeichnet sein sonst wird double angenommen und die SoftFPU verwendet. Die Compiler Optionen sind bei mir: -std=c99 -mthumb -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -Wall -fdata-sections -ffunction-sections und -DUSE_HAL_DRIVER -DSTM32F429xx -D__FPU_PRESENT=1 -D__FPU_USED=1 -DUSE_STM32F429I_DISCO -DARM_MATH_CM4 die Linkerflags sind: -mthumb -mcpu=cortex-m4 -mfpu=fpv4-sp-d16 -mfloat-abi=hard -specs=nosys.specs -specs=nano.specs -Wl,--gc-sections -Wl,--check-sections
Bei emblitz werden die meisten flags innerhalb der IDE eingetragen. Ich habe nur keine Ahnung wie ich alle prüfen kann. Ich schaue ins List file Main.s. Einige flags finde ich da wieder. Zum linken komme ich später.
Peter schrieb:
>Bei emblitz werden die meisten flags innerhalb der IDE eingetragen
nee makefile geht auch
Das hat beim STM32F746-DISCOVERY den Vorteil das man alles was im extern
angeschlossenen QSPI Speicher landen soll mit objcopy herausheddern
kann.
Der Trick ist dieser Eintrag im makefile:
ifeq ("$(MAKECMDGOALS)","Debug")
BIN_BASE := bin/Debug
CFLAGS += -g -gdwarf-2
ASFLAGS += -g
# optimization
OPT = -O0
else
BIN_BASE := bin/Release
# optimization
OPT = -O2
endif
im BIN_BASE stehen dann die Hexdateien
die eigentlichen Einsprungsmarken sind dann noch
Debug:
Release:
cleanDebug:
cleanRelease:
m.f.G.
Dieter
Hallo Peter, Ich hab das mal geprüft, ebenfalls STM32F4. Ich benutze GNU Tools ARM Embedded 4.9.2015q2 (also den aktuellsten) zusammen mit eclipse. Bei mir erzeugt dieses Programm
1 | int main (void) { |
2 | float pi = 3.141592653; |
3 | float Ergebnis; |
4 | Ergebnis = pi * 2.5; |
5 | while(1); |
6 | }
|
dieses Listing:
[asm]
main:
@ args = 0, pretend = 0, frame = 8
@ frame_needed = 1, uses_anonymous_args = 0
@ link register save eliminated.
push {r7}
sub sp, sp, #12
add r7, sp, #0
ldr r3, .L3
str r3, [r7, #4] @ float
flds s15, [r7, #4]
fconsts s14, #4
fmuls s15, s15, s14
fsts s15, [r7]
.L2:
b .L2
.L4:
.align 2
.L3:
.word 1078530011
.size main, .-main
.ident "GCC: (GNU Tools for ARM Embedded Processors) 4.9.3 20150529
(release) [ARM/embedded-4_9-branch revision 224288]"
[/asm]
Nach kurzem googlen habe ich dazu eine Information auf Stackoverflow
gefunden (quelle:
http://stackoverflow.com/questions/21120225/why-does-gcc-generates-fxxx-instead-of-vxxx-floating-point-assembly-instructions)
Die fxxx Instruktionen sind die selben wie die vxxx Instruktionen. Es
hat sich nur die mnemonics geändert. GNU scheint also einen alten
disassembler zu benutzen.
Siehe hierzu folgende Seite von ARM:
http://infocenter.arm.com/help/topic/com.arm.doc.dui0473c/CIHFAHFG.html
~Lil B
Das erklär endlich mal warum ich diese F... Befehle habe, obwohl es die eigentlich nicht gibt. Dann bin ich beruhigt und kann ohne bedenken meine float Routinen einbauen. Danke Euch, Peter
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.