GCC: Warnung vor "unused global variable" aktivieren?

Das wird allenfalls der Linker feststellen, nicht aber der Compiler. 
Siehe also bei dessen Flags.

Schreib "static" davor, das erhöht du Chance, daß die Warnung kommt.
(dann ist nämlich klar, daß die Variable nicht "extern" benutzt wird.

BTW, ein guter Linker link keine Objekte dazu, die keiner braucht.

Carl D. schrieb:
> BTW, ein guter Linker link keine Objekte dazu, die keiner braucht.

Dann ist er anders eine Fleischwarenfachverkäuferin. Die fragt:
"Darf's von der fetten, groben Variable noch ein Byte mehr sein?"

MfG Paul

Carl D. schrieb:
> BTW, ein guter Linker link keine Objekte dazu, die keiner braucht.

Wenn ein globales Objekt Teil einer aus anderen Gründen verwendeten 
Section ist, dann kann der Linker es nicht weglassen. Auf explizit 
initialisierte globale Variablen und auf Funktionen trifft das i.A. zu. 
Bei nicht initialisierten globalen Variablen kann es je nach Umgebung 
anders sein.

Dies gilt jedenfalls im klassischen Modell von Compiler/Assemblern, die 
Objectfiles bestehend aus je einer Code/Data/... Section erzeugen.

In GCC gibt es Optionen in Compiler und Linker, um alle Objekte in 
individuellen Sections unterzubringen und deshalb weglassen zu können. 
Alterativ geht das auch mit Übersetzung des gesamten Programms in einem 
Schritt.

Eine Möglichkeit ist des erwähnte --gc-sections etc. und ein Map-File 
vom Linker erstellen zu lassen.  Darin siehst du dann, was entsorgt 
wurde.

A. K. schrieb:
> Bei nicht initialisierten globalen Variablen kann es je nach Umgebung
> anders sein.

Ich dachte die gibt es laut C-Standard nicht? Wenn mich nicht alles 
täuscht, sind globale Variablen per Default zu Null initialisiert.

Mark B. schrieb:
> Ich dachte die gibt es laut C-Standard nicht? Wenn mich nicht alles
> täuscht, sind globale Variablen per Default zu Null initialisiert.

Korrekt. Ich hatte mich oben direkt davor aber ausdrücklich auf explizit 
initialisierte globale Variablen bezogen. Der Folgesatz bezieht sich 
daher auf nicht explizit initialisierte Variablen.

Je nach Compiler werde die u.U. einzeln als sogenannte "commons" an den 
Linker durchgereicht (Fortran lässt grüssen). Dann sind sie im 
Objectfile in keiner Section alloziert, sondern tauchen nur in der 
Symboltable auf. Erst der Linker sammelt die ein und platziert sie. Er 
könnte sie daher auch problemlos weglassen, wenn er unabhängig davon die 
Referenzierung erfasst.

Charakteristisch für solche Umgebungen ist, dass man sowas wie "int 
global_variable;" in mehreren Übersetzungseinheiten verwenden kann, ohne 
im Linker auf einen Fehler zu laufen. Obwohl eigentlich die Regel gilt, 
dass dies nur in einer einzigen Übersetzungseinheit zulässig ist.

Adib schrieb:
> Wenn du jetzt ohne Compilerfehler die Variable im .h File weglassen
> kannst, dann wird die Variable nur in dem Modul geraucht, wo sie auch
> definiert ist.

Und wenn man in diesem Szenario andererseits die Definition weglässt und 
der Linker still bleibt, dann wird sie nirgends verwendet.

Zuverlässig ist das doch alles nicht. Es kann ja auch sein, dass die 
Variable nur geschrieben, aber nie gelesen wird, z.B. wenn sie in 
irgendeiner Init-Funktion einmalig einen Wert bekommt, aber danach nie 
mehr verwendet wird. Dann kann sie auch weg.

A. K. schrieb:
> Ich hatte mich oben direkt davor aber ausdrücklich auf explizit
> initialisierte globale Variablen bezogen. Der Folgesatz bezieht sich
> daher auf nicht explizit initialisierte Variablen.

Soweit ich weiß unterscheiden gcc und ld aber nicht zwischen implizit 
und explizit mit 0 initialisierten Variablen. Nur Initialisierungswerte, 
die von 0 verschieden sind, werden anders behandelt.

> Je nach Compiler werde die u.U. einzeln als sogenannte "commons" an den
> Linker durchgereicht (Fortran lässt grüssen). Dann sind sie im
> Objectfile in keiner Section alloziert, sondern tauchen nur in der
> Symboltable auf.

Ich kenne das so, dass sie in die Section .bss kommen und dann vom 
Startup-Code im memset-Stil alle am Stück mit 0 initialisiert werden.

Fritzchen schrieb:
> Hmmmmm... das heißt, gcc kann das gar nicht???

Der gcc kann es gar nicht können.

A. K. schrieb:
> Charakteristisch für solche Umgebungen ist, dass man sowas wie "int
> global_variable;" in mehreren Übersetzungseinheiten verwenden kann,
> ohne im Linker auf einen Fehler zu laufen.

Es gibt sogar keinen Fehler, wenn in einem Modul "int global_variable;" 
steht und in einem anderen "float global_variable;".

Einen Fehler gibt es in dem Fall erst dann, wenn modulübergreifend 
optimiert wird (z.B. LTO per -flto) oder per -fno-common auf COMMON 
verzichtet wird.

Der einfachste Tip wurde ja schon genant: Die Definitionen der 
fraglichen Variablen auskommentieren, und schauen, welche dann vom 
Linker vermisst werden. Bei Funktionen geht es prinzipiell genauso.

Hilfreich Hinweise gibt dir da auch Doxygen. Das kann dir Caller und 
Calles auflisten.

Oder nutz einen vernünftigen Editor/IDE, wie z.B. QtCreator. Der findet 
alle Stellen, an denen eine Variable oder eine Funktion verwendet wird, 
mit einem Mausklick.

Oliver

Rolf M. schrieb:
> Soweit ich weiß unterscheiden gcc und ld aber nicht zwischen implizit
> und explizit mit 0 initialisierten Variablen. Nur Initialisierungswerte,
> die von 0 verschieden sind, werden anders behandelt.

Vielleicht wird irgendein Compiler oder eine Version eine explizite 
Initialisierung mit 0 zu einer impliziten Initialisierung machen. GCC 
4.7 und GCC 4.8 tun dies aber offenbar nicht automatisch.

> Ich kenne das so, dass sie in die Section .bss kommen

Aber erst im Linker. Der Compiler (einer solchen Umgebung) erzeugt nur 
einen "common" Eintrag in der Symboltabelle, mit der zu allozierenden 
Grösse. Wenn dieser Name anderswo als echte Definition auftaucht (unten 
"D"), dann wird der "C" Eintrag effektiv ignoriert.

1

extern int      extern_int;

2

int             implicit_int;

3

int             explicit_int = 0;

1

file.s:

2

        .comm   implicit_int,4,4

3

        .globl  explicit_int

4

        .data

5

        .align 4

6

explicit_int:

7

        .zero   4

1

file.o:

2

0000000000000000 D explicit_int

3

                 U extern_int

4

0000000000000004 C implicit_int

A. K. schrieb:
>> Soweit ich weiß unterscheiden gcc und ld aber nicht zwischen implizit
>> und explizit mit 0 initialisierten Variablen. Nur Initialisierungswerte,
>> die von 0 verschieden sind, werden anders behandelt.
>
> Vielleicht wird irgendein Compiler oder eine Version eine explizite
> Initialisierung mit 0 zu einer impliziten Initialisierung machen. GCC
> 4.7 und GCC 4.8 tun dies aber offenbar nicht automatisch.

Korrektur: Beides ist ein wenig richtig und ein wenig falsch. :-)

Explizite Initialisierungen mit 0 werden erkannt, werden aber nicht wie 
bei impliziten Initialisierungen zu Commons, sondern landen explizit in 
.bss statt .data (obiger .s Code ist nicht korrekt). Damit entfällt der 
Platz im Image, aber es sind echte harte Definitionen, keine schwachen 
Definitionen wie implizit initialisierte Variablen.

1

        .bss

2

explicit_int:

3

        .zero   4

1

        .data

2

explicit_int:

3

        .long   1

Während man also in einer solchen Umgebung
file1.c:  int var;     //C
file2.c:  int var;     //C
schreiben kann, geht zwar auch
file1.c:  int var;     //C
file2.c:  int var = 0; //D
aber nicht
file1.c:  int var = 0; //D
file2.c:  int var = 0; //D

In Eclipse kann man sich (wenn der Cursor auf einem Bezeichner steht) 
mit Ctrl+Alt+H die Aufrufer- und Aufrufgraphen jeweils in 
Baumdarstellung zeigen lassen.

Und obwohl der Menüpunkt "Call Hierarchy" eigentlich zunächst vermuten 
lässt es ginge nur für Funktionen funktioniert der Aufrufergraph 
ebensogut mit einer globalen Variablen als Wurzel. Dann siehst Du in 
welchen Funktionen die fragliche Variable verwendet wird.

Sehr praktische Sache das.

Und um mich meinem Vorredner anzuschließen: Doxygen (mit allen Optionen 
aktiviert, vor allem die Graphen) drüberlaufen lassen gibt auch eine 
stellenweise sehr hilfreiche Sicht auf die Struktur des Gesamtgebildes.

Bernd K. schrieb:
> In Eclipse kann man sich (wenn der Cursor auf einem Bezeichner steht)
> mit Ctrl+Alt+H die Aufrufer- und Aufrufgraphen jeweils in
> Baumdarstellung zeigen lassen.

Danke für den Tipp!