Fix:
You can work around the problem by adding a dummy variable 
to the contents of the structure logicalifname.

State-Changed-From-To: open->analyzed
State-Changed-Why: I can reproduce this with 3.2.1pre, but it seems fixed in
    present CVS. However, since this is a regression w.r.t.
    2.95, I leave it open and put it into "high". A reduced
    testcase is this:
    ----------------------------------
    #include <stdio.h>
    #include <string.h>
    
    struct X {
            char s[100];
    };
    
    void foo(struct X x) {
      printf("x.s: %s\n", x.s);
    }
    
    int main() {
        struct X x;
        strcpy(x.s, "this is a test string");
        foo(x);
    }
    -------------------------------------
    With 3.2.1pre I get
    tmp/g> /home/bangerth/bin/gcc-3.2.1-pre/bin/gcc x.c
    tmp/g> ./a.out
    x.s: Äñÿ¿Ôa@st string
    
    This is not what I want to see.

From: Wolfgang Bangerth <bangerth@ticam.utexas.edu>
To: gcc-gnats@gcc.gnu.org
Cc:  
Subject: Re: c/5351: function pass-by-value structure copy corrupts structure
 on stack
Date: Wed, 6 Nov 2002 13:00:00 -0600 (CST)

 This is probably a duplicate of 7591.
 W.
 
 -------------------------------------------------------------------------
 Wolfgang Bangerth              email:           bangerth@ticam.utexas.edu
                                www: http://www.ticam.utexas.edu/~bangerth
 
 

State-Changed-From-To: analyzed->closed
State-Changed-Why: Fixed by a patch from HJ:
    
    http://gcc.gnu.org/ml/gcc-patches/2002-08/msg01170.html

I am running cygwin on Windows XP
I am using gcc 3.4.4-3
The bug also manifests itself on my service provider's CPU.
All values should be 100.0. Minimal program below.

cc -o test test.c

My erroneous values:
ListA: (x: 100.0 y: 100.0 z: 100.0 w: 100.0)
ListB: (x: 100.0 y: 100.0 z: 100.0 w: 100.0)
MinA: (x:   0.0 y:   0.0 z:   0.0 w: 100.0)
MinB: (x:   0.0 y:   0.0 z:   0.0 w:   0.0)
AvgA: (x: 100.0 y: 100.0 z: 100.0 w: 100.0)
AvgB: (x: 100.0 y: 100.0 z: 100.0 w: 200.0)

Service provider erroneous values:
ListA: (x: 100.0 y: 100.0 z: 100.0 w: 100.0)
ListB: (x: 100.0 y: 100.0 z: 100.0 w: 100.0)
MinA: (x:  -0.0 y:   0.0 z:   0.0 w: 100.0)
MinB: (x:  -0.0 y:   0.0 z:   0.0 w:  -0.0)
AvgA: (x: 100.0 y: 100.0 z: 100.0 w: 100.0)
AvgB: (x: 100.0 y: 100.0 z: 100.0 w: 200.0)

------- test.c code that fails is here: ------------

#include <stdio.h>

#define MIN(a,b)  (((a)<=(b))?(a):(b))

#define ENTRIES 1 // put whatever in here, it is still broken

typedef struct
{
    double x, y, z, w;
} Entry;

Entry ListA[ENTRIES];
Entry ListB[ENTRIES];

Entry MinA, AvgA;
Entry MinB, AvgB;

extern void         printEntry(Entry  fntry, char *label);
extern Entry           Average(Entry *fntry);
extern Entry           Minimum(Entry *fntry);

main(int argc, char **argv)
{
    int i;

    for(i = 0; i < ENTRIES; i++)
    {
        ListA[i].x = 100; ListA[i].y = 100; ListA[i].z = 100; ListA[i].w = 100;
        ListB[i].x = 100; ListB[i].y = 100; ListB[i].z = 100; ListB[i].w = 100;
    }

    printEntry(ListA[0], "ListA");
    printEntry(ListB[0], "ListB");


    // should be same, but aren't
    MinA = Minimum(ListA); printEntry(MinA, "MinA");
    MinB = Minimum(ListB); printEntry(MinB, "MinB");

    // should be same, but aren't
    AvgA = Average(ListA); printEntry(AvgA, "AvgA");
    AvgB = Average(ListB); printEntry(AvgB, "AvgB");
}

void
printEntry(Entry fntry, char *label)
{
    printf("%s: (x: %5.1f y: %5.1f z: %5.1f w: %5.1f)\n",
        label, fntry.x, fntry.y, fntry.z, fntry.w);
}


Entry
Average(Entry *fntry)
{
    int i;
    Entry average;

    for (i = 0; i < ENTRIES; i++)
    {
        average.x += fntry[i].x;
        average.y += fntry[i].y;
        average.z += fntry[i].z;
        average.w += fntry[i].w;
    }

    average.x /= ENTRIES;
    average.y /= ENTRIES;
    average.z /= ENTRIES;
    average.w /= ENTRIES;

    return(average);
}

Entry
Minimum(Entry *fntry)
{
    int i;
    Entry minimum;

    for (i = 0; i < ENTRIES; i++)
    {
        minimum.x = MIN(minimum.x, fntry[i].x);
        minimum.y = MIN(minimum.y, fntry[i].y);
        minimum.z = MIN(minimum.z, fntry[i].z);
        minimum.w = MIN(minimum.w, fntry[i].w);
    }

    return(minimum);
}