Warum hat die -O3 GCC-Optimierung diese Funktion nicht inline ausgeführt?

Question

Im GCC-Compiler, wenn -O3 angeflagt ist, optimiert der Compiler hauptsächlich durch Schleifenentfaltung und Funktionsinline.

Als ich jedoch eine Anwendung kompilierte, die die folgende Funktion enthält, hat der Compiler keine Funktionsinline durchgeführt. Beim gprofen und gconvien konnte ich feststellen, dass diese Funktion (comp_t_delay) nicht aus der Hauptfunktioneinheit dieser Anwendung aufgerufen wurde. Stattdessen wurde sie von einer Funktion aufgerufen, die von einer Funktion aufgerufen wurde, die von der Hauptfunktion aufgerufen wurde.

Hier ist der Code von comp_t_delay(int in, int ip), den ich gerne wissen möchte, warum der GCC ihn nicht mit -O3 optimiert hat (jede Hilfe wird geschätzt!):

static float
comp_t_delay(int in, int ip)
{

    int sb, sib, dx, dy;
    t_type_ptr st, sit;
    float d_ssi;

    d_ssi = 0.;

    sb = net[in].node_block[0];
    st = block[sb].type;

    sib = net[in].node_block[ip];
    sit = block[sib].type;

    assert(st != NULL);
    assert(sit != NULL);

    dx = abs(block[sib].x - block[sb].x);
    dy = abs(block[sib].y - block[sb].y);

    if(st == T_IO)
    {
        if(sit == T_IO)
        d_ssi = de_io[dx][dy];
        else
        d_ssi = de_iof[dx][dy];
    }
    else
    {
        if(sit == T_IO)
        d_ssi = de_fio[dx][dy];
        else
        d_ssi = de_fb[dx][dy];
    }
    if(d_ssi < 0)
    {
        printf
        ("Fehler1\n");
        exit(1);
    }

    if(d_ssi < 0.)
    {
        printf
        ("Fehler2\n");
        exit(1);
    }

    return (d_ssi);
}

Answer 1

Es hat höchstwahrscheinlich nicht inline geschaltet, weil es zu lang ist. Lange Funktionen können tatsächlich dazu führen, dass der Code langsamer ausgeführt wird, wenn sie inline geschaltet werden - zum Beispiel werden die CPU-Register durch mehr Variablen aufgebläht. In diesem speziellen Fall hat GCC entschieden, dass es schneller ist, die Funktion nicht inline zu schalten.