Come posso dire a gcc di non incorporare una funzione?

Supponiamo di avere questa piccola funzione in un file sorgente

static void foo() {}

e costruisco una versione ottimizzata del mio binario, ma non voglio che questa funzione sia incorporata (per scopi di ottimizzazione). c'è una macro che posso aggiungere in un codice sorgente per impedire l'allineamento?

Si desidera l' attributo gcc-specifico noinline.

Questo attributo di funzione impedisce che una funzione venga considerata per l'inline. Se la funzione non ha effetti collaterali, ci sono ottimizzazioni diverse dall'inline che causano l'ottimizzazione delle chiamate di funzione, sebbene la chiamata di funzione sia attiva. Per evitare che tali chiamate vengano ottimizzate, metti asm ("");

Usalo in questo modo:

void __attribute__ ((noinline)) foo() 
{
  ...
}

GCC ha un interruttore chiamato

-fno-inline-small-functions

Quindi usalo quando invochi gcc. Ma l'effetto collaterale è che tutte le altre piccole funzioni sono anche non incorporate.

Un modo portatile per farlo è chiamare la funzione tramite un puntatore:

void (*foo_ptr)() = foo;
foo_ptr();

Anche se questo produce diverse istruzioni per ramificare, che potrebbe non essere il tuo obiettivo. Il che fa emergere un buon punto: qual è il tuo obiettivo qui?

So che la domanda riguarda GCC, ma ho pensato che potesse essere utile avere alcune informazioni su compilatori e altri compilatori.

L' noinline attributo di funzione di GCC è abbastanza popolare anche con altri compilatori. È supportato da almeno:

• Clang (verifica con __has_attribute(noinline))
• Compilatore Intel C / C ++ (la loro documentazione è terribile, ma sono certo che funziona su 16.0+)
• Oracle Solaris Studio torna almeno a 12.2
• Compilatore ARM C / C ++ di nuovo almeno 4.1
• IBM XL C / C ++ indietro almeno alla 10.1
• TI 8.0+ (o 7.3+ con --gcc, che definirà __TI_GNU_ATTRIBUTE_SUPPORT__)

Inoltre, MSVC supporta __declspec(noinline) nuovamente Visual Studio 7.1. Probabilmente anche Intel lo supporta (cercano di essere compatibili con GCC e MSVC), ma non mi sono preoccupato di verificarlo. La sintassi è sostanzialmente la stessa:

__declspec(noinline)
static void foo(void) { }

IGP 10.2+ (e probabilmente precedente) supporta un noinlinepragma che si applica alla funzione successiva:

#pragma noinline
static void foo(void) { }

TI 6.0+ supporta un FUNC_CANNOT_INLINE pragma che (fastidiosamente) funziona diversamente in C e C ++. In C ++, è simile a IGP:

#pragma FUNC_CANNOT_INLINE;
static void foo(void) { }

In C, tuttavia, è richiesto il nome della funzione:

#pragma FUNC_CANNOT_INLINE(foo);
static void foo(void) { }

Cray 6.4+ (e possibilmente prima) adotta un approccio simile, richiedendo il nome della funzione:

#pragma _CRI inline_never foo
static void foo(void) { }

Oracle Developer Studio supporta anche un pragma che prende il nome della funzione, risalendo almeno a Forte Developer 6 , ma nota che deve venire dopo la dichiarazione, anche nelle versioni recenti:

static void foo(void);
#pragma no_inline(foo)

A seconda di quanto ti dedichi, potresti creare una macro che funzionerebbe ovunque, ma dovrai avere il nome della funzione e la dichiarazione come argomenti.

Se, OTOH, stai bene con qualcosa che funziona solo per la maggior parte delle persone, puoi cavartela con qualcosa che è un po 'più esteticamente piacevole e non richiede di ripeterti. Questo è l'approccio che ho adottato per Hedley , dove la versione attuale di HEDLEY_NEVER_INLINE è simile a:

#if \
  HEDLEY_GNUC_HAS_ATTRIBUTE(noinline,4,0,0) || \
  HEDLEY_INTEL_VERSION_CHECK(16,0,0) || \
  HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \
  HEDLEY_ARM_VERSION_CHECK(4,1,0) || \
  HEDLEY_IBM_VERSION_CHECK(10,1,0) || \
  HEDLEY_TI_VERSION_CHECK(8,0,0) || \
  (HEDLEY_TI_VERSION_CHECK(7,3,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__))
#  define HEDLEY_NEVER_INLINE __attribute__((__noinline__))
#elif HEDLEY_MSVC_VERSION_CHECK(13,10,0)
#  define HEDLEY_NEVER_INLINE __declspec(noinline)
#elif HEDLEY_PGI_VERSION_CHECK(10,2,0)
#  define HEDLEY_NEVER_INLINE _Pragma("noinline")
#elif HEDLEY_TI_VERSION_CHECK(6,0,0)
#  define HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;")
#else
#  define HEDLEY_NEVER_INLINE HEDLEY_INLINE
#endif

Se non vuoi usare Hedley (è un singolo dominio pubblico / intestazione CC0) puoi convertire la versione controllando le macro senza troppi sforzi, ma più di quanto io sia disposto a inserire ☺.

Nel caso in cui ricevi un errore del compilatore __attribute__((noinline)), puoi semplicemente provare:

noinline int func(int arg)
{
    ....
}

static __attribute__ ((noinline))  void foo()
{

}

Questo è ciò che ha funzionato per me.

Usa l' noinline attributo :

int func(int arg) __attribute__((noinline))
{
}

Probabilmente dovresti usarlo sia quando dichiari la funzione per uso esterno sia quando scrivi la funzione.

Lavoro con gcc 7.2. In particolare avevo bisogno di una funzione per non essere incorporata, perché doveva essere istanziata in una libreria. Ho provato la __attribute__((noinline))risposta, così come la asm("")risposta. Nessuno dei due ha risolto il problema.

Infine, ho immaginato che la definizione di una variabile statica all'interno della funzione costringerà il compilatore ad allocare spazio per essa nel blocco di variabili statiche e ad emettere un'inizializzazione al momento della prima chiamata della funzione.

Questo è una specie di trucco sporco, ma funziona.