powerpc64-linux-gnu-gcj - Online nel cloud

PROGRAMMA:

NOME

gcj - Compilatore anticipato per il linguaggio Java

SINOSSI

gcj [-Idir...] [-d dir...]
[--PERCORSO CLASSE=sentiero] [--percorso di classe=sentiero]
[-fopzione...] [- codifica=Nome]
[--principale=nomeclasse] [-DNome[=APPREZZIAMO]...]
[-C] [--risorsa nome-risorsa] [-d elenco]
[-Wavvertire...]
file sorgente...

DESCRIZIONE

As gcj è solo un altro front-end per gcc, supporta molte delle stesse opzioni di gcc.
Questo manuale documenta solo le opzioni specifiche per gcj.

VERSIONI

Ingresso e produzione file
A gcj il comando è come a gcc comando, in quanto consiste di una serie di opzioni e file
nomi. Sono supportati i seguenti tipi di nomi di file di input:

filetto.Giava
File di origine Java.

filetto.classe
File di codice byte Java.

filettofile .zip
filetto.jar
Un archivio contenente uno o più file ".class", tutti compilati. Il
l'archivio può essere compresso. File in un archivio che non finiscono con .classe sono
trattati come file di risorse; sono compilati nel file oggetto risultante come nucleo:
URL.

@filetto
Un file contenente un elenco separato da spazi di nomi di file di input. (Attualmente, questi
devono essere tutti file sorgente ".java", ma ciò potrebbe cambiare.) Ogni file denominato viene compilato,
proprio come se fosse stato sulla riga di comando.

biblioteca.a
biblioteca.così
-lnomelib
Librerie da utilizzare durante il collegamento. Vedi il gcc manuale.

È possibile specificare più di un file di input sul gcj riga di comando, nel qual caso lo faranno
essere tutto compilato. Se specifichi un "-o NOME DEL FILE" opzione, tutti i file di input saranno
compilati insieme, producendo un singolo file di output, denominato NOME DEL FILE. Questo è permesso anche
quando si usa "-S" o "-c", ma non quando si usa "-C" o "--resource". (Questa è un'estensione
al di là di ciò che è semplice gcc consente.) (Se viene specificato più di un file di input, tutti devono
attualmente sono file ".java", anche se speriamo di risolvere questo problema.)

Ingresso Opzioni
gcj ha opzioni per controllare dove cerca i file di cui ha bisogno. Ad esempio, gcj forza
è necessario caricare una classe a cui fa riferimento il file che è stato chiesto di compilare. Piace
altri compilatori per il linguaggio Java, gcj ha una nozione di a classe sentiero. Ci sono
diverse opzioni e variabili d'ambiente che possono essere utilizzate per manipolare il percorso di classe.
Quando gcj cerca una data classe, cerca il percorso della classe alla ricerca di corrispondenze .classe
or .Giava file. gcj viene fornito con un percorso di classe integrato che punta all'installazione
libgcj.jar, un file che contiene tutte le classi standard.

Nel testo sottostante, una directory o un componente di percorso può fare riferimento a una directory effettiva
sul filesystem, o ad a file .zip or .jar file, che gcj cercherà come se fosse un
directory.

-Idir
Tutte le directory specificate da "-I" sono mantenute in ordine e anteposte al percorso di classe
costruito da tutte le altre opzioni. A meno che non sia compatibile con strumenti come "javac"
è importante, si consiglia di utilizzare sempre "-I" invece delle altre opzioni per
manipolazione del percorso di classe.

--percorsoclasse=sentiero
Questo imposta il percorso della classe su sentiero, un elenco di percorsi separati da due punti (su sistemi basati su Windows
sistemi, un elenco di percorsi separato da punto e virgola). Questo non sovrascrive il builtin
("avvio") percorso di ricerca.

--PERCORSOCLASSE=sentiero
Sinonimo deprecato per "--classpath".

--bootclasspath=sentiero
Dove trovare le classi predefinite standard, come "java.lang.String".

--dir.ext=sentiero
Per ogni directory nel sentiero, posiziona il contenuto di quella directory alla fine del
percorso di classe.

PERCORSO DI CLASSE
Questa è una variabile d'ambiente che contiene un elenco di percorsi.

Il percorso di classe finale è costruito in questo modo:

* Prima vengono tutte le directory specificate tramite "-I".

* Se --percorso di classe è specificato, il suo valore viene aggiunto. Altrimenti, se il "CLASSPATH"
viene specificata la variabile di ambiente, quindi viene aggiunto il suo valore. In caso contrario, la corrente
viene aggiunta la directory (".").

* Se è stato specificato "--bootclasspath", aggiungere il suo valore. Altrimenti, aggiungi il built-in
directory di sistema, libgcj.jar.

* Infine, se è stato specificato "--extdirs", aggiungere il contenuto della specificata
directory alla fine del percorso di classe. In caso contrario, aggiungere il contenuto del
extdir integrate in "$(prefix)/share/java/ext".

Il file di classe creato da gcj per la classe "java.lang.Object" (e inserito in "libgcj.jar")
contiene uno speciale attributo di lunghezza zero "gnu.gcj.gcj-compilato". Il compilatore cerca
questo attributo durante il caricamento di "java.lang.Object" e segnalerà un errore se non viene trovato,
a meno che non venga compilato in bytecode (l'opzione "-fforce-classes-archive-check" può essere usata per
ignorare questo comportamento in questo caso particolare.)

-fforce-classes-archivio-check
Questo costringe il compilatore a controllare sempre l'attributo speciale di lunghezza zero
"gnu.gcj.gcj-compiled" in "java.lang.Object" e genera un errore se non viene trovato.

-fsorgente=VERSIONE
Questa opzione viene utilizzata per scegliere la versione sorgente accettata da gcj. L'impostazione predefinita è 1.5.

codifiche
Il linguaggio di programmazione Java utilizza Unicode in tutto. Nel tentativo di integrarci bene
con altri locali, gcj consente .Giava file da scrivere utilizzando quasi tutte le codifiche. gcj
sa come convertire queste codifiche nella sua codifica interna in fase di compilazione.

Puoi usare "--encoding=NOME" opzione per specificare una codifica (di un carattere particolare
set) da utilizzare per i file di origine. Se questo non è specificato, la codifica predefinita proviene da
il tuo locale attuale. Se il tuo sistema host ha un supporto locale insufficiente, allora gcj
presuppone che la codifica predefinita sia la UTF-8 codifica di Unicode.

Per implementare "--encoding", gcj utilizza semplicemente la routine di conversione "iconv" della piattaforma host.
Ciò significa che in pratica gcj è limitato dalle capacità della piattaforma host.

I nomi consentiti per l'argomento "--encoding" variano da piattaforma a piattaforma (poiché
non sono standardizzati da nessuna parte). Però, gcj implementa la codifica denominata UTF-8
internamente, quindi se scegli di usarlo per i tuoi file sorgente puoi essere certo che lo farà
funzionerà su ogni host.

Avvertenze
gcj implementa diversi avvertimenti. Come con altri generici gcc avvisi, se un'opzione del
form "-Wfoo" abilita un avviso, quindi "-Wno-foo" lo disabilita. Qui abbiamo scelto di
documentare la forma dell'avviso che avrà un effetto -- l'impostazione predefinita è il
opposto di quanto elencato.

- Modificatori-Wredundant
Con questa bandiera, gcj avviserà sui modificatori ridondanti. Ad esempio, avviserà
se un metodo di interfaccia è dichiarato "pubblico".

-Wextraneous-punto e virgola
Questo causa gcj per avvertire di dichiarazioni vuote. Dichiarazioni vuote sono state
deprecato.

-Wno-obsoleto
Questa opzione causerà gcj non avvisare quando un file sorgente è più recente della sua corrispondenza
file di classe. Per impostazione predefinita gcj avviserà di questo.

-Wno-deprecato
Avvisa se si fa riferimento a una classe, metodo o campo deprecato.

-Wunusato
Questo è lo stesso di gcc's "-Wunused".

-Parete
È lo stesso di "-Wredundant-modifiers -Wextraneous-punto e virgola -Wunused".

Collegamento
Per trasformare un'applicazione Java in un programma eseguibile, è necessario collegarla con il necessario
librerie, proprio come per C o C++. Il linker per impostazione predefinita cerca una funzione globale denominata
"principale". Poiché Java non ha funzioni globali e una raccolta di classi Java potrebbe
hai più di una classe con un metodo "main", devi far sapere al linker quale di
quei metodi "principali" che dovrebbe invocare all'avvio dell'applicazione. Puoi farlo in
uno di questi modi:

* Specificare la classe contenente il metodo "main" desiderato quando si collega l'applicazione,
utilizzando il flag "--main", descritto di seguito.

* Collega i pacchetti Java in una libreria condivisa (dll) piuttosto che in un eseguibile. Quindi
invocare l'applicazione utilizzando il programma "gij", assicurandosi che "gij" possa trovare il
biblioteche di cui ha bisogno.

* Collega i pacchetti Java con il flag "-lgij", che si collega alla routine "main"
dal comando "gij". Ciò consente di selezionare la classe di cui si utilizza il metodo "principale"
desidera eseguire quando si esegue l'applicazione. Puoi anche usare altri flag "gij", come
Flag "-D" per impostare le proprietà. Usando la libreria "-lgij" (piuttosto che la libreria "gij"
programma del meccanismo precedente) presenta alcuni vantaggi: è compatibile con statico
collegamento e non richiede la configurazione o l'installazione di librerie.

Queste opzioni "gij" riguardano il collegamento di un eseguibile:

--principale=NOME DELLA CLASSE
Questa opzione viene utilizzata durante il collegamento per specificare il nome della classe il cui metodo "main"
dovrebbe essere invocato quando viene eseguito l'eseguibile risultante.

-DNome[=APPREZZIAMO]
Questa opzione può essere utilizzata solo con "--main". Definisce una proprietà di sistema denominata Nome
con valore APPREZZIAMO. Se APPREZZIAMO non è specificato, il valore predefinito è la stringa vuota.
Queste proprietà di sistema vengono inizializzate all'avvio del programma e possono essere recuperate
in fase di esecuzione utilizzando il metodo "java.lang.System.getProperty".

-lgij
Creare un'applicazione la cui elaborazione dalla riga di comando è quella del comando "gij".

Questa opzione è un'alternativa all'uso di "--main"; non puoi usare entrambi

-static-libgcj
Questa opzione fa sì che il collegamento venga eseguito contro una versione statica del runtime libgcj
biblioteca. Questa opzione è disponibile solo se esiste il supporto del linker corrispondente.

Attenzione: Il collegamento statico di libgcj può causare l'omissione di parti essenziali di libgcj.
Alcune parti di libgcj usano la reflection per caricare le classi in fase di esecuzione. Dal momento che il linker lo fa
non vedere questi riferimenti al momento del collegamento, può omettere le classi di riferimento. Il
il risultato è di solito (ma non sempre) una "ClassNotFoundException" lanciata in fase di esecuzione.
È necessario prestare attenzione quando si utilizza questa opzione. Per maggiori dettagli vedi:
<http://gcc.gnu.org/wiki/Statically%20collegamento%20libgcj>

Code Generazione
Oltre a molti gcc opzioni che controllano la generazione del codice, gcj ha diverse opzioni
specifico di se stesso.

-C Questa opzione è usata per dire gcj per generare bytecode (.classe file) piuttosto che oggetto
codice.

--risorsa nome-risorsa
Questa opzione è usata per dire gcj per compilare il contenuto di un dato file in codice oggetto
quindi è possibile accedervi in ​​fase di esecuzione con il gestore del protocollo principale come nucleo:/risorsa-
Nome. Nota che nome-risorsa è il nome della risorsa così come trovata in fase di esecuzione; per
esempio, potrebbe essere utilizzato in una chiamata a "ResourceBundle.getBundle". Il file reale
il nome da compilare in questo modo deve essere specificato separatamente.

-fttarget=VERSIONE
Questo può essere usato con -C per scegliere la versione del bytecode emesso da gcj.
l'impostazione predefinita è 1.5. Quando non si genera il bytecode, questa opzione non ha effetto.

-d elenco
Se usato con "-C", questo fa sì che tutto venga generato .classe file da inserire nel
sottodirectory appropriata di elenco. Per impostazione predefinita verranno inseriti nelle sottodirectory
della directory di lavoro corrente.

-fno-limiti-controllo
Per impostazione predefinita, gcj genera codice che controlla i limiti di tutti gli indici di array
operazioni. Con questa opzione, questi controlli vengono omessi, il che può migliorare le prestazioni
per il codice che utilizza gli array in modo estensivo. Nota che questo può risultare imprevedibile
comportamento se il codice in questione viola effettivamente i vincoli dei limiti dell'array. Esso
è sicuro usare questa opzione se sei sicuro che il tuo codice non lancerà mai un
"Indice della Matrice Fuori Dai Limiti d'Eccezione".

-fno-store-check
Non generare controlli dell'archivio array. Quando si archiviano oggetti in array, un controllo di runtime
viene normalmente generato al fine di garantire che l'oggetto sia compatibile con l'assegnazione
il tipo di componente dell'array (che potrebbe non essere noto in fase di compilazione). Con questo
opzione, questi controlli vengono omessi. Questo può migliorare le prestazioni per il codice che memorizza
oggetti in array frequentemente. È sicuro usare questa opzione se sei sicuro di te
il codice non genererà mai una "ArrayStoreException".

-fjni
Con gcj ci sono due opzioni per scrivere metodi nativi: CNI e JNI. Per impostazione predefinita
gcj presuppone che tu stia usando CNI. Se stai compilando una classe con metodi nativi e
questi metodi sono implementati usando JNI, quindi devi usare "-fjni". Questa opzione
cause gcj per generare stub che invocheranno i metodi JNI sottostanti.

-fno-asser
Non riconoscere la parola chiave "asser". Questo è per la compatibilità con le versioni precedenti
della specifica della lingua.

-fno-optimize-static-class-inizializzazione
Quando il livello di ottimizzazione è maggiore o uguale a "-O2", gcj cercherò di ottimizzare il
modo in cui vengono effettuate le chiamate nel runtime per inizializzare le classi statiche al primo utilizzo
(questa ottimizzazione non viene eseguita se è stato specificato "-C".) Quando si compila in nativo
codice, "-fno-optimize-static-class-initialization" disattiverà questa ottimizzazione,
indipendentemente dal livello di ottimizzazione in uso.

--disable-asserzioni[=classe-o-pacchetto]
Non includere codice per il controllo delle asserzioni nel codice compilato. Se
"=classe-o-pacchetto" manca disabilita la generazione del codice di asserzione per tutte le classi,
a meno che non venga sovrascritto da un flag "--enable-assertions" più specifico. Se classe-o-pacchetto
è un nome di classe, disabilita solo la generazione di controlli di asserzione all'interno della classe denominata o
sue classi interne. Se classe-o-pacchetto è un nome di pacchetto, disabilita la generazione
controlli di asserzione all'interno del pacchetto denominato o di un sottopacchetto.

Per impostazione predefinita, le asserzioni sono abilitate quando si generano file di classe o quando non si ottimizzano,
e disabilitato durante la generazione di binari ottimizzati.

--enable-asserzioni[=classe-o-pacchetto]
Genera codice per controllare le asserzioni. L'opzione è forse un nome errato, poiché è ancora necessario
per attivare il controllo delle asserzioni in fase di esecuzione e non supportiamo alcun modo semplice per farlo
Quello. Quindi questo flag non è ancora molto utile, tranne che per sovrascriverlo parzialmente
"--disabilita-asserzioni".

-findirect-dispaccio
gcj ha una speciale compatibilità binaria ABI, che è abilitata dal
opzione "-findirect-dispatch". In questa modalità, il codice generato da gcj onora il
garanzie di compatibilità binaria nella specifica del linguaggio Java e la risultante
i file oggetto non devono essere collegati direttamente alle loro dipendenze. Anziché,
tutte le dipendenze vengono ricercate in fase di esecuzione. Ciò consente la libera miscelazione di interpretati e
codice compilato.

Nota che, al momento, "-findirect-dispatch" può essere utilizzato solo durante la compilazione .classe
File. Non funzionerà durante la compilazione dal sorgente. Anche CNI non lavora ancora con
la compatibilità binaria ABI. Queste restrizioni verranno revocate in futuro
rilasciare.

Tuttavia, se compili il codice CNI con l'ABI standard, puoi chiamarlo da codice
costruito con la compatibilità binaria ABI.

-fbootstrap-classi
Questa opzione può essere usata per dire a "libgcj" che le classi compilate dovrebbero essere caricate da
il caricatore bootstrap, non il caricatore della classe di sistema. Di default, se compili una classe
e collegarlo a un eseguibile, verrà trattato come se fosse stato caricato utilizzando il comando
caricatore di classi di sistema. Questo è conveniente, in quanto significa che cose come
"Class.forName()" cercherà PERCORSO DI CLASSE per trovare la classe desiderata.

-riflesso-fredotto
Questa opzione fa sì che il codice generato da gcj contenere una quota ridotta della classe
metadati utilizzati per supportare la riflessione in fase di esecuzione. Il costo di questo risparmio è la perdita di
la capacità di utilizzare determinate capacità di riflessione del runtime Java standard
ambiente. Quando si impostano tutti i metadati ad eccezione di quelli necessari per ottenere la correzione
la semantica di runtime viene eliminata.

Per codice che non usa la reflection (es. serializzazione, RMI, CORBA o metodi di chiamata)
nel pacchetto "java.lang.reflect"), "-freduced-reflection" risulterà corretto
operazione con un risparmio nella dimensione del codice eseguibile.

JNI ("-fjni") e la compatibilità binaria ABI ("-findirect-dispatch") non funzionano
correttamente senza metadati di riflessione completa. Per questo motivo, è un errore da usare
queste opzioni con "-riflessione-fredotta".

Attenzione: Se non sono presenti metadati di riflessione, il codice che utilizza un "SecurityManager" può
non funzionare correttamente. Anche la chiamata a "Class.forName()" potrebbe non riuscire se il metodo chiamante ha
nessun meta-dati di riflessione.

Tempo di configurazione Opzioni
Alcuni gcj le opzioni di generazione del codice influiscono sull'ABI risultante e quindi può essere solo
dato in modo significativo quando "libgcj", il pacchetto runtime, è configurato. "libgcj" mette il
opzioni appropriate da questo gruppo in a spec file che viene letto da gcj. Queste opzioni
sono elencati qui per completezza; se stai usando "libgcj" non vorrai toccare
queste opzioni.

-fusibile-boehm-gc
Ciò consente l'uso del codice di marcatura bitmap Boehm GC. In particolare questo causa
gcj per inserire un descrittore di marcatura oggetto in ogni vtable.

-fhash-sincronizzazione
Per impostazione predefinita, i dati di sincronizzazione (i dati utilizzati per "sincronizzare", "attesa" e
"notifica") è indicato da una parola in ogni oggetto. Con questa opzione gcj lo presume
queste informazioni sono memorizzate in una tabella hash e non nell'oggetto stesso.

-subroutine-fuse-divide
Su alcuni sistemi, viene chiamata una routine di libreria per eseguire la divisione di interi. Questo è
necessario per ottenere la corretta gestione delle eccezioni durante la divisione per zero.

-fcheck-riferimenti
Su alcuni sistemi è necessario inserire dei controlli in linea ogni volta che si accede ad un oggetto
tramite un riferimento. Su altri sistemi non ti servirà perché il puntatore null accede
vengono catturati automaticamente dal processore.

-fusibile-atomici-incorporati
Su alcuni sistemi, GCC può generare codice per operazioni atomiche integrate. Usa questo
opzione per forzare gcj a utilizzare questi builtin durante la compilazione del codice Java. Dove questo
la capacità è presente dovrebbe essere rilevata automaticamente, quindi di solito non è necessario
per utilizzare questa opzione.

Usa powerpc64-linux-gnu-gcj online usando i servizi onworks.net