Note: This website is archived. For up-to-date information about D projects and development, please visit wiki.dlang.org.

Changeset 380

Show
Ignore:
Timestamp:
02/12/10 09:35:06 (15 years ago)
Author:
walter
Message:

bugzilla 3736 corrupted struct returned by function with optimizations (-O)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • branches/dmd-1.x/src/backend/blockopt.c

    r288 r380  
    11// Copyright (C) 1986-1997 by Symantec 
    2 // Copyright (C) 2000-2009 by Digital Mars 
     2// Copyright (C) 2000-2010 by Digital Mars 
    33// All Rights Reserved 
    44// http://www.digitalmars.com 
    55// Written by Walter Bright 
    66/* 
    77 * This source file is made available for personal use 
    88 * only. The license is in /dmd/src/dmd/backendlicense.txt 
    99 * or /dm/src/dmd/backendlicense.txt 
    1010 * For any other uses, please contact Digital Mars. 
    1111 */ 
    1212 
    1313 
    1414/**************************************************************** 
    1515 * Handle basic blocks. 
    1616 */ 
    1717 
    1818#if !SPP 
    1919 
    2020#include    <stdio.h> 
    2121#include    <string.h> 
    2222#include    <time.h> 
    …… 
    726726            if (b2->Belem) 
    727727            { 
    728728            op = OPandand; 
    729729            b->Belem = PARSER ? el_bint(op,tsint,b->Belem,b2->Belem) 
    730730                      : el_bin(op,TYint,b->Belem,b2->Belem); 
    731731            b2->Belem = NULL; 
    732732            } 
    733733            list_subtract(&(b->Bsucc),b2); 
    734734            list_subtract(&(b2->Bpred),b); 
    735735            cmes("brcombine(): if !e1 then e2 => e1 || e2\n"); 
    736736            anychanges++; 
    737737        } 
    738738        else if (list_next(b3->Bpred) || b3 == startblock) 
    739739            continue; 
    740740        else if ((bc2 == BCretexp && b3->BC == BCretexp) 
    741741             //|| (bc2 == BCret && b3->BC == BCret) 
    742742            ) 
    743743        {   elem *e; 
    744744 
    745745            if (PARSER) 
    746             {   type *t; 
    747  
    748             t = (bc2 == BCretexp) ? b2->Belem->ET : tsvoid; 
     746            { 
     747            type *t = (bc2 == BCretexp) ? b2->Belem->ET : tsvoid; 
    749748            e = el_bint(OPcolon2,t,b2->Belem,b3->Belem); 
    750749            b->Belem = el_bint(OPcond,t,b->Belem,e); 
    751750            } 
    752751            else 
    753             {   tym_t ty; 
    754  
     752            { 
    755753            if (EOP(b3->Belem)) 
    756754                continue; 
    757             ty = (bc2 == BCretexp) ? b2->Belem->Ety : TYvoid; 
     755            tym_t ty = (bc2 == BCretexp) ? b2->Belem->Ety : TYvoid; 
    758756            e = el_bin(OPcolon2,ty,b2->Belem,b3->Belem); 
    759757            b->Belem = el_bin(OPcond,ty,b->Belem,e); 
    760758            } 
    761759            b->BC = bc2; 
     760            b->Belem->Enumbytes = b2->Belem->Enumbytes; 
    762761            b2->Belem = NULL; 
    763762            b3->Belem = NULL; 
    764763            list_free(&b->Bsucc,FPNULL); 
    765764            list_subtract(&(b2->Bpred),b); 
    766765            list_subtract(&(b3->Bpred),b); 
    767766            cmes("brcombine(): if e1 return e2 else return e3 => ret e1?e2:e3\n"); 
    768767            anychanges++; 
    769768        } 
    770769        else if (bc2 == BCgoto && 
    771770             b3->BC == BCgoto && 
    772771             list_block(b2->Bsucc) == list_block(b3->Bsucc)) 
    773772        {   elem *e; 
    774773            block *bsucc; 
    775774 
    776775            bsucc = list_block(b2->Bsucc); 
    777776            if (b2->Belem) 
    778777            { 
    779778            if (PARSER) 
    780779            { 
    781780                if (b3->Belem) 
    782781                { 
    783782                e = el_bint(OPcolon2,b2->Belem->ET, 
    784783                    b2->Belem,b3->Belem); 
    785784                e = el_bint(OPcond,e->ET,b->Belem,e); 
    786785                } 
    787786                else 
    788787                { 
    789788                op = OPandand; 
    790789                e = el_bint(op,tsint,b->Belem,b2->Belem); 
    791790                } 
    792791            } 
    793792            else 
    794793            { 
    795794                if (b3->Belem) 
    796795                { 
    797796                if (EOP(b3->Belem)) 
    798797                    continue; 
    799798                e = el_bin(OPcolon2,b2->Belem->Ety, 
    800799                    b2->Belem,b3->Belem); 
    801800                e = el_bin(OPcond,e->Ety,b->Belem,e); 
     801                e->Enumbytes = b2->Belem->Enumbytes; 
    802802                } 
    803803                else 
    804804                { 
    805805                op = OPandand; 
    806806                e = el_bin(op,TYint,b->Belem,b2->Belem); 
    807807                } 
    808808            } 
    809809            b2->Belem = NULL; 
    810810            b->Belem = e; 
    811811            } 
    812812            else if (b3->Belem) 
    813813            { 
    814814            op = OPoror; 
    815815            b->Belem = PARSER ? el_bint(op,tsint,b->Belem,b3->Belem) 
    816816                      : el_bin(op,TYint,b->Belem,b3->Belem); 
    817817            } 
    818818            b->BC = BCgoto; 
    819819            b3->Belem = NULL; 
    820820            list_free(&b->Bsucc,FPNULL); 
    821821 

  • branches/dmd-1.x/src/backend/cgelem.c

    r289 r380  
    11// Copyright (C) 1985-1998 by Symantec 
    2 // Copyright (C) 2000-2009 by Digital Mars 
     2// Copyright (C) 2000-2010 by Digital Mars 
    33// All Rights Reserved 
    44// http://www.digitalmars.com 
    55// Written by Walter Bright 
    66/* 
    77 * This source file is made available for personal use 
    88 * only. The license is in /dmd/src/dmd/backendlicense.txt 
    99 * or /dm/src/dmd/backendlicense.txt 
    1010 * For any other uses, please contact Digital Mars. 
    1111 */ 
    1212 
    1313#if !SPP 
    1414 
    1515#include    <stdio.h> 
    1616#include    <string.h> 
    1717#include    <time.h> 
    1818#include    "cc.h" 
    1919#include    "oper.h" 
    2020#include    "global.h" 
    2121#include    "el.h" 
    2222#include    "dt.h" 
    …… 
    43784378            if (EOP(e1))    // if failed to fold the constants 
    43794379            {   // Undo the changes so we don't infinite loop 
    43804380            e->E2 = e1->E1; 
    43814381            e1->E1 = e->E1; 
    43824382            e->E1 = e1; 
    43834383            } 
    43844384            else 
    43854385            {   e->E2 = e1; 
    43864386            goto beg; 
    43874387            } 
    43884388        } 
    43894389        else 
    43904390            goto beg; 
    43914391        } 
    43924392      } 
    43934393 
    43944394      if (!OTrtol(op) && op != OPparam && op != OPcolon && op != OPcolon2 && 
    43954395          e1->Eoper == OPcomma) 
    43964396      { // Convert ((a,b) op c) to (a,(b op c)) 
    43974397        e1->Ety = e->Ety; 
     4398        e1->Enumbytes = e->Enumbytes; 
    43984399        e->E1 = e1->E2; 
    43994400        e1->E2 = e; 
    44004401        e = e1; 
    44014402        goto beg; 
    44024403      } 
    44034404    } 
    44044405 
    44054406    if (OTcommut(op))        // if commutative 
    44064407    { 
    44074408          /* see if we should swap the leaves   */ 
    44084409#if 0 
    44094410          if (tyfloating(e1->Ety)) 
    44104411          { 
    44114412            if (fcost(e2) > fcost(e1)) 
    44124413            {   e->E1 = e2; 
    44134414            e2 = e->E2 = e1; 
    44144415            e1 = e->E1;     // reverse the leaves 
    44154416            op = e->Eoper = swaprel(op); 
    44164417            } 
    44174418          } 

  • trunk/src/backend/blockopt.c

    r288 r380  
    11// Copyright (C) 1986-1997 by Symantec 
    2 // Copyright (C) 2000-2009 by Digital Mars 
     2// Copyright (C) 2000-2010 by Digital Mars 
    33// All Rights Reserved 
    44// http://www.digitalmars.com 
    55// Written by Walter Bright 
    66/* 
    77 * This source file is made available for personal use 
    88 * only. The license is in /dmd/src/dmd/backendlicense.txt 
    99 * or /dm/src/dmd/backendlicense.txt 
    1010 * For any other uses, please contact Digital Mars. 
    1111 */ 
    1212 
    1313 
    1414/**************************************************************** 
    1515 * Handle basic blocks. 
    1616 */ 
    1717 
    1818#if !SPP 
    1919 
    2020#include    <stdio.h> 
    2121#include    <string.h> 
    2222#include    <time.h> 
    …… 
    726726            if (b2->Belem) 
    727727            { 
    728728            op = OPandand; 
    729729            b->Belem = PARSER ? el_bint(op,tsint,b->Belem,b2->Belem) 
    730730                      : el_bin(op,TYint,b->Belem,b2->Belem); 
    731731            b2->Belem = NULL; 
    732732            } 
    733733            list_subtract(&(b->Bsucc),b2); 
    734734            list_subtract(&(b2->Bpred),b); 
    735735            cmes("brcombine(): if !e1 then e2 => e1 || e2\n"); 
    736736            anychanges++; 
    737737        } 
    738738        else if (list_next(b3->Bpred) || b3 == startblock) 
    739739            continue; 
    740740        else if ((bc2 == BCretexp && b3->BC == BCretexp) 
    741741             //|| (bc2 == BCret && b3->BC == BCret) 
    742742            ) 
    743743        {   elem *e; 
    744744 
    745745            if (PARSER) 
    746             {   type *t; 
    747  
    748             t = (bc2 == BCretexp) ? b2->Belem->ET : tsvoid; 
     746            { 
     747            type *t = (bc2 == BCretexp) ? b2->Belem->ET : tsvoid; 
    749748            e = el_bint(OPcolon2,t,b2->Belem,b3->Belem); 
    750749            b->Belem = el_bint(OPcond,t,b->Belem,e); 
    751750            } 
    752751            else 
    753             {   tym_t ty; 
    754  
     752            { 
    755753            if (EOP(b3->Belem)) 
    756754                continue; 
    757             ty = (bc2 == BCretexp) ? b2->Belem->Ety : TYvoid; 
     755            tym_t ty = (bc2 == BCretexp) ? b2->Belem->Ety : TYvoid; 
    758756            e = el_bin(OPcolon2,ty,b2->Belem,b3->Belem); 
    759757            b->Belem = el_bin(OPcond,ty,b->Belem,e); 
    760758            } 
    761759            b->BC = bc2; 
     760            b->Belem->Enumbytes = b2->Belem->Enumbytes; 
    762761            b2->Belem = NULL; 
    763762            b3->Belem = NULL; 
    764763            list_free(&b->Bsucc,FPNULL); 
    765764            list_subtract(&(b2->Bpred),b); 
    766765            list_subtract(&(b3->Bpred),b); 
    767766            cmes("brcombine(): if e1 return e2 else return e3 => ret e1?e2:e3\n"); 
    768767            anychanges++; 
    769768        } 
    770769        else if (bc2 == BCgoto && 
    771770             b3->BC == BCgoto && 
    772771             list_block(b2->Bsucc) == list_block(b3->Bsucc)) 
    773772        {   elem *e; 
    774773            block *bsucc; 
    775774 
    776775            bsucc = list_block(b2->Bsucc); 
    777776            if (b2->Belem) 
    778777            { 
    779778            if (PARSER) 
    780779            { 
    781780                if (b3->Belem) 
    782781                { 
    783782                e = el_bint(OPcolon2,b2->Belem->ET, 
    784783                    b2->Belem,b3->Belem); 
    785784                e = el_bint(OPcond,e->ET,b->Belem,e); 
    786785                } 
    787786                else 
    788787                { 
    789788                op = OPandand; 
    790789                e = el_bint(op,tsint,b->Belem,b2->Belem); 
    791790                } 
    792791            } 
    793792            else 
    794793            { 
    795794                if (b3->Belem) 
    796795                { 
    797796                if (EOP(b3->Belem)) 
    798797                    continue; 
    799798                e = el_bin(OPcolon2,b2->Belem->Ety, 
    800799                    b2->Belem,b3->Belem); 
    801800                e = el_bin(OPcond,e->Ety,b->Belem,e); 
     801                e->Enumbytes = b2->Belem->Enumbytes; 
    802802                } 
    803803                else 
    804804                { 
    805805                op = OPandand; 
    806806                e = el_bin(op,TYint,b->Belem,b2->Belem); 
    807807                } 
    808808            } 
    809809            b2->Belem = NULL; 
    810810            b->Belem = e; 
    811811            } 
    812812            else if (b3->Belem) 
    813813            { 
    814814            op = OPoror; 
    815815            b->Belem = PARSER ? el_bint(op,tsint,b->Belem,b3->Belem) 
    816816                      : el_bin(op,TYint,b->Belem,b3->Belem); 
    817817            } 
    818818            b->BC = BCgoto; 
    819819            b3->Belem = NULL; 
    820820            list_free(&b->Bsucc,FPNULL); 
    821821 

  • trunk/src/backend/cgelem.c

    r289 r380  
    11// Copyright (C) 1985-1998 by Symantec 
    2 // Copyright (C) 2000-2009 by Digital Mars 
     2// Copyright (C) 2000-2010 by Digital Mars 
    33// All Rights Reserved 
    44// http://www.digitalmars.com 
    55// Written by Walter Bright 
    66/* 
    77 * This source file is made available for personal use 
    88 * only. The license is in /dmd/src/dmd/backendlicense.txt 
    99 * or /dm/src/dmd/backendlicense.txt 
    1010 * For any other uses, please contact Digital Mars. 
    1111 */ 
    1212 
    1313#if !SPP 
    1414 
    1515#include    <stdio.h> 
    1616#include    <string.h> 
    1717#include    <time.h> 
    1818#include    "cc.h" 
    1919#include    "oper.h" 
    2020#include    "global.h" 
    2121#include    "el.h" 
    2222#include    "dt.h" 
    …… 
    43784378            if (EOP(e1))    // if failed to fold the constants 
    43794379            {   // Undo the changes so we don't infinite loop 
    43804380            e->E2 = e1->E1; 
    43814381            e1->E1 = e->E1; 
    43824382            e->E1 = e1; 
    43834383            } 
    43844384            else 
    43854385            {   e->E2 = e1; 
    43864386            goto beg; 
    43874387            } 
    43884388        } 
    43894389        else 
    43904390            goto beg; 
    43914391        } 
    43924392      } 
    43934393 
    43944394      if (!OTrtol(op) && op != OPparam && op != OPcolon && op != OPcolon2 && 
    43954395          e1->Eoper == OPcomma) 
    43964396      { // Convert ((a,b) op c) to (a,(b op c)) 
    43974397        e1->Ety = e->Ety; 
     4398        e1->Enumbytes = e->Enumbytes; 
    43984399        e->E1 = e1->E2; 
    43994400        e1->E2 = e; 
    44004401        e = e1; 
    44014402        goto beg; 
    44024403      } 
    44034404    } 
    44044405 
    44054406    if (OTcommut(op))        // if commutative 
    44064407    { 
    44074408          /* see if we should swap the leaves   */ 
    44084409#if 0 
    44094410          if (tyfloating(e1->Ety)) 
    44104411          { 
    44114412            if (fcost(e2) > fcost(e1)) 
    44124413            {   e->E1 = e2; 
    44134414            e2 = e->E2 = e1; 
    44144415            e1 = e->E1;     // reverse the leaves 
    44154416            op = e->Eoper = swaprel(op); 
    44164417            } 
    44174418          }