From lattner at cs.uiuc.edu Mon Dec 15 00:40:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 00:40:02 2003 Subject: [llvm-commits] CVS: llvm/include/Support/slist Message-ID: <200312150639.AAA10650@zion.cs.uiuc.edu> Changes in directory llvm/include/Support: slist (r1.5) removed --- Log message: This header is dead --- Diffs of the changes: (+0 -0) From lattner at cs.uiuc.edu Mon Dec 15 11:34:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 11:34:01 2003 Subject: [llvm-commits] CVS: llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx Message-ID: <200312151733.LAA07236@zion.cs.uiuc.edu> Changes in directory llvm/test/Regression/Transforms/IndVarsSimplify: 2003-12-15-Crash.llx added (r1.1) --- Log message: New testcase, for PR185 --- Diffs of the changes: (+22 -0) Index: llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx diff -c /dev/null llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx:1.1 *** /dev/null Mon Dec 15 11:33:51 2003 --- llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx Mon Dec 15 11:33:41 2003 *************** *** 0 **** --- 1,22 ---- + void %_ZN17CoinFactorization7cleanupEv() { + entry: + br bool false, label %loopexit.14, label %cond_continue.3 + + cond_continue.3: ; preds = %entry + ret void + + loopexit.14: ; preds = %entry + %tmp.738 = sub int 0, 0 ; [#uses=1] + br bool false, label %no_exit.15.preheader, label %loopexit.15 + + no_exit.15.preheader: ; preds = %loopexit.14 + br label %no_exit.15 + + no_exit.15: ; preds = %no_exit.15.preheader, %no_exit.15 + %highC.0 = phi int [ %tmp.738, %no_exit.15.preheader ], [ %dec.0, %no_exit.15 ] ; [#uses=1] + %dec.0 = add int %highC.0, -1 ; [#uses=1] + br bool false, label %no_exit.15, label %loopexit.15 + + loopexit.15: ; preds = %loopexit.14, %no_exit.15 + ret void + } From lattner at cs.uiuc.edu Mon Dec 15 11:35:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 11:35:02 2003 Subject: [llvm-commits] CVS: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Message-ID: <200312151734.LAA07325@zion.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/Scalar: IndVarSimplify.cpp updated: 1.44 -> 1.45 --- Log message: Fix for PR185 & IndVarsSimplify/2003-12-15-Crash.llx --- Diffs of the changes: (+9 -0) Index: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp diff -u llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.44 llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.45 --- llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.44 Wed Dec 10 14:43:04 2003 +++ llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Mon Dec 15 11:34:02 2003 @@ -26,6 +26,7 @@ #include "Support/Debug.h" #include "Support/Statistic.h" #include "Support/STLExtras.h" +#include using namespace llvm; namespace { @@ -206,6 +207,14 @@ PHIOps.insert(PHIOps.end(), MaybeDead->op_begin(), MaybeDead->op_end()); MaybeDead->getParent()->getInstList().erase(MaybeDead); + + // Erase any duplicates entries in the PHIOps list. + std::vector::iterator It = + std::find(PHIOps.begin(), PHIOps.end(), MaybeDead); + while (It != PHIOps.end()) { + PHIOps.erase(It); + It = std::find(PHIOps.begin(), PHIOps.end(), MaybeDead); + } // Erasing the instruction could invalidate the AfterPHI iterator! AfterPHIIt = Header->begin(); From lattner at cs.uiuc.edu Mon Dec 15 11:36:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 11:36:02 2003 Subject: [llvm-commits] [release_11] CVS: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Message-ID: <200312151735.LAA07342@zion.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/Scalar: IndVarSimplify.cpp updated: 1.44 -> 1.44.2.1 --- Log message: Merge from mainline, bugfix for PR185 --- Diffs of the changes: (+9 -0) Index: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp diff -u llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.44 llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.44.2.1 --- llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.44 Wed Dec 10 14:43:04 2003 +++ llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Mon Dec 15 11:35:09 2003 @@ -26,6 +26,7 @@ #include "Support/Debug.h" #include "Support/Statistic.h" #include "Support/STLExtras.h" +#include using namespace llvm; namespace { @@ -206,6 +207,14 @@ PHIOps.insert(PHIOps.end(), MaybeDead->op_begin(), MaybeDead->op_end()); MaybeDead->getParent()->getInstList().erase(MaybeDead); + + // Erase any duplicates entries in the PHIOps list. + std::vector::iterator It = + std::find(PHIOps.begin(), PHIOps.end(), MaybeDead); + while (It != PHIOps.end()) { + PHIOps.erase(It); + It = std::find(PHIOps.begin(), PHIOps.end(), MaybeDead); + } // Erasing the instruction could invalidate the AfterPHI iterator! AfterPHIIt = Header->begin(); From lattner at cs.uiuc.edu Mon Dec 15 11:37:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 11:37:01 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx Message-ID: <200312151736.LAA07357@zion.cs.uiuc.edu> Changes in directory llvm/test/Regression/Transforms/IndVarsSimplify: 2003-12-15-Crash.llx added (r1.1.2.1) --- Log message: merge testcase from mainline --- Diffs of the changes: (+22 -0) Index: llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx diff -c /dev/null llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx:1.1.2.1 *** /dev/null Mon Dec 15 11:36:07 2003 --- llvm/test/Regression/Transforms/IndVarsSimplify/2003-12-15-Crash.llx Mon Dec 15 11:35:57 2003 *************** *** 0 **** --- 1,22 ---- + void %_ZN17CoinFactorization7cleanupEv() { + entry: + br bool false, label %loopexit.14, label %cond_continue.3 + + cond_continue.3: ; preds = %entry + ret void + + loopexit.14: ; preds = %entry + %tmp.738 = sub int 0, 0 ; [#uses=1] + br bool false, label %no_exit.15.preheader, label %loopexit.15 + + no_exit.15.preheader: ; preds = %loopexit.14 + br label %no_exit.15 + + no_exit.15: ; preds = %no_exit.15.preheader, %no_exit.15 + %highC.0 = phi int [ %tmp.738, %no_exit.15.preheader ], [ %dec.0, %no_exit.15 ] ; [#uses=1] + %dec.0 = add int %highC.0, -1 ; [#uses=1] + br bool false, label %no_exit.15, label %loopexit.15 + + loopexit.15: ; preds = %loopexit.14, %no_exit.15 + ret void + } From lattner at cs.uiuc.edu Mon Dec 15 13:16:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 13:16:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312151915.NAA16393@zion.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.4 -> 1.5 --- Log message: Change the subject line on the llvm download email. All capitals look like spam to my filter. :) --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.4 llvm-www/releases/register.cgi:1.5 --- llvm-www/releases/register.cgi:1.4 Fri Dec 12 16:11:41 2003 +++ llvm-www/releases/register.cgi Mon Dec 15 13:15:11 2003 @@ -125,7 +125,7 @@ # Construct an email message describing the user who is downloading # LLVM. # - msg = 'Subject: [LLVM DOWNLOAD]\r\n\r\n' + msg = 'Subject: [LLVM Download]\r\n\r\n' msg = msg + 'Name: ' + firstname + ' ' + lastname + '\n' msg = msg + 'Email: ' + email + '\n' msg = msg + 'Title: ' + title + '\n' From brukman at cs.uiuc.edu Mon Dec 15 14:16:01 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Mon Dec 15 14:16:01 2003 Subject: [llvm-commits] CVS: llvm-www/header.incl Message-ID: <200312152015.OAA08082@zion.cs.uiuc.edu> Changes in directory llvm-www: header.incl updated: 1.5 -> 1.6 --- Log message: Must use absolute URLs because it's included in different levels of the tree. --- Diffs of the changes: (+6 -6) Index: llvm-www/header.incl diff -u llvm-www/header.incl:1.5 llvm-www/header.incl:1.6 --- llvm-www/header.incl:1.5 Fri Dec 12 12:23:51 2003 +++ llvm-www/header.incl Mon Dec 15 14:14:58 2003 @@ -18,12 +18,12 @@ Site Map: From lattner at cs.uiuc.edu Mon Dec 15 14:38:08 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 14:38:08 2003 Subject: [llvm-commits] CVS: llvm-www/ProjectsWithLLVM/2002-Fall-CS426-SSAPRE.pdf 2002-Fall-CS426-SSAPRE.ps Message-ID: <200312152037.OAA11530@zion.cs.uiuc.edu> Changes in directory llvm-www/ProjectsWithLLVM: 2002-Fall-CS426-SSAPRE.pdf added (r1.1) 2002-Fall-CS426-SSAPRE.ps added (r1.1) --- Log message: initial checkin of SSAPRE project --- Diffs of the changes: (+5135 -0) Index: llvm-www/ProjectsWithLLVM/2002-Fall-CS426-SSAPRE.pdf Index: llvm-www/ProjectsWithLLVM/2002-Fall-CS426-SSAPRE.ps diff -c /dev/null llvm-www/ProjectsWithLLVM/2002-Fall-CS426-SSAPRE.ps:1.1 *** /dev/null Mon Dec 15 14:37:35 2003 --- llvm-www/ProjectsWithLLVM/2002-Fall-CS426-SSAPRE.ps Mon Dec 15 14:37:24 2003 *************** *** 0 **** --- 1,5135 ---- + %!PS-Adobe-2.0 + %%Creator: dvips(k) 5.90a Copyright 2002 Radical Eye Software + %%Title: texput.dvi + %%Pages: 23 + %%PageOrder: Ascend + %%BoundingBox: 0 0 612 792 + %%EndComments + %DVIPSWebPage: (www.radicaleye.com) + %DVIPSCommandLine: dvips -t letter texput.dvi -o ssapre.ps + %DVIPSParameters: dpi=600, compressed + %DVIPSSource: TeX output 2002.12.08:1652 + %%BeginProcSet: texc.pro + %! + /TeXDict 300 dict def TeXDict begin/N{def}def/B{bind def}N/S{exch}N/X{S + N}B/A{dup}B/TR{translate}N/isls false N/vsize 11 72 mul N/hsize 8.5 72 + mul N/landplus90{false}def/@rigin{isls{[0 landplus90{1 -1}{-1 1}ifelse 0 + 0 0]concat}if 72 Resolution div 72 VResolution div neg scale isls{ + landplus90{VResolution 72 div vsize mul 0 exch}{Resolution -72 div hsize + mul 0}ifelse TR}if Resolution VResolution vsize -72 div 1 add mul TR[ + matrix currentmatrix{A A round sub abs 0.00001 lt{round}if}forall round + exch round exch]setmatrix}N/@landscape{/isls true N}B/@manualfeed{ + statusdict/manualfeed true put}B/@copies{/#copies X}B/FMat[1 0 0 -1 0 0] + N/FBB[0 0 0 0]N/nn 0 N/IEn 0 N/ctr 0 N/df-tail{/nn 8 dict N nn begin + /FontType 3 N/FontMatrix fntrx N/FontBBox FBB N string/base X array + /BitMaps X/BuildChar{CharBuilder}N/Encoding IEn N end A{/foo setfont}2 + array copy cvx N load 0 nn put/ctr 0 N[}B/sf 0 N/df{/sf 1 N/fntrx FMat N + df-tail}B/dfs{div/sf X/fntrx[sf 0 0 sf neg 0 0]N df-tail}B/E{pop nn A + definefont setfont}B/Cw{Cd A length 5 sub get}B/Ch{Cd A length 4 sub get + }B/Cx{128 Cd A length 3 sub get sub}B/Cy{Cd A length 2 sub get 127 sub} + B/Cdx{Cd A length 1 sub get}B/Ci{Cd A type/stringtype ne{ctr get/ctr ctr + 1 add N}if}B/id 0 N/rw 0 N/rc 0 N/gp 0 N/cp 0 N/G 0 N/CharBuilder{save 3 + 1 roll S A/base get 2 index get S/BitMaps get S get/Cd X pop/ctr 0 N Cdx + 0 Cx Cy Ch sub Cx Cw add Cy setcachedevice Cw Ch true[1 0 0 -1 -.1 Cx + sub Cy .1 sub]/id Ci N/rw Cw 7 add 8 idiv string N/rc 0 N/gp 0 N/cp 0 N{ + rc 0 ne{rc 1 sub/rc X rw}{G}ifelse}imagemask restore}B/G{{id gp get/gp + gp 1 add N A 18 mod S 18 idiv pl S get exec}loop}B/adv{cp add/cp X}B + /chg{rw cp id gp 4 index getinterval putinterval A gp add/gp X adv}B/nd{ + /cp 0 N rw exit}B/lsh{rw cp 2 copy get A 0 eq{pop 1}{A 255 eq{pop 254}{ + A A add 255 and S 1 and or}ifelse}ifelse put 1 adv}B/rsh{rw cp 2 copy + get A 0 eq{pop 128}{A 255 eq{pop 127}{A 2 idiv S 128 and or}ifelse} + ifelse put 1 adv}B/clr{rw cp 2 index string putinterval adv}B/set{rw cp + fillstr 0 4 index getinterval putinterval adv}B/fillstr 18 string 0 1 17 + {2 copy 255 put pop}for N/pl[{adv 1 chg}{adv 1 chg nd}{1 add chg}{1 add + chg nd}{adv lsh}{adv lsh nd}{adv rsh}{adv rsh nd}{1 add adv}{/rc X nd}{ + 1 add set}{1 add clr}{adv 2 chg}{adv 2 chg nd}{pop nd}]A{bind pop} + forall N/D{/cc X A type/stringtype ne{]}if nn/base get cc ctr put nn + /BitMaps get S ctr S sf 1 ne{A A length 1 sub A 2 index S get sf div put + }if put/ctr ctr 1 add N}B/I{cc 1 add D}B/bop{userdict/bop-hook known{ + bop-hook}if/SI save N @rigin 0 0 moveto/V matrix currentmatrix A 1 get A + mul exch 0 get A mul add .99 lt{/QV}{/RV}ifelse load def pop pop}N/eop{ + SI restore userdict/eop-hook known{eop-hook}if showpage}N/@start{ + userdict/start-hook known{start-hook}if pop/VResolution X/Resolution X + 1000 div/DVImag X/IEn 256 array N 2 string 0 1 255{IEn S A 360 add 36 4 + index cvrs cvn put}for pop 65781.76 div/vsize X 65781.76 div/hsize X}N + /p{show}N/RMat[1 0 0 -1 0 0]N/BDot 260 string N/Rx 0 N/Ry 0 N/V{}B/RV/v{ + /Ry X/Rx X V}B statusdict begin/product where{pop false[(Display)(NeXT) + (LaserWriter 16/600)]{A length product length le{A length product exch 0 + exch getinterval eq{pop true exit}if}{pop}ifelse}forall}{false}ifelse + end{{gsave TR -.1 .1 TR 1 1 scale Rx Ry false RMat{BDot}imagemask + grestore}}{{gsave TR -.1 .1 TR Rx Ry scale 1 1 false RMat{BDot} + imagemask grestore}}ifelse B/QV{gsave newpath transform round exch round + exch itransform moveto Rx 0 rlineto 0 Ry neg rlineto Rx neg 0 rlineto + fill grestore}B/a{moveto}B/delta 0 N/tail{A/delta X 0 rmoveto}B/M{S p + delta add tail}B/b{S p tail}B/c{-4 M}B/d{-3 M}B/e{-2 M}B/f{-1 M}B/g{0 M} + B/h{1 M}B/i{2 M}B/j{3 M}B/k{4 M}B/w{0 rmoveto}B/l{p -4 w}B/m{p -3 w}B/n{ + p -2 w}B/o{p -1 w}B/q{p 1 w}B/r{p 2 w}B/s{p 3 w}B/t{p 4 w}B/x{0 S + rmoveto}B/y{3 2 roll p a}B/bos{/SS save N}B/eos{SS restore}B end + + %%EndProcSet + %%BeginProcSet: special.pro + %! + TeXDict begin/SDict 200 dict N SDict begin/@SpecialDefaults{/hs 612 N + /vs 792 N/ho 0 N/vo 0 N/hsc 1 N/vsc 1 N/ang 0 N/CLIP 0 N/rwiSeen false N + /rhiSeen false N/letter{}N/note{}N/a4{}N/legal{}N}B/@scaleunit 100 N + /@hscale{@scaleunit div/hsc X}B/@vscale{@scaleunit div/vsc X}B/@hsize{ + /hs X/CLIP 1 N}B/@vsize{/vs X/CLIP 1 N}B/@clip{/CLIP 2 N}B/@hoffset{/ho + X}B/@voffset{/vo X}B/@angle{/ang X}B/@rwi{10 div/rwi X/rwiSeen true N}B + /@rhi{10 div/rhi X/rhiSeen true N}B/@llx{/llx X}B/@lly{/lly X}B/@urx{ + /urx X}B/@ury{/ury X}B/magscale true def end/@MacSetUp{userdict/md known + {userdict/md get type/dicttype eq{userdict begin md length 10 add md + maxlength ge{/md md dup length 20 add dict copy def}if end md begin + /letter{}N/note{}N/legal{}N/od{txpose 1 0 mtx defaultmatrix dtransform S + atan/pa X newpath clippath mark{transform{itransform moveto}}{transform{ + itransform lineto}}{6 -2 roll transform 6 -2 roll transform 6 -2 roll + transform{itransform 6 2 roll itransform 6 2 roll itransform 6 2 roll + curveto}}{{closepath}}pathforall newpath counttomark array astore/gc xdf + pop ct 39 0 put 10 fz 0 fs 2 F/|______Courier fnt invertflag{PaintBlack} + if}N/txpose{pxs pys scale ppr aload pop por{noflips{pop S neg S TR pop 1 + -1 scale}if xflip yflip and{pop S neg S TR 180 rotate 1 -1 scale ppr 3 + get ppr 1 get neg sub neg ppr 2 get ppr 0 get neg sub neg TR}if xflip + yflip not and{pop S neg S TR pop 180 rotate ppr 3 get ppr 1 get neg sub + neg 0 TR}if yflip xflip not and{ppr 1 get neg ppr 0 get neg TR}if}{ + noflips{TR pop pop 270 rotate 1 -1 scale}if xflip yflip and{TR pop pop + 90 rotate 1 -1 scale ppr 3 get ppr 1 get neg sub neg ppr 2 get ppr 0 get + neg sub neg TR}if xflip yflip not and{TR pop pop 90 rotate ppr 3 get ppr + 1 get neg sub neg 0 TR}if yflip xflip not and{TR pop pop 270 rotate ppr + 2 get ppr 0 get neg sub neg 0 S TR}if}ifelse scaleby96{ppr aload pop 4 + -1 roll add 2 div 3 1 roll add 2 div 2 copy TR .96 dup scale neg S neg S + TR}if}N/cp{pop pop showpage pm restore}N end}if}if}N/normalscale{ + Resolution 72 div VResolution 72 div neg scale magscale{DVImag dup scale + }if 0 setgray}N/psfts{S 65781.76 div N}N/startTexFig{/psf$SavedState + save N userdict maxlength dict begin/magscale true def normalscale + currentpoint TR/psf$ury psfts/psf$urx psfts/psf$lly psfts/psf$llx psfts + /psf$y psfts/psf$x psfts currentpoint/psf$cy X/psf$cx X/psf$sx psf$x + psf$urx psf$llx sub div N/psf$sy psf$y psf$ury psf$lly sub div N psf$sx + psf$sy scale psf$cx psf$sx div psf$llx sub psf$cy psf$sy div psf$ury sub + TR/showpage{}N/erasepage{}N/setpagedevice{pop}N/copypage{}N/p 3 def + @MacSetUp}N/doclip{psf$llx psf$lly psf$urx psf$ury currentpoint 6 2 roll + newpath 4 copy 4 2 roll moveto 6 -1 roll S lineto S lineto S lineto + closepath clip newpath moveto}N/endTexFig{end psf$SavedState restore}N + /@beginspecial{SDict begin/SpecialSave save N gsave normalscale + currentpoint TR @SpecialDefaults count/ocount X/dcount countdictstack N} + N/@setspecial{CLIP 1 eq{newpath 0 0 moveto hs 0 rlineto 0 vs rlineto hs + neg 0 rlineto closepath clip}if ho vo TR hsc vsc scale ang rotate + rwiSeen{rwi urx llx sub div rhiSeen{rhi ury lly sub div}{dup}ifelse + scale llx neg lly neg TR}{rhiSeen{rhi ury lly sub div dup scale llx neg + lly neg TR}if}ifelse CLIP 2 eq{newpath llx lly moveto urx lly lineto urx + ury lineto llx ury lineto closepath clip}if/showpage{}N/erasepage{}N + /setpagedevice{pop}N/copypage{}N newpath}N/@endspecial{count ocount sub{ + pop}repeat countdictstack dcount sub{end}repeat grestore SpecialSave + restore end}N/@defspecial{SDict begin}N/@fedspecial{end}B/li{lineto}B + /rl{rlineto}B/rc{rcurveto}B/np{/SaveX currentpoint/SaveY X N 1 + setlinecap newpath}N/st{stroke SaveX SaveY moveto}N/fil{fill SaveX SaveY + moveto}N/ellipse{/endangle X/startangle X/yrad X/xrad X/savematrix + matrix currentmatrix N TR xrad yrad scale 0 0 1 startangle endangle arc + savematrix setmatrix}N end + + %%EndProcSet + TeXDict begin 40258431 52099146 1000 600 600 (texput.dvi) + @start + %DVIPSBitmapFont: Fa ecbi1440 14.4 5 + /Fa 5 117 df<020FB712F84A82A361DA000301FCC8FCA25FA25DA25FA25DA25FA25DA2 + 5FA25DA25FA25DA294C9FCA292B5FCA25EA25CA25EA25CA25EA25CA25EA25CA25EA24A17 + 7C1AFC5E19014A17F8A24C14031AF04A1607A293C8EA0FE0A291B5151F1AC04B153FA249 + EF7F8019FF4B4A130060495E4E5A4B143F18FF4903035B171F007FB9FC61BAFCA26C6046 + 507ACF4F>76 D97 + D101 D114 + D116 + D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fb eccc1000 10 39 + /Fb 39 253 df<121C127FEAFF80A213C0A3127F121C1200A412011380A2120313005A12 + 06120E5A5A5A12600A1977881B>44 D<121C127FEAFF80A5EA7F00121C090977881B>46 + D66 + DI69 DI<011FB512F0A390 + 39000FFE00EC03FCB3B3A3123FEA7F80EAFFC0A44A5A1380D87F005B0070130F6C495A6C + 5C6C49C7FC3807C0FE3801FFF838003FC0243B7CB82F>74 DIII<913801 + FFC0020F13F891387F80FF903A01FC001FC0D903F0EB07E0D90FC0EB01F849486D7E49C8 + 127E017E81496F7E00018348486F7EA248486F7E000F83491503001F83A248486F7EA300 + 7F834981A300FF1880AB007F18006D5DA3003F5FA26D1503001F5FA26C6C4B5AA200075F + 6D150F6C6C4B5A00015F6C6C4B5A017F4BC7FC6D6C14FE6D6C495A6D6C495AD903F0EB07 + E0D901FCEB1FC09027007F80FFC8FC91380FFFF8020113C0393D7ABA46>79 + DI82 + DI<003FB812FCA3D9C001EB800390C790C7FC007C173E0078171E0070170EA30060 + 1706A400E01707481703A4C81500B3B0020313C0010FB612F0A338397CB841>I87 D<003FB712E0A301FCC7EA7FC013E00180ECFF8090C7481300123E003C4A + 5A00384A5A127800704A5A4B5AA24B5A0060147F5E4B5A5CC791C7FC4A5AA24A5A4A5AA2 + 4A5A4A5AA24A5A4A5AA24990C8FC495AA2495A49481430A2495A133F5C495A01FF15705C + 4890C8FCA2484815F0484815E0A2484814014848140316074848140F4848143FED01FFB8 + FCA32C397AB838>90 D<1407A24A7EA34A7EA3EC37E0A2EC77F01463A2ECC1F8A201017F + 1480A2903803007EA301067FA2010E80010C131FA2496D7EA2013FB57EA2903830000749 + 6D7EA3496D7EA200018149130012036D801207D81FE0903801FF80D8FFF8010F13F8A22D + 2C7DAB33>97 D<91383FC006903901FFF80E90390FE03E1E90381F0007017EEB03BE01F8 + EB01FE484813004848147E0007153E485A001F151E5B003F150E90C8FC5A1606A212FE16 + 00AA007F1506A37E6D140E001F150C7F000F151C6C6C1418000315386C6C14706C6C14E0 + 017EEB01C0011FEB078090390FE03E00903801FFF89038003FC0272D7BAB31>99 + DIII<91383FE003903901FFF807903907E01E0F90391F00078F017E + EB01DF496DB4FC484880484880484880485A001F815B003F8190C8FC5A82A212FE93C7FC + A892383FFFF8A2007F02001380EE3F00A27E7F121F7F120F6C7E6C7E6C6C5C6C7E017E5C + 011FEB01CF903907E00F87903901FFFE039026003FF0C7FC2D2D7BAB35>III107 DIIIII114 + D<017F13603901FFE0E0380780F9380E001F48130748130312780070130100F01300A315 + 607EA26C14007E127F13C0EA3FFEEBFFE06C13F8000713FE6C7FC61480010F13C01300EC + 0FE01407EC03F01401A212C01400A37E15E06C1301A26CEB03C06CEB0780B4EB0F0038F3 + E01E38E0FFF838C01FE01C2D7BAB26>I<007FB712C0A23A7E003FC00F007890381F8003 + 007015011600126000E016E0A2481660A5C71500B3A8EC7FE0011FB57EA22B2B7DAA31> + II< + B56CEB3FFEA2D80FFCC7EA0FF06C48EC07E00003ED03C01780000116006D5C00001506A2 + 017E5CA2017F141C6D141880011F5CA26D6C5BA28001075CA26D6C485AA2ECF803010191 + C7FCA2903800FC06A2ECFE0EEC7E0C147F6E5AA2EC1FB0A215F06E5AA26E5AA36E5AA22F + 2C7EAA33>II + 121 D<903807803C90380FE0FE011F7F14F1A314E0010F5B903807803C90CAFCA4B539C0 + 07FFE0A2D807F8C713006C48143CA21618B3A916386C6C1430A2000015706D5C017C5C6D + 13016D495A90260F800FC7FC903803E03C903800FFF8EC3FC02B397CB733>252 + D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fc cmr8 8 1 + /Fc 1 44 df43 + D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fd cmr6 6 5 + /Fd 5 58 df<13FF000313C0380781E0380F00F0001E137848133CA248131EA400F8131F + AD0078131EA2007C133E003C133CA26C13786C13F0380781E03803FFC0C6130018227DA0 + 1E>48 D<13E01201120712FF12F91201B3A7487EB512C0A212217AA01E>I<14E01301A2 + 13031307A2130D131D13391331136113E113C1EA01811203EA07011206120C121C121812 + 30127012E0B6FCA2380001E0A6EB03F0EB3FFFA218227DA11E>52 + D<00101330381E01F0381FFFE014C01480EBFE00EA1BF00018C7FCA513FE381BFF80381F + 03C0381C01E0381800F014F8C71278A2147CA21230127812F8A214784813F8006013F038 + 7001E01238381E07803807FF00EA01F816227CA01E>I<13FE3803FFC0380781E0380E00 + 70481378003C133848133CA200F8131EA3141FA40078133FA26C137F121C380F01DF3807 + FF9F3803FE1EC7FCA2143E143C001C1338003E13781470003C13E0381801C0381C078038 + 0FFE00EA03F818227DA01E>57 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fe cmmi8 8 2 + /Fe 2 99 df97 + D<13F8121FA21201A25BA21203A25BA21207A25BA2120FEBC7E0EB9FF8EBB83C381FF01E + EBE01F13C09038800F80EA3F00A2123EA2007E131FA2127CA2143F00FC14005AA2147EA2 + 147C14FC5C387801F01303495A383C0F806C48C7FCEA0FFCEA03F0192F7DAD1E>I + E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Ff ecrm0800 8 39 + /Ff 39 123 df<14FF010713E090381F80F090383E003849137C4913FC485A1203491378 + 153092C7FCA7157CB612FCA23803E000157CB3A5486C13FE3A7FFF0FFFE0A2232F7FAE27 + >28 D<123C127EB4FCA21380A2127F123D1201A312031300A25A1206120E5A5A5A126009 + 157AAD14>39 D<123C127EB4FCA21380A2127F123D1201A312031300A25A1206120E5A5A + 5A126009157A8714>44 DI<123C127E12FFA4127E123C08087A + 8714>I50 D<123C127EB4FCA4127E123CC7FCAD123C127EB4FCA21380A2127F + 123D1201A312031300A25A1206120E5A5A5A1260092A7A9C14>59 + D<4A7E4A7EA34A7EA24A7EA3EC1BF81419A2EC30FCA2EC70FEEC607EA24A7EA349486C7E + A2010380EC000FA201066D7EA3496D7EA2011FB57EA29038180001496D7EA349147EA201 + E0147F4980A20001ED1F801203000716C0D80FF0EC3FE0D8FFFC0103B5FCA2302F7EAE35 + >65 D69 D73 D80 D + 82 D<90383F80303901FFF0703807C07C390F000EF0001E130748130348130114001270 + 00F01470A315307EA26C1400127E127FEA3FE013FE381FFFE06C13FC6C13FF00011480D8 + 003F13E013039038003FF0EC07F81401140015FC157C12C0153CA37EA215787E6C14706C + 14F06CEB01E039F78003C039E3F00F0038E07FFE38C00FF01E2F7CAD27>I<007FB712F8 + A29039000FC003007C150000701638A200601618A200E0161CA248160CA5C71500B3A94A + 7E011FB512E0A22E2D7EAC33>I87 D<13FF000713C0380F01F038 + 1C00F8003F137C80A2143F001E7FC7FCA4EB07FF137F3801FE1FEA07F0EA1FC0EA3F80EA + 7F00127E00FE14065AA3143F7E007E137F007FEBEF8C391F83C7FC390FFF03F83901FC01 + E01F207D9E23>97 DII<15F8141FA214011400ACEB0FE0EB7FF83801F81E3803E0073807C003380F8001EA + 1F00481300123E127EA25AA9127C127EA2003E13017EEB8003000F13073903E00EFC3A01 + F03CFFC038007FF090391FC0F800222F7EAD27>III<013F13F89038FFC3FE3903E1FF1E3807807C000F14 + 0C391F003E00A2003E7FA76C133EA26C6C5A00071378380FE1F0380CFFC0D81C3FC7FC90 + C8FCA3121E121F380FFFF814FF6C14C04814F0391E0007F848130048147C12F848143CA4 + 6C147C007C14F86CEB01F06CEB03E03907E01F803901FFFE0038003FF01F2D7E9D23>I< + EA07C012FFA2120F1207AC14FE9038C3FF809038C703E09038DE01F013F8496C7EA25BA2 + 5BB2486C487E3AFFFE1FFFC0A2222E7EAD27>II107 DI<2607C07FEB + 07F03BFFC3FFC03FFC903AC783F0783F3C0FCE01F8E01F803B07DC00F9C00F01F8D9FF80 + 13C04990387F000749137EA249137CB2486C01FEEB0FE03CFFFE0FFFE0FFFEA2371E7E9D + 3C>I<3807C0FE39FFC3FF809038C703E0390FDE01F0EA07F8496C7EA25BA25BB2486C48 + 7E3AFFFE1FFFC0A2221E7E9D27>II<3807C0FE39FF + C7FF809038CF03E0390FDC01F03907F800FC49137E49133E49133FED1F80A3ED0FC0A815 + 1F1680A2ED3F00A26D137E6D137C5D9038FC01F09038CE07E09038C7FF80D9C1FCC7FC01 + C0C8FCA9487EEAFFFEA2222B7E9D27>I<380781F038FF87FCEB9E7EEA0F98EA07B813B0 + EBF03CEBE000A35BB1487EB5FCA2171E7E9D1B>114 D<3801FE183807FFB8381E01F8EA + 3C00481378481338A21418A27E7EB41300EA7FF06CB4FC6C13C06C13F0000113F838001F + FC130138C0007E143EA26C131EA27EA26C133CA26C137838FF01F038E3FFC000C0130017 + 207E9E1C>I<1360A413E0A312011203A21207121FB512F0A23803E000AF1418A7143838 + 01F03014703800F860EB3FE0EB0F80152A7FA81B>II<3AFFFC01FFC0A23A0FE0007E000007147C15380003143015706C6C1360A26C6C + 5BA390387C0180A26D48C7FCA2EB3F07EB1F06A2EB0F8CA214DCEB07D8A2EB03F0A36D5A + A26D5A221E7F9C25>I<3BFFFC3FFE07FFA23B0FE003F001F801C09038E000F000070101 + 14E0812603E00314C0A2913807F8012701F006781380A29039F80E7C030000D90C3C1300 + A290397C181E06A2151F6D486C5AA2168C90391F600798A216D890390FC003F0A36D486C + 5AA36DC75A301E7F9C33>I<3AFFFC07FF80A23A0FF003FC000003EB01F0000114C06D48 + 5A000091C7FCEB7C06EB3E0E6D5A14B8EB0FB0EB07E013036D7E497E1307EB067C497EEB + 1C1F01387FEB700F496C7E6E7ED803C07F00076D7E391FE003FC3AFFF007FFC0A2221D7F + 9C25>I<3AFFFC01FFC0A23A0FE0007E000007147C1538000314306D137000011460A26C + 6C5BA2EBFC01017C5BEB7E03013E90C7FCA2EB1F06A2148EEB0F8CA2EB07D8A2EB03F0A3 + 6D5AA26D5AA2495AA2130391C8FC1278EAFC06A25B131CEA7838EA7070EA3FE0EA0F8022 + 2B7F9C25>I<003FB51280A2EB003F003C14000038137E00305BEA700100605B495A495A + 130F00005B495A49C7FC5B137E9038FC0180EA01F8120313F03807E003EA0FC0001F1400 + 138048485A007E5B00FE133FB6FCA2191D7E9C1F>I E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fg ecrm0600 6 5 + /Fg 5 54 df<13E01201120712FF12F91201B3A7487EB512C0A212217AA01E>49 + DI<13FF000313C0380F03E0381C00F014F800 + 3E13FC147CA2001E13FC120CC712F8A2EB01F0EB03E0EB0FC03801FF00A2380003E0EB00 + F01478147C143E143F1230127812FCA2143E48137E0060137C003813F8381E03F0380FFF + C00001130018227DA01E>I<14E01301A213031307A2130D131D13391331136113E113C1 + EA01811203EA07011206120C121C12181230127012E0B6FCA2380001E0A6EB03F0EB3FFF + A218227DA11E>I<00101330381E01F0381FFFE014C01480EBFE00EA1BF00018C7FCA513 + FE381BFF80381F03C0381C01E0381800F014F8C71278A2147CA21230127812F8A2147848 + 13F8006013F0387001E01238381E07803807FF00EA01F816227CA01E>I + E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fh ecbi1000 10 26 + /Fh 26 123 df<173E177FA25F5EA25EA25E5E845EA25E5EA293B5FCA2ED01F7150304E7 + 7FED07C7ED0FC31683151F1603153E157E157C03FC8015F8EC01F002037F15E0140715C0 + EC0F80141F15004A8192B6FC5C91B7FCA2D901F0C7FCA2495A13075C494881A249C8127F + 5B133E48B4FC007F01F8017FB512F06E16F8B54816F07E3D3B7ABA48>65 + D<0103B712F04916FEF0FF8019E0D9000790C713F0187FF03FF84A151F4B15FCA3141F5D + A3023FED3FF85D19F0187F027FEDFFE05D4D13C04D138002FF913807FE004BEB1FFCEFFF + F092B612C0495E18F09239C0001FF8717E496F7E4B6D7E1980A25B92C7FCA35B5C5FA201 + 1F17004A5C60171F013F5E4A4A5A177F4D5A017F02035B4A010F1380B9C7FC17FC17F094 + C8FC3E3979B844>II<0103B712E04916FE727E19E0D90007 + D980037F9438007FF8F01FFC4A6F7E93C71207727EA24A6F13805D1AC0A2023F815DA302 + 7F5D5DA314FF5D60A24918805D60A24918005D60615B4B4A5AA26149163F92C85B187F61 + 494C5A4A4A5BA24D90C7FC013F4B5A4AEC1FFC4D5AEFFFE0017F02035B4A011F90C8FCB8 + 12FC17F0178004F8C9FC423979B849>I<0103B812C04917E0A3D90007EB80019438007F + C0181F5C93C7120FA35C4B1580A3143F4B13F017F81601027F160003F849C7FCA2160302 + FF13074B485A163F92B5FC5B5FA2EDE03F49141F03C05B160F161F5B038090C8FCA34914 + 1E92CAFCA35B5CA3133F5CA3137F5CB612FE815DA23B397AB83C>70 + D<0103B612E017F0A217E0D90003EBC000A35C5EA35C93C7FCA35C5DA3143F5DA3147F5D + A314FF5DA35B5DA35B5DA35B5DA35B92C8FCA35B5CA3133F5C007FB512FC81B65A7E2C39 + 7BB827>73 D<0103B500C0030FB51280496E4B14C0621D80D900074D90C7FC97B5FC824A + 5E03BF923803EFFEA2F107DF141F033F92380F9FFCF11F1F6F6C153F023F163E023E047C + 5BA2F1F87F147E027CDB01F05BF003E06F6C15FF02FC4B5A02F84B485BA2F01F01130102 + F0033E5C6F6C137C61010316F802E0DA01F05CA24D485A0107ED07C002C095C8FC923903 + FF0F8061010FED1F000280023E5CA24D131F011F5D02005F6F5B193F495D013E4B5CA24D + 137F017E92C7FCD801FE60B526FC00FE90B612F0A25E5E5A3979B859>77 + D<0103B7FC4916F018FC18FFD90007D9800F1380050113C07113E04AED7FF093C7FCA219 + F85C5DA3023FEDFFF05DA219E0027F5C4B15C04D1380190002FF4A5A4BEB1FFCEF3FF04C + B45A4990B6C7FC17FC839238E00FFF4902037F4B6C7F848249825DA25E495E1500A25E5B + 4A5DA3013F4A141C4AED803EA2197E017F177C4A7FB600F815F870EB81F070EBC3E09438 + 7FFFC0CA001F1380943803FE003F3B79B847>82 DI<007FB500E0B639C01FFFFE6F6F5AB612E16C02E003C014FC00019026E0 + 000301C0C71380F37E001B7C1BFC6E6F5C505A6C6F1503634C1507634C4B5AA24C4BC7FC + 4C5D1A3E4C5D6E81047D5D017F02FC14014C5D030115034C5D4B484A5A15074C4A5A030F + 151F4C92C8FC6E4848EBF83EA2033E017F5B013F017E15FC037C5D4B14F961DAFDF0ECFB + E002FF15FF4B5DA24B5D4B92C9FCA26D90C76C5AA24A5D4A5DA24A5DA24A5DA24A5D4A5D + A26D486ECAFC573A6EB860>87 D97 + D100 DI<167E923803FFC04B13E092381FE3F092383FC7F816CFED7F9FA215FF17F0 + 5CEE1FE0EE078093C7FCA25C5DA414075D011FB6128017C01780A29026000FF8C7FCA514 + 1F5DA4143F5DA4147FA25DA414FF5DA45B92C8FCA4495AA45C1307120F383F87F8EA7FC7 + EAFFCF5CA2EB8FE0EB9FC0EB1F80D8FC3FC9FCEA7FFEEA1FF8EA07E02D4C81BA21>I<14 + 3C147F495A15805B1500A25C6D5AEB007091C7FCAB133FEBFFC000037F3807C7F0380F87 + F8EA1F07A2EA3E0FA2127C131F5C12FCEAF83F00005B137F5CA213FF5CA25A91C7FC5A5B + EC0F801207EBFC1F1500120F495A143E5C13F000075BEBF1F06CB45AC65B013EC7FC193C + 79BA1E>105 D108 + DIII<01FCEB7F80 + 3A03FF01FFF04801C713FC3A0F9FEFC0FE3A1F0FFF003F4A13FF003E495A131F4A5A007C + 13F0A216FED8FC3FEB01FC00F89038E000F000001500A2137F5CA313FF5CA35A91C8FCA3 + 5A5BA312075BA35B5BEA01E0282779A52A>114 DI<14F0EB03F8130780495AA3131FA25CA2133FA25CA2137FA2B612 + 8015C0A21580C6EB8000A25AA291C7FCA25AA25BA21207A25BA2120FA25BA2121FA29038 + F007C0A2003F130F1580EBE01F1500143E147EEBC07C6C6C5A380FE3F0EBFFE000031380 + C648C7FC1A3778B520>I<017EEB01E03A01FF8003F8489038E007FC3907C7F00FD80F87 + EB1FFEEA1F0F14F8123E150F397C1FF0071503013F130100FC9038E000FC12F8EA007F5C + 16F813FF5C15014815F01400A2ED03E05A5BED07C0A2ED0F80A2ED1F00151E0001143E6D + 5B6C5C90387F81F06DB45A010F1380D901FEC7FC272779A52C>118 + D<013F161ED9FFC0011EEB7F80000301F090393F80FFC02607E7F8137FD80F83DAFF8113 + E01387381F07FC003E5C1700D87E0F167F007C01F8153F011F49141F00FC01F049EB0FC0 + 12F8EA003FECE0074C1480137F14C0030F141F01FF4A14001480A26048021F143E02005B + 60A360A2033F495A6C5F9139807FF803017F01FF495A903B3FC1FBFC0F8090261FFFF1B5 + C7FC01079038C07FFC01009038000FF03B2779A540>I<133FD9FFC0130F000301F0EB1F + C02607E7F8133FD80F83147F1387381F07FC003E15FF1780EA7E0F007C5B011F5B00FC01 + F0140012F8EA003F4A5A5E137F14C0150701FF5C1480A2150F485D1400A2151F5EA3153F + 5E6C147FEC80FFEB7F836DB55A130F903801FC7F90C712FF5EEA03C0260FF00190C7FC12 + 1F003F495AA24A5A4A5A01E05B49485A9038007F80261FC0FFC8FC380FFFFC000313F0C6 + 13802A3779A52F>121 D<02FC131FEB03FF010FEB803F49EBC07E49EBE07C49EBF8FC90 + B612F816F04815E09039F8000FC049EB1F80C8EA3F00157E5D4A5A4A5A4A5AEC1FC04AC7 + FC147E5C495A495AEB0FE0EB1F8049C7127C137E4914FC4848EB01F84848130748B612F0 + 5A16E0D81F8314C0D83F011480D87E001400007CEB3FFE00FCEB1FF848EB07E028277BA5 + 29>I E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fi ecrm0700 7 5 + /Fi 5 54 df<13381378EA01F8121F12FE12E01200B3AB487EB512F8A215267BA521>49 + D<13FF000313E0380E03F0381800F848137C48137E00787F12FC6CEB1F80A4127CC7FC15 + 005C143E147E147C5C495A495A5C495A010EC7FC5B5B903870018013E0EA018039030003 + 0012065A001FB5FC5A485BB5FCA219267DA521>I<13FF000313E0380F01F8381C007C00 + 30137E003C133E007E133FA4123CC7123E147E147C5C495AEB07E03801FF8091C7FC3800 + 01E06D7E147C80143F801580A21238127C12FEA21500485B0078133E00705B6C5B381F01 + F03807FFC0C690C7FC19277DA521>I<1438A2147814F81301A2130313071306130C131C + 131813301370136013C012011380EA03005A120E120C121C5A12305A12E0B612E0A2C7EA + F800A7497E90383FFFE0A21B277EA621>I<0018130C001F137CEBFFF85C5C1480D819FC + C7FC0018C8FCA7137F3819FFE0381F81F0381E0078001C7F0018133EC7FC80A21580A212 + 30127C12FCA3150012F00060133E127000305B001C5B380F03E03803FFC0C648C7FC1927 + 7DA521>I E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fj ecbx1000 10 19 + /Fj 19 118 df46 D<141E143E14FE1307137FB5FCA3138FEA000FB3B3A5007FB61280A4213679B530> + 49 DIII<001C15C0D81F80130701F8137F90 + B61280A216005D5D15F05D15804AC7FC14F090C9FCA7EB03FE90381FFFE0017F13F89038 + FE07FC9038F003FFD9C0011380496C13C090C7FC000E15E0C8127F16F0A216F8A3121FEA + 3FC0487E12FF7FA316F05B15FFD87F8014E0007EC713C0003E5B003F4913806C6C481300 + 390FF01FFE6CB512F8000114E06C6C1380D90FF8C7FC25377BB530>II<123C123EEA3FE090B71280A41700485D5E5E5E5EA200 + 7CC7EA0FC000784A5A4BC7FC00F8147E485C5D14014A5AC7485A4A5AA24A5A143F4AC8FC + A214FEA213015C1303A21307A2130F5CA2131FA5133FA96D5A6D5A6D5A29397BB730>I< + DB3FFCEB01C00203B5EAC003021FECF00791B6EAFC0F01039039FC00FF3F4901C0EB1FFF + D91FFEC77E49481403D97FF080494880485B48177F4849153F4890C9FC181F485A180F12 + 3F5B1807127FA24993C7FC12FFAD127F7FF003C0123FA27F001F1707A26C6C1780180F6C + 6D16006C6D5D6C173E6C6D157ED97FF85D6D6C4A5A6DB44A5A010701C0EB0FE06D01FCEB + FF80010090B548C7FC021F14F8020314E09126003FFEC8FC3A3B7BB945>67 + D79 + D<903801FFC0010F13FC017F13FFD9FF8013802603FE0013C048485AEA0FF8121F13F012 + 3F6E13804848EB7F00151C92C7FC12FFA9127FA27F123FED01E06C7E15036C6CEB07C06C + 6C14806C6C131FC69038C07E006DB45A010F13F00101138023257DA42A>99 + D<903803FF80011F13F0017F13FC3901FF83FE3A03FE007F804848133F484814C0001FEC + 1FE05B003FEC0FF0A2485A16F8150712FFA290B6FCA301E0C8FCA4127FA36C7E1678121F + 6C6C14F86D14F000071403D801FFEB0FE06C9038C07FC06DB51200010F13FC010113E025 + 257DA42C>101 D<13FFB5FCA412077EB3B3ACB512FCA4163A7DB91B>108 + D<01FEEB7FC000FF903803FFF8020F13FE91381F03FFDA3C011380000713780003497E6D + 4814C05CA25CA291C7FCB3A3B5D8FC3F13FFA430257DA435>110 + D<903801FFC0010F13F8017F13FFD9FF807F3A03FE003FE048486D7E48486D7E48486D7E + A2003F81491303007F81A300FF1680A9007F1600A3003F5D6D1307001F5DA26C6C495A6C + 6C495A6C6C495A6C6C6CB45A6C6CB5C7FC011F13FC010113C029257DA430>I<9038FE03 + F000FFEB0FFEEC3FFF91387C7F809138F8FFC000075B6C6C5A5CA29138807F80ED3F0015 + 0C92C7FC91C8FCB3A2B512FEA422257EA427>114 D<90383FF0383903FFFEF8000F13FF + 381FC00F383F0003007E1301007C130012FC15787E7E6D130013FCEBFFE06C13FCECFF80 + 6C14C06C14F06C14F81203C614FC131F9038007FFE140700F0130114007E157E7E157C6C + 14FC6C14F8EB80019038F007F090B512C000F8140038E01FF81F257DA426>I<130FA55B + A45BA25B5BA25A1207001FEBFFE0B6FCA3000390C7FCB21578A815F86CEB80F014816CEB + C3E090383FFFC06D1380903803FE001D357EB425>I<01FFEC3FC0B5EB3FFFA400071401 + 6C80B3A35DA25DA26C5C6E4813E06CD9C03E13FF90387FFFFC011F13F00103138030257D + A435>I E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fk ectt1000 10 78 + /Fk 78 126 df<121FEA3F80EA7FC0EAFFE0B0EA7FC0AEEA1F00C7FCA7121FEA3F80EA7F + C0EAFFE0A5EA7FC0EA3F80EA1F000B3470B32C>33 D<003C131E007F137F481480A66C14 + 00A6007E7FA6003E133EA3003C131E001C131C191977B32C>I<0107131C90380F803EA8 + 011F137EEC007CA4003FB612E0B712F8A43A003E00F800A2EB7E01017C5BA8EBFC0301F8 + 5BA2B712F8A4003F15E03A01F007C000A30003130F01E05BA86C486CC7FC25337DB22C> + I37 + D39 + D<143814FC13011303EB07F8EB0FF0EB1FC0EB3F80EB7F0013FE485A485A5B12075B120F + 5B485AA2123F90C7FCA25A127EA312FE5AAC7E127EA3127F7EA27F121FA26C7E7F12077F + 12037F6C7E6C7E137FEB3F80EB1FC0EB0FF0EB07F8EB03FC130113001438164272B92C> + I<127012FC7E7E6C7E6C7EEA0FE06C7E6C7E6C7E6C7E137F7F1480131F14C0130FEB07E0 + A214F01303A214F81301A314FC1300AC130114F8A3130314F0A2130714E0A2EB0FC0131F + 1480133F14005B13FE485A485A485A485AEA3FC0485A48C7FC5A5A1270164279B92C>I< + EB0380497EA60020140800F8143E00FE14FE00FF13C1EBC7C7EBE7CF003FB512F8000F14 + E0000314806C140038007FFCA248B5FC481480000F14E0003F14F839FFE7CFFEEBC7C7EB + 07C100FE13C000F8143E0020140800001400A66D5A1F247AAA2C>I<147014F8AF003FB6 + 12E0B712F8A4C700F8C7FCB0147025267DAB2C>II<007FB512F0B612F8A36C14F01D0579942C>I<121FEA3F80EA7FC0EAFFE0A5EA + 7FC0EA3F80EA1F000B0B708A2C>I48 + D<1307497EA2131FA2133F137F13FF5A1207127FB5FC13DF139FEA7C1F1200B3AE007FB5 + 12E0B612F0A36C14E01C3477B32C>IIII<000FB512FE4880A35D0180C8FCADEB83FE90389FFF8090B512E015F8819038 + FE03FE9038F000FF01C07F49EB3F8090C7121F6C15C0C8120FA2ED07E0A4123C127EB4FC + 150F16C0A248141F007EEC3F80007FEC7F006C6C5B6D485A391FF80FFC6CB55A6C5C0001 + 14C06C6C90C7FCEB0FF823347CB22C>II<1278B712C016E0A316C000FCC7EA3F80ED7F0015FE00785CC712014A5A4A5A + 5D140F5D4A5A143F92C7FC5C147E14FE5C13015CA2495AA213075CA3495AA4495AA5133F + 91C8FCAA131E23357CB32C>III<121FEA3F80EA7FC0EA + FFE0A5EA7FC0EA3F80EA1F00C7FCAE121FEA3F80EA7FC0EAFFE0A5EA7FC0EA3F80EA1F00 + 0B2470A32C>II<1502ED0F80151F157F15FF913803FE00EC0FFCEC + 1FF0EC7FE0ECFF80D903FEC7FC495AEB1FF0495AEBFF80000390C8FCEA07FCEA1FF8EA3F + E0EAFF8090C9FCA27FEA3FE0EA1FF8EA07FC6CB4FCC67FEB3FE06D7EEB07FC6D7E903800 + FF80EC7FE0EC1FF0EC0FFCEC03FE913800FF80157F151F150FED0200212A7BAD2C>I<00 + 7FB612F0B712F8A36C15F0CAFCA8007FB612F0B712F8A36C15F025127DA12C>I<122012 + F87EB4FC7FEA3FE0EA1FF8EA07FC6CB4FCC67FEB3FE06D7EEB07FC6D7E903800FF80EC7F + E0EC1FF0EC0FFCEC03FE913800FF80157FA215FF913803FE00EC0FFCEC1FF0EC7FE0ECFF + 80D903FEC7FC495AEB1FF0495AEBFF80000390C8FCEA07FCEA1FF8EA3FE0EAFF8090C9FC + 12FC5A1220212A7BAD2C>I<14FE497EA4497FA214EFA2130781A214C7A2010F7FA314C3 + 90381F83F0A590383F01F8A490387E00FCA549137E90B512FEA34880A29038F8003FA348 + 48EB1F80A4000715C049130FD87FFEEBFFFC6D5AB514FE6C15FC497E27347EB32C>65 + D<007FB512E015F8B612FE6C8016C03903F0003FED0FE0ED07F01503A2ED01F8A6ED03F0 + A21507ED0FE0ED1FC0EDFF8090B612005D5D15FF16C09039F0001FE0ED07F0ED03F81501 + ED00FCA216FE167EA616FE16FC1501ED03F8150FED3FF0007FB612E016C0B712806CECFE + 0015F027337FB22C>I<02FF13700107EBE0F84913F9013F13FD4913FFEBFF813901FE00 + 7F4848131FD807F0130F1507485A491303485A150148C7FCA25A007EEC00F01600A212FE + 5AAB7E127EA3007F15F06CEC01F8A26C7EA26C6C13036D14F06C6C130716E0D803FC131F + 6C6CEB3FC03A00FF81FF806DB512006D5B010F5B6D13F00100138025357DB32C>I<007F + B5FCB612C015F0816C803907E003FEEC00FFED7F80153FED1FC0ED0FE0A2150716F01503 + 16F81501A4ED00FCACED01F8A3150316F0A2150716E0150FED1FC0153FED7F80EDFF00EC + 03FE007FB55AB65A5D15C06C91C7FC26337EB22C>I<007FB612F0B712F8A37E3903F000 + 01A7ED00F01600A4EC01E04A7EA490B5FCA5EBF003A46E5A91C8FCA5163C167EA8007FB6 + 12FEB7FCA36C15FC27337EB22C>I<007FB612F8B712FCA37ED803F0C7FCA716781600A5 + 15F04A7EA490B5FCA5EBF001A46E5A92C7FCAD387FFFE0B5FC805C7E26337EB22C>I72 D<007FB512F8B612FCA36C14F839000FC0 + 00B3B3A5007FB512F8B612FCA36C14F81E3379B22C>I<387FFFE0B57EA36C5BD803F0C8 + FCB3AE16F0ED01F8A8007FB6FCB7FCA36C15F025337DB22C>76 DII<007FB512C0B612F88115FF6C + 15802603F00013C0153FED0FE0ED07F0A2150316F81501A6150316F01507A2ED0FE0ED3F + C015FF90B61280160015FC5D15C001F0C8FCB0387FFF80B57EA36C5B25337EB22C>80 + D<90381FF80790B5EA0F804814CF000714FF5A381FF01F383FC003497E48C7FC007E147F + 00FE143F5A151FA46CEC0F00007E91C7FC127F7FEA3FE0EA1FFCEBFFC06C13FC0003EBFF + C06C14F06C6C7F01077F9038007FFEEC07FF02001380153FED1FC0A2ED0FE0A200781407 + 12FCA56CEC0FC0A26CEC1F806D133F01E0EB7F009038FE01FF90B55A5D00F914F0D8F83F + 13C0D8700790C7FC23357CB32C>83 D<007FB612FCB712FEA43AFC007E007EA70078153C + C71400B3AF90383FFFFCA2497F6D5BA227337EB22C>I<3B7FFF803FFFC0B56C4813E0A3 + 6C496C13C03B03F00001F800B3AF6D130300015DA26D130700005D6D130F017F495A6D6C + 485AECE0FF6DB5C7FC6D5B010313F86D5B9038003F802B3480B22C>II<3A3FFF03FFE0484913F0148714 + 076C6D13E03A01F800FE007F0000495A13FE017E5BEB7F03013F5B1487011F5B14CF010F + 5B14FF6D5BA26D90C7FCA26D5AA26D5AA2497EA2497EA2497F81EB0FCF81EB1FC7EC87F0 + EB3F83EC03F8EB7F01017E7FEBFE00497F0001147E49137F000380491480151FD87FFEEB + FFFC6D5AB514FE6C15FC497E27337EB22C>88 DI<003FB612C04815E0A4007EC7EA1FC0ED3F80 + A2ED7F00157E15FE4A5A003C5CC712034A5AA24A5A4A5AA24A5A4AC7FCA214FE495AA249 + 5A495AA2495A495AA2495A49C8FCA213FE485AA24848EB03C049EB07E01207485A5B121F + 485AA248C7FCB7FCA46C15C023337CB22C>I<387FFFFCB512FEA314FC00FCC7FCB3B3B3 + B512FC14FEA36C13FC17416FB92C>I<127012F8A27E127C127E123E123F7EA27F120F7F + 12077F12037F12017F12007F137C137E133EA2133F7F80130F8013078013038013018013 + 0080147C147E143EA2143F8081140F81140781140381140181140081157CA2157E153E15 + 3F811680150FA2ED070021417BB92C>I<387FFFFCB512FEA37EC7127EB3B3B3387FFFFE + B5FCA36C13FC17417DB92C>I<007FB6FCB71280A46C150021067B7D2C>95 + D<3801FFF0000713FE001F6D7E15E048809038C01FF81407EC01FC381F80000006C77EC8 + 127EA3ECFFFE131F90B5FC1203120F48EB807E383FF800EA7FC090C7FC12FE5AA47E007F + 14FEEB8003383FE01F6CB612FC6C15FE6C14BF0001EBFE1F3A003FF007FC27247CA32C> + 97 DI<903803FFE0011F13F8017F13FE48B5FC48804848C6FCEA0FF0485A49137E + 4848131890C9FC5A127EA25AA8127EA2127F6C140F6DEB1F806C7E6D133F6C6CEB7F0039 + 07FE03FF6CB55A6C5C6C6C5B011F13E0010390C7FC21247AA32C>IIII + II< + 1307EB1FC0A2497EA36D5AA20107C7FC90C8FCA7387FFFC080B5FC7EA2EA0007B3A8007F + B512FCB612FEA36C14FC1F3479B32C>I<140EEC3F80A2EC7FC0A3EC3F80A2EC0E0091C7 + FCA748B512804814C0A37EC7120FB3B3A2141F003C1480007E133FB414005CEB01FEEBFF + FC6C5B5C001F5B000790C7FC1A467CB32C>II<387FFFE0B57EA37EEA0003B3B3A5007F + B61280B712C0A36C158022337BB22C>I<3A7F83F007E09039CFFC1FF83AFFDFFE3FFCD8 + 7FFF13FF91B57E3A07FE1FFC3E01FCEBF83F496C487E01F013E001E013C0A301C01380B3 + 3B7FFC3FF87FF0027F13FFD8FFFE6D13F8D87FFC4913F0023F137F2D2481A32C>I<397F + F01FE039FFF87FFC9038F9FFFE01FB7F6CB6FC00019038F03F80ECC01F02807FEC000F5B + 5BA25BB3267FFFE0B5FCB500F11480A36C01E0140029247FA32C>II<397FF01FE0 + 39FFF8FFF801FB13FE90B6FC6C158000019038F07FC09138801FE091380007F049EB03F8 + 5BED01FC491300A216FE167EA816FE6D14FCA2ED01F86D13036DEB07F0150F9138801FE0 + 9138E07FC091B51280160001FB5B01F813F8EC3FC091C8FCAD387FFFE0B57EA36C5B2736 + 7FA32C>I<903903FC078090391FFF0FC0017F13CF48B512EF4814FF3807FE07380FF001 + 48487E49137F4848133F90C7FC48141F127E150F5AA87E007E141FA26C143F7F6C6C137F + 6D13FF380FF0033807FC0F6CB6FC6C14EF6C6C138F6D130FEB07F890C7FCAD0203B5FC4A + 1480A36E140029367DA32C>II<90387FF8700003B512F8120F5A5A387FC00F387E00034813015AA36CEB + 00F0007F140013F0383FFFC06C13FE6CEBFF80000314E0C66C13F8010113FCEB0007EC00 + FE0078147F00FC143F151F7EA26C143F6D133E6D13FE9038F007FC90B5FC15F815E000F8 + 148039701FFC0020247AA32C>I<131E133FA9007FB6FCB71280A36C1500D8003FC8FCB1 + ED03C0ED07E0A5EC800F011FEB1FC0ECE07F6DB51280160001035B6D13F89038003FE023 + 2E7EAD2C>I<3A7FF003FF80486C487FA3007F7F0001EB000FB3A3151FA2153F6D137F39 + 00FE03FF90B7FC6D15807F6D13CF902603FE07130029247FA32C>I<3A7FFF01FFFCB514 + FE148314016C15FC3A03E0000F80A26D131F00011500A26D5B0000143EA26D137E017C13 + 7CA2017E13FC013E5BA2EB3F01011F5BA21483010F5BA214C701075BA214EF01035BA214 + FF6D90C7FCA26D5A147C27247EA32C>II<3A3FFF03FFF048018713F8A36C010313F03A00FC007E005D90387E01F8013F5BEB1F + 83EC87E090380FCFC0903807EF80EB03FF6D90C7FC5C6D5A147C14FE130180903803EF80 + 903807CFC0EB0FC7EC83E090381F01F0013F7FEB7E00017C137C49137E0001803A7FFF01 + FFFC1483B514FE6C15FC140127247EA32C>I<3A7FFF01FFFCB5008113FE148314816C01 + 0113FC3A03E0000F806C7E151F6D140012005D6D133E137C017E137E013E137CA2013F13 + FC6D5BA2EB0F815DA2EB07C1ECC3E0A2EB03E3ECE7C0130114F75DEB00FFA292C7FC80A2 + 143EA2147E147CA214FC5CA2EA0C01003F5BEA7F83EB87E0EA7E0F495A387FFF806C90C8 + FC6C5A6C5AEA07E027367EA32C>I<003FB612E04815F0A4007EC7EA1FE0ED3FC0ED7F80 + EDFF004A5A003C495AC7485A4A5A4A5A4A5A4A5A4AC7FCEB01FC495AEB0FF0495A495A49 + 5A49C8FC4848EB01E04848EB03F0485A485A485A485A485AB7FCA46C15E024247DA32C> + I<15FF02071380141F147F91B512004913C04AC7FCEB03F85CB31307EB1FE013FF007F5B + B55A49C8FC6D7E6C7FC67F131FEB07F01303B380EB01FEECFFC06D13FF6E1380141F1407 + 0200130021417BB92C>I125 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fl cmsy10 10 6 + /Fl 6 95 df<007FB81280B912C0A26C17803204799641>0 D15 D<91381FFFFE91B6FC1303010F14FED91FF0C7 + FCEB7F8001FEC8FCEA01F8485A485A485A5B48C9FCA2123EA25AA2127812F8A25AA2B712 + FE16FFA216FE00F0C9FCA27EA21278127CA27EA27EA26C7E7F6C7E6C7E6C7EEA00FEEB7F + 80EB1FF06DB512FE010314FF1300021F13FE283279AD37>50 D<007FB712F8B812FCA27E + CA123CB217182E177C9D37>58 D<15301578B3B3AD007FB812F8B912FCA26C17F836367B + B541>63 D<14034A7E4A7EA24A7EA34A7EA2EC7CF8A2ECF87CA2ECF03C0101133EA24948 + 7EA249486C7EA249486C7EA2EC00034980A2013E6D7EA2496D7EA20178147801F8147CA2 + 484880A2484880A24848EC0F80A2491407000F16C0A248C8EA03E0A2003EED01F0A2003C + 1500007C16F8A248167CA248163C006016182E347CB137>94 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fm cmr10 10 3 + /Fm 3 62 df<011FB512FEA39026001FFEC8FCEC07F8A8EC3FFE0103B512E0D91FF713FC + 90397F07F87F01FCEC1F80D803F8EC0FE0D807F06E7ED80FE06E7E001F82D83FC06E7EA2 + 007F8201808000FF1780A7007F170001C05C003F5EA2D81FE04A5A000F5ED807F04A5AD8 + 03F84A5AD800FCEC1F80017F027FC7FC90391FF7FFFC0103B512E09026003FFEC8FCEC07 + F8A8EC1FFE011FB512FEA331397BB83C>8 D<15301578B3A6007FB812F8B912FCA26C17 + F8C80078C8FCB3A6153036367BAF41>43 D<007FB812F8B912FCA26C17F8CCFCAE007FB8 + 12F8B912FCA26C17F836167B9F41>61 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fn cmr7 7 2 + /Fn 2 51 df<13381378EA01F8121F12FE12E01200B3AB487EB512F8A215267BA521>49 + D<13FF000313E0380E03F0381800F848137C48137E00787F12FC6CEB1F80A4127CC7FC15 + 005C143E147E147C5C495A495A5C495A010EC7FC5B5B903870018013E0EA018039030003 + 0012065A001FB5FC5A485BB5FCA219267DA521>I E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fo cmmi10 10 17 + /Fo 17 120 df<1503A35DA21506A2150EA2150CA2151CA21518A21538A21530A21570A2 + EC07FE91383FFFC0903901FCE3F0903907E0E0F890391F80C03ED93E007FEB7C01D801F8 + EC0F80D803F0018013C0D807E014071403D80FC015E0D81F801300A248485AA2007E1306 + A2020E130F12FE48010C14C0A2021CEB1F80A20218EB3F00A20238137E007C5D1430007E + 4A5A003E90387003F06CEC07C09138600F80D80F80013FC7FC3903E0E0FC3901F8E7F039 + 007FFF80D90FFCC8FCEB01C0A25CA21303A291C9FCA25BA21306A2130EA2130CA22B4B7C + B931>30 D<0140151E01E0153F00015E484816805B120790C9123F000E161F170F5A1707 + 481700A2003014C014010070010314061260A2170E00E04948130C5A171C92C7FC5FA26C + 495C4A14F04A7E6C017F495A4A6C485A3AF801F7E00F3BFE0FF3F83F80267FFFE3B5FC02 + C191C7FC6C01815B02005BD80FFCEB7FF0D803F0EB0FC031267FA434>33 + D<1760177017F01601A21603A21607160FA24C7EA216331673166316C3A2ED0183A2ED03 + 03150683150C160115181530A21560A215C014011580DA03007FA202061300140E140C5C + 021FB5FC5CA20260C7FC5C83495A8349C8FC1306A25BA25B13385B01F01680487E000716 + FFB56C013F13FF5EA2383C7DBB3E>65 D<0103B77E4916F018FC903B0007F80003FE4BEB + 00FFF07F80020FED3FC0181F4B15E0A2141FA25DA2143F19C04B143F1980027F157F1900 + 92C812FE4D5A4A4A5AEF0FF04AEC1FC005FFC7FC49B612FC5F02FCC7B4FCEF3FC00103ED + 0FE0717E5C717E1307844A1401A2130F17035CA2131F4D5A5C4D5A133F4D5A4A4A5A4D5A + 017F4BC7FC4C5A91C7EA07FC49EC3FF0B812C094C8FC16F83B397DB83F>I<0103B812F0 + 5BA290260007F8C7123F4B1407F003E0020F150118005DA2141FA25D19C0143FA24B1330 + A2027F1470190092C7126017E05C16014A495A160F49B6FCA25F9138FC000F01031407A2 + 4A6DC8FCA201075C18034A130660010F160693C7FC4A150E180C011F161C18184A1538A2 + 013F5E18F04A4A5AA2017F15074D5A91C8123F49913803FF80B9FCA295C7FC3C397DB83D + >69 D<147E903803FF8090390FC1C38090391F00EFC0017E137F49133F485A4848EB1F80 + 12075B000F143F48481400A2485A5D007F147E90C7FCA215FE485C5AA214015D48150CA2 + 1403EDF01C16181407007C1538007E010F1330003E131F027B13706C01E113E03A0F83C0 + F9C03A03FF007F80D800FCEB1F0026267DA42C>97 D<133FEA1FFFA3C67E137EA313FE5B + A312015BA312035BA31207EBE0FCEBE3FF9038E707C0390FFE03E09038F801F001F013F8 + EBE000485A15FC5BA2123F90C7FCA214015A127EA2140312FE4814F8A2140715F05AEC0F + E0A215C0EC1F80143F00781400007C137E5C383C01F86C485A380F07C06CB4C7FCEA01FC + 1E3B7CB924>II101 D<14E0EB03F8A21307A314F0EB01C090C7FCAB13F8EA03 + FEEA070F000E1380121C121812381230EA701F1260133F00E0130012C05BEA007EA213FE + 5B1201A25B12035BA20007131813E01438000F133013C01470EB806014E014C01381EB83 + 8038078700EA03FEEA00F815397EB71D>105 D108 D + 110 D<90390F8003F090391FE00FFC903939F03C1F903A70F8700F80903AE0FDE007C090 + 38C0FF80030013E00001491303018015F05CEA038113015CA2D800031407A25CA2010714 + 0FA24A14E0A2010F141F17C05CEE3F80131FEE7F004A137E16FE013F5C6E485A4B5A6E48 + 5A90397F700F80DA383FC7FC90387E1FFCEC07E001FEC9FCA25BA21201A25BA21203A25B + 1207B512C0A32C3583A42A>112 D<3903E001F83907F807FE390E3C1E07391C3E381F3A + 183F703F800038EBE07F0030EBC0FF00705B00601500EC007E153CD8E07F90C7FCEAC07E + A2120013FE5BA312015BA312035BA312075BA3120F5BA3121F5B0007C9FC21267EA425> + 114 D116 + D<01F8EB03C0D803FEEB07E0D8070F130F000E018013F0121C12180038140700301403D8 + 701F130112601500D8E03F14E000C090C7FC5BEA007E16C013FE5B1501000115805B1503 + 16001203495B1506150E150C151C151815385D00015C6D485A6C6C485AD97E0FC7FCEB1F + FEEB07F024267EA428>118 D<01F816F0D803FE9138E001F8D8070F903801F003000ED9 + 800314FC121C12180038020713010030EDE000D8701F167C1260030F143CD8E03F163800 + C001005B5BD8007E131F183001FE5C5B033F1470000117604991C7FCA218E000034A14C0 + 49137E17011880170318005F03FE1306170E000101015C01F801BF5B3B00FC039F807090 + 3A7E0F0FC0E0903A1FFC03FFC0902703F0007FC7FC36267EA43B>I + E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fp ecbx1200 12 37 + /Fp 37 121 df28 D<157F913803FFC0020F + 7F4A7F91383FE1F891387F80789138FF007C49143C495A163E4948131EA3130FA3163E16 + 3C167C16786E13F84B5A4B5A15075E6D6C485A4BC70003B512E0153E15FC6D5B5D4B9139 + 0007C0004B5E6D6D150F4FC7FC6D6D151E49173E496D5D491778496D15F890261FBFFE4A + 5AD93F3F5E9026FE1FFF1403D801FC6E495A00036D5E48486C6D130F000F6F49C8FC001F + 6D6D133E48486C6D133C187C007F6D6D5B6F6C485A00FF6E6C485A6FEB87C06F13CFEFFF + 806F91C9FC6D6D5B6F49EC01E06F7F6C6CEC3FFF706D13036C6C4A6DEB07C06C6C91B500 + F0130FDA800702FCEB1F806C9026E03FF89039FF80FF00000390B5D8F03FEBFFFE6CDBC0 + 0F5C6C6CDA00035C011F01F8D9007F13E001030180020790C7FC4B477BC557>38 + D46 + D + 49 DII<163FA25E5E5D5DA25D5D + 5D5DA25D92B5FCEC01F7EC03E7140715C7EC0F87EC1F07143E147E147C14F8EB01F0EB03 + E0130714C0EB0F80EB1F00133E5BA25B485A485A485A120F5B48C7FC123E5A12FCB91280 + A5C8000F90C7FCAC027FB61280A531417DC038>I<0007150301E0143F01FFEB07FF91B6 + FC5E5E5E5E5E16804BC7FC5D15E092C8FC01C0C9FCAAEC3FF001C1B5FC01C714C001DF14 + F09039FFE03FFC9138000FFE01FC6D7E01F06D13804915C0497F6C4815E0C8FC6F13F0A3 + 17F8A4EA0F80EA3FE0487E12FF7FA317F05B5D6C4815E05B007EC74813C0123E003F4A13 + 80D81FC0491300D80FF0495AD807FEEBFFFC6CB612F0C65D013F1480010F01FCC7FC0101 + 13C02D427BC038>I65 DI + III76 + D80 D82 DI87 D<903801FFE0011F13FE017F6D + 7E48B612E03A03FE007FF84848EB1FFC6D6D7E486C6D7EA26F7FA36F7F6C5A6C5AEA00F0 + 90C7FCA40203B5FC91B6FC1307013F13F19038FFFC01000313E0481380381FFE00485A5B + 127F5B12FF5BA35DA26D5B6C6C5B4B13F0D83FFE013EEBFFC03A1FFF80FC7F0007EBFFF8 + 6CECE01FC66CEB8007D90FFCC9FC322F7DAD36>97 D99 DIII + II< + 137C48B4FC4813804813C0A24813E0A56C13C0A26C13806C1300EA007C90C7FCAAEB7FC0 + EA7FFFA512037EB3AFB6FCA518467CC520>I107 DI<90277F8007FEEC0FFCB590263FFFC090387FFF8092B5D8F001B512E002 + 816E4880913D87F01FFC0FE03FF8913D8FC00FFE1F801FFC0003D99F009026FF3E007F6C + 019E6D013C130F02BC5D02F86D496D7EA24A5D4A5DA34A5DB3A7B60081B60003B512FEA5 + 572D7CAC5E>I<90397F8007FEB590383FFF8092B512E0028114F8913987F03FFC91388F + 801F000390399F000FFE6C139E14BC02F86D7E5CA25CA35CB3A7B60083B512FEA5372D7C + AC3E>II<90397FC00FF8B5 + 90B57E02C314E002CF14F89139DFC03FFC9139FF001FFE000301FCEB07FF6C496D13804A + 15C04A6D13E05C7013F0A2EF7FF8A4EF3FFCACEF7FF8A318F017FFA24C13E06E15C06E5B + 6E4913806E4913006E495A9139DFC07FFC02CFB512F002C314C002C091C7FCED1FF092C9 + FCADB67EA536407DAC3E>I<90387F807FB53881FFE0028313F0028F13F8ED8FFC91389F + 1FFE000313BE6C13BC14F8A214F0ED0FFC9138E007F8ED01E092C7FCA35CB3A5B612E0A5 + 272D7DAC2E>114 D<90391FFC038090B51287000314FF120F381FF003383FC00049133F + 48C7121F127E00FE140FA215077EA27F01E090C7FC13FE387FFFF014FF6C14C015F06C14 + FC6C800003806C15806C7E010F14C0EB003F020313E0140000F0143FA26C141F150FA27E + A26C15C06C141FA26DEB3F8001E0EB7F009038F803FE90B55A00FC5CD8F03F13E026E007 + FEC7FC232F7CAD2C>III120 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fq ecti1000 10 52 + /Fq 52 123 df28 D39 D<150C151C153815F0EC01E0EC03 + C0EC0780EC0F00141E5C147C5C5C495A1303495A5C130F49C7FCA2133EA25BA25BA2485A + A212035B12075BA2120F5BA2121FA290C8FCA25AA2123EA2127EA2127CA412FC5AAD1278 + A57EA3121C121EA2120E7EA26C7E6C7EA212001E5274BD22>I<140C140E80EC0380A2EC + 01C015E0A2140015F0A21578A4157C153CAB157CA715FCA215F8A21401A215F0A21403A2 + 15E0A21407A215C0140F1580A2141F1500A2143EA25CA25CA2495AA2495A5C1307495A91 + C7FC5B133E133C5B5B485A12035B48C8FC120E5A12785A12C01E527FBD22>I44 D<387FFFF8A2B5FCA214F0150579941E>I<120EEA3F8012 + 7F12FFA31300127E123C0909778819>I<1538A2157015F014011403EC07E0140F143F14 + FF010713C0EB3FCF141F131001001380A2143FA21500A25CA2147EA214FEA25CA21301A2 + 5CA21303A25CA21307A25CA2130FA25CA2131FA25CA2133FA291C7FC497EB61280A31D37 + 77B62A>49 DII57 D<133C137E13FF5AA313FE13FCEA00701300B2120EEA3F80127F12FFA31300127E + 123C102477A319>I65 + D<0107B612FCEFFF8018C0903B000FF0001FF04BEB07F81703021F15FC17014B14FEA202 + 3F1400A24B1301A2147F18FC92C7120318F84A140718F04AEC0FE0EF1FC00101ED3F80EF + 7F004AEB01FEEE07F849B612E05F9139F80007F0EE01FC01076E7E177F4AEC3F80A2010F + 16C0171F5CA2131F173F5CA2133FEF7F805C1800017F5D4C5A91C7485A5F49140FEE1FE0 + 494A5A00014AB45AB748C7FC16F816C037397BB83A>II<0103B612FEEFFFC018F0903B0007F8 + 000FF84BEB03FCEF00FE020F157FF03F804B141F19C0021F150F19E05D1807143F19F05D + A2147FA292C8FCA25C180F5CA2130119E04A151FA2130319C04A153FA201071780187F4A + 1600A2010F16FEA24A4A5A60011F15034D5A4A5D4D5A013F4B5A173F4A4AC7FC17FC017F + EC03F84C5A91C7EA1FC04949B45A007F90B548C8FCB712F016803C397CB83F>I<0107B7 + 12FEA3903A000FF000074B1300187C021F153CA25DA2143FA25D1838147FA292C8FCEE03 + 804A130718004A91C7FCA201015CA24A131E163E010314FE91B5FC5EA2903807F800167C + 4A1378A2130FA24A1370A2011F14F0A24A90C8FCA2133FA25CA2137FA291CAFCA25BA25B + 487EB6FCA337397BB836>70 DI<0103B512F8A390390007F8005DA2140FA25DA2141F + A25DA2143FA25DA2147FA292C7FCA25CA25CA21301A25CA21303A25CA21307A25CA2130F + A25CA2131FA25CA2133FA25CA2137FA291C8FC497EB6FCA25C25397CB820>73 + D<0107B512FCA25E9026000FF8C7FC5D5D141FA25DA2143FA25DA2147FA292C8FCA25CA2 + 5CA21301A25CA21303A25CA21307A25CA2130F170C4A141CA2011F153C17384A1478A201 + 3F157017F04A14E01601017F140317C091C71207160F49EC1F80163F4914FF0001020713 + 00B8FCA25E2E397BB834>76 D<902607FFF8923807FFF0614F13E0D9000FEFF0004F5AA2 + 021F167FF1EFC0141DDA1CFCEC01CF023C16DF9538039F800238ED071FA20278ED0E3F97 + C7FC0270151CA202F04B5AF0707E14E0037E14E0010117FE4D485A02C0EC0380A20103ED + 0701610280140EA20107ED1C0305385B14006F137049160705E05B010EEC01C0A2011E91 + 3803800F61011CEC0700A2013C020E131F4C5C1338ED1FB80178163F04F091C8FC01705C + A201F04A5B187E00015DD807F816FEB500C09039007FFFFC151E150E4C397AB84A>I<90 + 2603FFF891B512E0A281D90007923807F8006F6E5A61020F5E81DA0E7F5DA2021E6D1307 + 033F92C7FC141C82DA3C1F5C70130EEC380FA202786D131E0307141C147082DAF003143C + 70133814E0150101016E1378030014705C8201036E13F0604A1480163F010715C1041F5B + 91C7FC17E149EC0FE360010E15F31607011E15FF95C8FC011C80A2013C805F1338160013 + 785F01F8157CEA03FC267FFFE0143CB51538A243397CB83E>II<0107B612F817FF1880903B00 + 0FF0003FE04BEB0FF0EF03F8141FEF01FC5DA2023F15FEA25DA2147FEF03FC92C7FCA24A + 15F817074A15F0EF0FE01301EF1FC04AEC3F80EFFE0001034A5AEE0FF091B612C04CC7FC + D907F8C9FCA25CA2130FA25CA2131FA25CA2133FA25CA2137FA291CAFCA25BA25B1201B5 + 12FCA337397BB838>I<0103B612F017FEEFFF80903B0007F8003FC04BEB0FF01707020F + EC03F8EF01FC5DA2021F15FEA25DA2143FEF03FC5DA2027FEC07F818F092C7120F18E04A + EC1FC0EF3F004A14FEEE01F80101EC0FE091B6128004FCC7FC9138FC003F0103EC0F8083 + 4A6D7E8301071403A25C83010F14075F5CA2011F140FA25CA2133F161F4AECE007A2017F + 160F180E91C7FC49020F131C007F01FE153CB5913807F078040313F0CAEAFFE0EF3F8038 + 3B7CB83D>82 D<92383FC00E913901FFF01C020713FC91391FC07E3C91393F001F7C027C + EB0FF84A130749481303495A4948EB01F0A2495AA2011F15E091C7FCA34915C0A36E90C7 + FCA2806D7E14FCECFF806D13F015FE6D6D7E6D14E0010080023F7F14079138007FFC150F + 15031501A21500A2167C120EA3001E15FC5EA3003E4A5AA24B5AA2007F4A5A4B5A6D49C7 + FC6D133ED8F9F013FC39F8FC03F839F07FFFE0D8E01F138026C003FCC8FC2F3D7ABA2F> + I<0007B812E0A25AD9F800EB001F01C049EB07C0485AD900011403121E001C5C003C1780 + 1403123800785C00701607140700F01700485CA2140FC792C7FC5DA2141FA25DA2143FA2 + 5DA2147FA292C9FCA25CA25CA21301A25CA21303A25CA21307A25CA2130FA25CEB3FF000 + 7FB512F8B6FCA2333971B83B>I86 + DI95 D<14F8EB07FE90381F871C90383E03FE137CEBF801120148486C5A485A + 120FEBC001001F5CA2EA3F801403007F5C1300A21407485C5AA2140F5D48ECC1C0A2141F + 15831680143F1587007C017F1300ECFF076C485B9038038F8E391F0F079E3907FE03FC39 + 01F000F0222677A42A>97 D<133FEA1FFFA3C67E137EA313FE5BA312015BA312035BA312 + 07EBE0F8EBE7FE9038EF0F80390FFC07C013F89038F003E013E0D81FC013F0A21380A212 + 3F1300A214075A127EA2140F12FE4814E0A2141F15C05AEC3F80A215005C147E5C387801 + F8007C5B383C03E0383E07C0381E1F80D80FFEC7FCEA01F01C3B77B926>I<147F903803 + FFC090380FC1E090381F0070017E13784913383901F801F83803F003120713E0120FD81F + C013F091C7FC485AA2127F90C8FCA35A5AA45AA3153015381578007C14F0007EEB01E000 + 3EEB03C0EC0F806CEB3E00380F81F83803FFE0C690C7FC1D2677A426>II<147F90 + 3803FFC090380FC1E090383F00F0017E13785B485A485A485A120F4913F8001F14F0383F + 8001EC07E0EC1F80397F81FF00EBFFF8148090C8FC5A5AA55AA21530007C14381578007E + 14F0003EEB01E0EC03C06CEB0F806CEB3E00380781F83803FFE0C690C7FC1D2677A426> + IIIII108 DII<147F903803FF + C090380FC1F090381F00F8017E137C5B4848137E4848133E0007143F5B120F485AA2485A + 157F127F90C7FCA215FF5A4814FEA2140115FC5AEC03F8A2EC07F015E0140F007C14C000 + 7EEB1F80003EEB3F00147E6C13F8380F83F03803FFC0C648C7FC202677A42A>I<903907 + 8007C090391FE03FF090393CF0787C903938F8E03E9038787FC00170497EECFF00D9F0FE + 148013E05CEA01E113C15CA2D80003143FA25CA20107147FA24A1400A2010F5C5E5C4B5A + 131F5EEC80035E013F495A6E485A5E6E48C7FC017F133EEC70FC90387E3FF0EC0F8001FE + C9FCA25BA21201A25BA21203A25B1207B512C0A3293580A42A>I<3903C003F0390FF01F + FC391E783C0F381C7C703A3C3EE03F8038383FC0EB7F800078150000701300151CD8F07E + 90C7FCEAE0FE5BA2120012015BA312035BA312075BA3120F5BA3121F5BA3123F90C9FC12 + 0E212679A423>114 D<14FE903807FF8090380F83C090383E00E04913F00178137001F8 + 13F00001130313F0A215E00003EB01C06DC7FC7FEBFFC06C13F814FE6C7F6D13807F010F + 13C01300143F141F140F123E127E00FE1480A348EB1F0012E06C133E00705B6C5B381E03 + E06CB45AD801FEC7FC1C267AA422>II<13F8D803FEEB01C0D8078FEB03E0390E0F8007121E121C0038140F131F00 + 7815C01270013F131F00F0130000E015805BD8007E133FA201FE14005B5D120149137EA2 + 15FE120349EBFC0EA20201131E161C15F813E0163CD9F003133814070001ECF07091381E + F8F03A00F83C78E090393FF03FC090390FC00F00272679A42D>I<01F0130ED803FC133F + D8071EEB7F80EA0E1F121C123C0038143F49131F0070140FA25BD8F07E140000E08013FE + C6485B150E12015B151E0003141C5BA2153C000714385B5DA35DA24A5A140300035C6D48 + C7FC0001130E3800F83CEB7FF8EB0FC0212679A426>I<01F01507D803FC903903801F80 + D8071E903907C03FC0D80E1F130F121C123C0038021F131F49EC800F00701607A249133F + D8F07E168000E0ED000313FEC64849130718000001147E5B03FE5B0003160E495BA2171E + 00070101141C01E05B173C1738A217781770020314F05F0003010713016D486C485A0001 + 90391E7C07802800FC3C3E0FC7FC90393FF81FFE90390FE003F0322679A437>I<13F0D8 + 03FCEB01C0D8071EEB03E0D80E1F1307121C123C0038140F4914C01270A249131FD8F07E + 148012E013FEC648133F160012015B5D0003147E5BA215FE00075C5BA214015DA314035D + 14070003130FEBF01F3901F87FE038007FF7EB1FC7EB000F5DA2141F003F5C48133F92C7 + FC147E147C007E13FC387001F8EB03E06C485A383C1F80D80FFEC8FCEA03F0233679A428 + >121 D<903903C0038090380FF007D91FF81300496C5A017F130E9038FFFE1E9038F83F + FC3901F007F849C65A495B1401C7485A4A5A4AC7FC141E5C5C5C495A495A495A49C8FC13 + 1E5B49131C5B4848133C48481338491378000714F8390FF801F0391FFF07E0383E1FFFD8 + 3C0F5B00785CD8700790C7FC38F003FC38E000F021267BA422>I + E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fr ecrm1000 10 80 + /Fr 80 178 df<486C1360000314E039070001C0000EEB038048EB070000181306003813 + 0E0030130C0070131C00601318A200E01338481330A400CEEB338039FF803FE001C013F0 + A3007F131FA2393F800FE0390E0003801C1981B91C>16 D<001C1307007FEB1FC039FF80 + 3FE0A201C013F0A3007F131F001CEB073000001300A400011470491360A2000314E090C7 + 12C048130100061480000E130348EB070048130E485B006013181C1980B91C>I21 DI27 DIII<007C137C00FE13FEEAFF01A3EAFE00A7007E13 + FC007C137CA8003C137800381338A700181330171E77BA2A>34 D<017C166048B416F026 + 07C3801401260F81C01403D900E04A5A001E01784A5A003E6D141F003C013FEC7F80007C + 90271BE003FFC7FC0218B512BF007891381FFC3E00F8011CC75A020C14FC5F4C5A16035F + 4C5A160F5F4CC8FC021C5B00780118133E007C5D16FC003C01385B003E90383001F0001E + EB70036C01E05B903981C007C03907C3800F2601FF005BD8007C49C9FC90C748EB07C003 + 3EEB1FF04BEB3C3803FCEBF81C4B497E913A01F001E00602030103130703E0497E912607 + C0071480020F15011580DA1F00018013C04A010F1300143E5C14FC5C495A13035C495A13 + 0F4A0107130149C701C013805B013E1603490203140001FC6F5A49020113064848913800 + F00E0003705A49ED3C3849ED1FF06C48ED07C03A437BBD45>37 D<121C127FEAFF80A213 + C0A3127F121C1200A412011380A2120313005A1206120E5A5A5A12600A1979B917>39 + D<146014E0EB01C0EB0380EB0700130E131E5B5BA25B485AA2485AA212075B120F90C7FC + A25A121EA2123EA35AA65AB2127CA67EA3121EA2121F7EA27F12077F1203A26C7EA26C7E + 1378A27F7F130E7FEB0380EB01C0EB00E01460135278BD20>I<12C07E12707E7E7E120F + 6C7E6C7EA26C7E6C7EA21378A2137C133C133E131EA2131F7FA21480A3EB07C0A6EB03E0 + B2EB07C0A6EB0F80A31400A25B131EA2133E133C137C1378A25BA2485A485AA2485A48C7 + FC120E5A5A5A5A5A13527CBD20>I<121C127FEAFF80A213C0A3127F121C1200A4120113 + 80A2120313005A1206120E5A5A5A12600A19798817>44 DI<12 + 1C127FEAFF80A5EA7F00121C0909798817>I<1506A2150E150CA2151C151815381530A2 + 15701560A215E015C0A214011580A2140315005C1406A2140E140CA2141C1418A2143814 + 30A21470146014E05CA213015CA2130391C7FCA25B1306A2130E130C131C1318A2133813 + 30A213701360A213E05BA212015B120390C8FCA25A1206A2120E120CA2121C1218A21238 + 123012701260A212E05AA21F537BBD2A>IIIII<1538A2157815F8A2140114031407A2140F141F141B14331473146314C31301 + 1483EB030313071306130C131C131813301370136013C01201EA038013005A120E120C5A + 123812305A12E0B712F8A3C73803F800AA4A7E0103B512F8A325387EB72A>I<0006140C + D80780133C9038F003F890B5FC5D5D158092C7FC14FC38067FE090C9FCAAEB07F8EB1FFE + 9038780F809038E007E03907C003F0496C7E130000066D7E81C8FC8181A21680A4121C12 + 7F5A7FA390C713005D12FC00605C12704A5A6C5C6C1303001E495A6C6C485A3907E03F80 + 0001B5C7FC38007FFCEB1FE021397CB62A>II<12 + 301238123E003FB612E0A316C05A168016000070C712060060140E5D5D00E01430481470 + 5D5DC712014A5A4AC7FC1406140E5CA25C1478147014F05C1301A213035C1307A2130FA3 + 131F5CA2133FA5137FA96DC8FC131E233A7BB72A>II< + EB03F8EB1FFF017F13C03901FC07E048486C7E3907E001F8000F6D7E4848137E5B003F80 + A248C71380A25AED1FC0A516E0A56C143FA36C7E157F121F6C6C13FF6C6C13DF00031301 + 3901F0039F3900FC0F1FD93FFC13C0EB07F090C7FCA2153F1680A216005D120F486C137E + 486C5BA24A5A4A5A49485A381F000F001CEB1F80260F807FC7FC3807FFFE000113F83800 + 3FC023397DB62A>I<121C127FEAFF80A5EA7F00121CC7FCB2121C127FEAFF80A5EA7F00 + 121C092479A317>I<121C127FEAFF80A5EA7F00121CC7FCB2121C127FEAFF80A213C0A3 + 127F121C1200A412011380A2120313005A1206120E5A5A5A12600A3479A317>I<1538A3 + 157CA315FEA34A7EA34A6C7EA202077FEC063FA2020E7FEC0C1FA2021C7FEC180FA20238 + 7FEC3007A202707FEC6003A202C07F1501A2D901807F81A249C77F167FA20106810107B6 + FCA24981010CC7121FA2496E7EA3496E7EA3496E7EA213E0707E1201486C81D80FFC0207 + 1380B56C90B512FEA3373C7DBB3E>65 DI<913A01FF800180020FEB + E003027F13F8903A01FF807E07903A03FC000F0FD90FF0EB039F4948EB01DFD93F80EB00 + FF49C8127F01FE153F12014848151F4848150FA248481507A2485A1703123F5B007F1601 + A35B00FF93C7FCAD127F6DED0180A3123F7F001F160318006C7E5F6C7E17066C6C150E6C + 6C5D00001618017F15386D6C5CD91FE05C6D6CEB03C0D903FCEB0F80902701FF803FC7FC + 9039007FFFFC020F13F002011380313D7BBA3C>IIIIIII75 + DIIIII82 DI<003FB812E0A3D9C003EB001F273E0001FE130348EE01F0007816000070 + 1770A300601730A400E01738481718A4C71600B3B0913807FF80011FB612E0A335397DB8 + 3C>IIII91 + D93 D<007FB81280B912C0A26C178032 + 04797041>95 D97 DIIII<147E903803FF8090380F + C1E0EB1F8790383F0FF0137EA213FCA23901F803C091C7FCADB512FCA3D801F8C7FCB3AB + 487E387FFFF8A31C3B7FBA19>III< + EA0380EA0FE0487EA56C5AEA0380C8FCAAEA03F012FFA312071203B3AA487EB512C0A312 + 387EB717>IIII<2703F00FF0EB1FE000FFD93FFCEB7FF8 + 913AF03F01E07E903BF1C01F83803F3D0FF3800FC7001F802603F70013CE01FE14DC49D9 + 07F8EB0FC0A2495CA3495CB3A3486C496CEB1FE0B500C1B50083B5FCA340257EA445>I< + 3903F00FF000FFEB3FFCECF03F9039F1C01F803A0FF3800FC03803F70013FE496D7EA25B + A35BB3A3486C497EB500C1B51280A329257EA42E>II<3903F01FE000 + FFEB7FF89038F1E07E9039F3801F803A07F7000FC0D803FEEB07E049EB03F04914F84913 + 0116FC150016FEA3167FAA16FEA3ED01FCA26DEB03F816F06D13076DEB0FE001F614C090 + 39F7803F009038F1E07E9038F0FFF8EC1FC091C8FCAB487EB512C0A328357EA42E>I + I<3807E01F00FFEB7FC09038E1E3E09038E387F0380FE707EA03E613EE9038EC03E09038 + FC0080491300A45BB3A2487EB512F0A31C257EA421>II<1318A51338A31378A313F8120112031207 + 001FB5FCB6FCA2D801F8C7FCB215C0A93800FC011580EB7C03017E13006D5AEB0FFEEB01 + F81A347FB220>IIIIII<003FB512FCA2EB8003D83E0013F8003CEB07F00038EB0F + E012300070EB1FC0EC3F800060137F150014FE495AA2C6485A495AA2495A495A495AA290 + 387F000613FEA2485A485A0007140E5B4848130C4848131CA24848133C48C7127C48EB03 + FC90B5FCA21F247EA325>I<1418147C14FE13011303495AEB0FF0EB1FC0495A017EC7FC + 13F813E0138090C8FCA3EBFF03000713E7381F00FF003C133F487F8000707F12F0A2807E + A27EB490C7FCEA7FE013FF6C13E06C13F86C7F00037FC67F01071380EB007F141F00C0EB + 0FC01407A26C1303A37EA26CEB07807EEC0F00B4131E38F3C07C38E1FFF038C03FC01A37 + 7DB521>177 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fs ecbx1440 14.4 45 + /Fs 45 123 df<151E153E15FE1403140F147FEB07FF0003B5FCB6FCA3EBF87FEAFC00C7 + FCB3B3B3A6007FB712FCA52E4E76CD42>49 DI< + 913807FFC0027F13FC0103B67E010F15E090261FF80313F890267FC0007F01FEC7EA3FFE + 48488148486E138013FE486C6C6D13C0804817E080A66C5B18C06C5B6C90C75AD8003816 + 8090C8FC4C1300A24C5A5F4C5A4B5B4B13C0030F5BDB7FFEC7FC91387FFFF816C016FCEE + FF80DA000313E09238007FF8EE3FFE707E70138018C07013E018F07013F8A218FC82A218 + FEA3EA03C0EA0FF0EA3FFC487EA2B5FCA218FCA25E18F8A26C4816F0495C4916E0D83FE0 + 4A13C06C485CD80FF04A1380D807FE91387FFE003B03FFE003FFFC6C90B65A6C6C15E001 + 0F92C7FC010114FCD9001F1380374F7BCD42>I<17FC1601A216031607160FA2161F163F + 167FA216FF5D5DA25D5D5D167F153E157E15FC15F8EC01F01403EC07E015C0EC0F80141F + EC3F00143E5C14FC495A5C495A1307495A5C49C7FC5B137E137C5B1201485A5B485A120F + 485A90C8FC123E127E5ABA1280A5C901FCC7FCAF021FB71280A5394F7CCE42>I<486C15 + 0601F0153E01FEEC01FED9FFF0133F91B65A5F5F5F5F5F94C7FC16FC5E16E093C8FC15FC + 01F0138091CAFCAC913807FF80023F13F891B512FE01F36E7E9026FFFC0113E09139E000 + 7FF891C76C7E496E7E01F86E7E5B7013804916C0C9FC18E08218F0A418F8A31203EA0FE0 + EA3FF8487EA212FF7FA218F0A25B5E6C4816E05B01C016C06CC85A18806C6C4A13007FD8 + 0FF04A5A6C6CECFFFCD803FE4913F02701FFE00F5B6C6CB612806D92C7FC010F14F80101 + 14C09026003FFCC8FC354F7ACD42>II<121F7F7FEBFF8091B8FCA4 + 5A18FE18FC18F818F0A218E018C018804817000180C8123E007EC9127E5F007C4B5A4C5A + 5F16074C5A484B5A4CC7FC167E167CC912FC4B5A4B5AA24B5A150F4B5AA24B5AA24BC8FC + 5DA25C5D1403A214075D140FA3141FA2143FA34A5AA414FFA65BAB6D5B6E5A6E5A6E5A38 + 5279D042>I<173FA24D7EA34D7EA24C7FA34C7FA24C7FA34C7FA24C7FA34C7F163E8304 + 7E80EE7C3F04FC8016F8830301814C7E03038116E0830307814C7E030F81168083031F81 + 1600834B81033E80037E82157C8403FC824B800201835D840203834B800207835D92B8FC + 4A83A34A8392C9FC4A83143E85027E84027C8202FC845C850101854A820103855C850107 + 854A82A2494884D93FF082B600F0020FB712C0A55A547CD363>65 + DI<932603FFF01407047F01 + FF140F0307B600E0131F033F03F8133F92B700FE137F02039126C003FF13FF020F01F8C7 + EA3FC1023F01C0EC0FE391B5C80003B5FC4901FC814949814901E082011F498249498292 + CA7E4948834948835A4A83485B4885A24849187FA2485B1B3FA2485B1B1FA25AA21B0091 + CDFCA2B5FCAE7EA280A36C1A1FA36C7FA21B3F6C7F1B3E6C7F1B7E6C6D187C6C1AFC6E18 + F86C19016D6CEF03F06D7E6FEE07E06D6DEE0FC001076DEE1F806D01F8EE3F006D6D16FE + 6D01FF4B5A023F01C0EC07F8020F01FCEC3FF00203903AFFC001FFC0020091B6C7FC033F + 15FC030715F0DB007F1480040301F0C8FC505479D25F>III73 + D76 + DII<93381FFF800303B512FC033FECFFC092B712F00207D9F80113FE021F903A80 + 001FFF804A48C700077FDAFFF8020113F049496E7F4901C0ED3FFC49496F7E4990C96C7E + 4948707F013F854948707F4948707F48864A8248864A177F48864849717EA3481B804A83 + 481BC0A44890CB6C13E0A5B51AF0AF6C1BE06E5FA46C1BC0A26E5F6C1B80A36C6D4D1300 + A26C6D4D5AA26C626C6D4C5B6E5E6C626D6C4C5B6E5E6D6D4B5B6D6D4B5B6D6D4B90C7FC + 6D6D4B5A01016D4A13F86D01FE02075B91263FFFC0013F13C06ED9F801B55A020790B648 + C8FC020116F8DA003F15C003074AC9FCDB001F1380545479D263>II82 D<003FBB12FCA59126C0007FEB000301FCC7ED003FD87F + F0F00FFE49180749180349180190C81600A2007E1A7EA3007C1A3EA500FC1A3F481A1FA6 + C91700B3B3AC49B912C0A550517BD05B>84 D87 D<003FB749B612FCA5D8000349C8000301E0C7FC6FDB + 007EC8FC7F6D6E5D6E6D4A5A19036E6D5D6E6D4A5A4F5A6E6D141F6E6D5D4FC9FC6E6D14 + 7E6E7F715B6E4B5A6FEBC0036F01E05B4E5A6F6D485A6FEBF81F616F6D48CAFC6FEBFE7E + A26F6D5A6F5CA2705B705B707FA2707F707FA2707F707FA24C80854C805EDC1FDF7F058F + 7FEE3F0FDC7E077F717F16FC4B486C7F03036D805E4B486D7F4B486D7F031F824C7F4BC7 + 6C7F037E6E7FA24B6E7F4A486E7F14034B6E804A486F7F4A5A021F707F4B6F7F4AC98002 + 7E82737F4A707F495AD90FFF707FB70203B712F0A55C527DD163>I97 D<913803FFE0023F13FE91 + B67E010315E0010F9038003FF8D93FFCEB07FC4948497E4948131F4849497E485B485BA2 + 4890C7FC5A5B003F6F5A705A705A007F92C8FC5BA312FFAD127F7FA3123F7F6CEE0F80A2 + 6C6D141F18006C6D5C6C6D143E6C6D147E6C6D5C6D6C495A6DB4EB07F0010F9038C01FE0 + 6D90B5128001014AC7FCD9003F13F80203138031387CB63A>99 D<943803FF80040FB5FC + A5EE003F170FB3A4913803FF80023F13F849B512FE0107ECFF8F011F9038C03FEF90273F + FE0007B5FCD97FF8130149487F484980484980484980488291C8FC5A5B123FA2127F5BA3 + 12FFAD127FA37F123FA3121F7F6C5E6C6D5C5F6C6D91B5FC6C6D5B6C6D4914E0D97FFCD9 + 0FEFEBFF80D91FFFEB7F8F010790B5120F010114FC6D6C13E00207010049C7FC41547CD2 + 49>I<913807FF80027F13F849B512FE01076E7E011F010313E0903A3FFC007FF0D97FF0 + 6D7E49486D7E4849130F48496D7E48824890C77E1880485A82003F17C0A3485A18E082A2 + 12FFA290B8FCA401FCCAFCA6127FA37F123FA2EF03E06C7E17076C17C06C6D140F18806C + 6D141F6C6DEC3F006C6D147ED97FFC495AD91FFFEB07F86D9038E03FF0010390B512C001 + 005D023F01FCC7FC020113E033387CB63C>IIII<133FEBFFC0487F487FA2487FA66C5BA26C5B6C5B013FC7FC + 90C8FCAEEB1FF8B5FCA512017EB3B3A6B612F0A51C547CD324>I107 DIII<913801FFC0023F13FE91B67E010315 + E0010F018013F8903A3FFC001FFED97FF0EB07FF49486D7F48496D7F48496D7F91C8127F + 4883488349153F001F83A2003F8349151FA2007F83A400FF1880AC007F1800A3003F5F6D + 153FA2001F5FA26C6C4B5AA26C6D4A5A6C5F6C6D495B6C6D495B6D6C4990C7FCD93FFCEB + 1FFE6DB46CB45A010790B512F0010115C0D9003F49C8FC020313E039387CB642>II<90393FF001FC + B590380FFF804B13E0037F13F09238FE1FF89138F1F83F00019138F07FFC6CEBF3E015C0 + ECF780A2ECFF00EE3FF84AEB1FF0EE0FE093C7FC5CA45CB3ABB612FEA52E367DB535> + 114 D<903903FFC00E011FEBFC1E90B6127E000315FE3907FE003FD80FF0130F48481303 + 48481301491300127F90C8127EA248153EA27FA27F01F091C7FC13FCEBFF806C13FEECFF + F06C14FE6F7E6C15E06C816C15FC6C81C681133F010F15801301D9000F14C0EC003F0307 + 13E0150100F880167F6C153FA2161F7EA217C07E6D143F17807F6DEC7F0001F85C6DEB03 + FE9039FF801FFC486CB512F0D8F81F14C0D8F00791C7FC39E0007FF02B387CB634>I<14 + 7CA614FCA41301A31303A21307A2130F131F133F137F13FF1203000F90B512FEB7FCA426 + 007FFCC8FCB3A9EE0F80ABEE1F006D7EA2011F143E806D6D5A6DEBC1F86DEBFFF001005C + 023F1380DA03FEC7FC294D7ECB33>IIIIII<003FB712FEA4DA000113FC01F815F801E05B494913F04915E090C75A4B13C0 + 007E4A1380A24B13004B5A007C5D5C4A5B5E5C4A5BC75C5C4A5B93C7FC5C4A5A495B5D5B + 4949131F5D5B495B5D49153F4990C7123E5C13FF485B4849147EA2484914FE485B4A1301 + 4815034849130791C7EA1FFC48EC01FFB8FCA430357CB43A>I E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Ft ectt1200 12 22 + /Ft 22 126 df44 + D<121FEA3F80EA7FC0EAFFE0A5EA7FC0EA3F80EA1F000B0B6C8A33>46 + D64 D97 + DIIII104 D<14E0EB03F8A2497EA36D5AA2EB00E091 + C8FCAA383FFFF8487FA47EEA0001B3AD007FB612C0B712E016F0A216E06C15C0243E78BD + 33>I<1570EC01FCA2EC03FEA3EC01FCA2EC00701500AA90383FFFFC4913FE90B5FCA27F + 7F90C7FCB3B3A9140115FCA21218007EEB03F81407B414F0140F9038803FE090B512C06C + 14806C14006C5B6C13F8000113E01F557BBD33>I<383FFFFC487FB5FCA27E7EC7FCB3B3 + AD003FB612F84815FCB712FEA26C15FC6C15F8273D7ABC33>108 + D<4AB4FC263FFC0713C0267FFE1F13F000FF017F7F91B5FC6CB67E6CEC07FEC6EBF801EC + F0004A7F4A7F5CA291C7FCA35BB3A43B3FFFF80FFFFC486D4813FEB56C4813FFA26C496C + 13FE6C496C13FC302C7FAB33>110 DI114 D<90381FFE0F90B5EA8F80000314FF120F5A5AEBF00738 + 7F800190C7FC00FE147F5A153FA37E007FEC1F0001C090C7FCEA3FF8EBFFC06C13FF6C14 + E0000314F8C680011F13FF01001480020713C0EC007FED1FE0007C140F00FEEC07F01503 + A27EA27F15076D14E06D130F6DEB3FC09038FE01FF90B61280160000FD5C00FC14F8D8F8 + 3F13E0D8780790C7FC242E79AC33>III<3B7FFF8007FFF8B56C4813FC6E5A + A24A7E6C496C13F8D80FC0C7EA0FC06D141F00071680A56D143F00031600A3EC0FC0EC1F + E0A23A01F83FF07EA3EC7FF8147CA20000157C9039FCFCFCFCA3ECF87CA2017C5C017D13 + 7EECF03EA2017F133FA26D486C5AA3ECC00F90390F8007C02E2B7EAA33>119 + D<3B7FFF801FFFE0B56C4813F06E4813F8A24A6C13F06C496C13E0D803F8C7EAFC000001 + 14015E7F000014036D5C137EA2017F495A7FA26E485A131FA26D6C485AA214E0010749C7 + FCA214F01303157EEB01F8A2157C010013FC14FC5D147C147DEC3FF0A36E5AA36E5AA214 + 1F5DA2143F92C8FCA3147EA214FE003F5B1301387F81F81383EB87F0139FEBFFE06C5B5C + 6C90C9FCEA0FFCEA03F02D427DAA33>121 D123 D125 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fu ecrm1200 12 34 + /Fu 34 122 df<121EEA7F8012FF13C0A213E0A3127FEA1E601200A413E013C0A3120113 + 80120313005A1206120E5A5A5A12600B1D78891B>44 DI<14FF + 010713E090381F81F890383E007C01FC133F4848EB1F8049130F4848EB07C04848EB03E0 + A2000F15F0491301001F15F8A2003F15FCA390C8FC4815FEA54815FFB3A46C15FEA56D13 + 01003F15FCA3001F15F8A26C6CEB03F0A36C6CEB07E0000315C06D130F6C6CEB1F806C6C + EB3F00013E137C90381F81F8903807FFE0010090C7FC28447CC131>48 + D50 D<14FF010713E0011F13F890387F + 00FE01FC133FD801F0EB1F804848EB0FC049EB07E00007EC03F048481301A290C713F848 + 1400A47FA26D130116F07F6C6CEB03E013FC6C6CEB07C09039FF800F806C9038C01F006C + EBF03EECF87839007FFEF090383FFFC07F01077F6D13F8497F90381E7FFFD97C1F138049 + 6C13C02601E00313E048486C13F000079038007FF84848EB3FFC48C7120F003EEC07FE15 + 0148140016FF167F48153FA2161FA56C151E007C153EA2007E153C003E157C6C15F86DEB + 01F06C6CEB03E06C6CEB07C0D803F8EB1F80C6B4EBFF0090383FFFFC010F13F001011380 + 28447CC131>56 D66 DII73 D<010FB512FEA3D9000313806E130080B3B3AB123F48 + 7E487EA44A5A13801300006C495A00705C6C13076C5C6C495A6CEB1F802603E07FC7FC38 + 00FFFCEB1FE027467BC332>I<49B41303010FEBE007013F13F89039FE00FE0FD801F813 + 1FD807E0EB079F49EB03DF48486DB4FC48C8FC4881003E81127E82127C00FC81A282A37E + 82A27EA26C6C91C7FC7F7FEA3FF813FE381FFFE06C13FE6CEBFFE06C14FC6C14FF6C15C0 + 013F14F0010F80010180D9001F7F14019138001FFF03031380816F13C0167F163F161F17 + E000C0150FA31607A37EA36C16C0160F7E17806C151F6C16006C5D6D147ED8FBC05CD8F9 + F0495AD8F07C495A90393FC00FE0D8E00FB51280010149C7FC39C0003FF02B487BC536> + 83 D<003FB912F8A3903BF0001FF8001F01806D481303003EC7150048187C0078183CA2 + 0070181CA30060180CA5481806A5C81600B3B3A54B7EED7FFE49B77EA33F447DC346>I< + B600C0010FB5FCA3000101E0C813F026007F80ED1F80F00F00A21806B3B3A7180E6D6C15 + 0CA2181C131F6E1518010F163818306D6C1570606D6C14016D6C5D6D6CEC0780027F4AC7 + FC6E6C131EDA1FE0137C913907FC03F00201B55A6E6C1380DB07FCC8FC40467CC349>I< + B60107B500F890380FFFFEA3000301E0D9001F90C813F06C0180DA0FFCED3FC091C86C48 + ED1F006C871C0E6D6C6E7E1C0CA26D6C6F5DA36EDA06FF1538011F1A30A26E020E6D1470 + 010FDB0C7F1560A26E021C7F0107DB183F5DA2856D6CDA301F4A5AA36D6C4A6C6C49C7FC + A36D6C4A6C6C1306A3DB80016D6C130E027F0280150CA2DBC00380023FDA00015CA203E0 + 81021F01066D5CA36E6C486E6C5AA36E6C486E6C5AA36F48EC1FE1020360A2DBFE7015F3 + 02010160020F90C8FCA2DBFFE015FB6E49EC07FEA36F486E5AA36FC86C5AA3031E6F5AA3 + 1A70030C16605F467EC364>87 D97 DII<167FED3FFFA315018182B3EC7F80 + 903803FFF090380FC07C90383F000E017E1307496D5AD803F87F48487F5B000F81485AA2 + 485AA2127FA290C8FC5AAB7E7FA2123FA26C7EA2000F5D7F6C6C5B00035C6C6C9038077F + 806C6C010E13C0013F011C13FE90380FC0F8903803FFE09026007F0013002F467DC436> + IIIIII108 DI<3901FC01FE00FF903807FFC091381E07F0913838 + 01F8000701707F0003EBE0002601FDC07F5C01FF147F91C7FCA25BA35BB3A8486CECFF80 + B5D8F83F13FEA32F2C7DAB36>II<3901FC + 03FC00FF90380FFF8091383C07E091387001F83A07FDE000FE00010180137F01FFEC3F80 + 91C7EA1FC04915E049140F17F0160717F8160317FCA3EE01FEABEE03FCA3EE07F8A217F0 + 160F6D15E0EE1FC06D143F17806EEB7E00D9FDC05B9039FCF003F891383C0FE091381FFF + 80DA03FCC7FC91C9FCAE487EB512F8A32F3F7DAB36>I<3903F803F000FFEB1FFCEC3C3E + EC707F0007EBE0FF3803F9C000015B13FBEC007E153C01FF13005BA45BB3A748B4FCB512 + FEA3202C7DAB26>114 D<90383FE0183901FFFC383907E01F78390F0003F8001E130148 + 1300007C1478127800F81438A21518A27EA27E6C6C13006C7E13FC383FFFE06C13FC6C13 + FF6C14C06C14E0C614F0011F13F81300EC0FFC140300C0EB01FE1400157E7E153EA27EA3 + 6C143C6C147C15786C14F86CEB01F039F38003E039F1F00F8039E07FFE0038C00FF01F2E + 7DAC26>I<1306A5130EA4131EA3133E137EA213FE12011207001FB512F0B6FCA2C648C7 + FCB3A4150CAA017E131C017F1318A26D133890381F8030ECC070903807E0E0903801FFC0 + 9038007F001E3E7EBC26>III121 D E + %EndDVIPSBitmapFont + %DVIPSBitmapFont: Fv ecbx1728 17.28 19 + /Fv 19 117 df<183FA24E7EA34E7EA24D7FA34D7FA24D7FA34D7FA24D7FA34D7FA24D80 + 177D177C05FC805F84DC01F0808404038117E08404078117C0040F6D7F178084041F8117 + 004C6D7F163E84047E82167C04FC6D805E850301835E03036F7F5E850307835E854B4882 + 85031F8393C8FC854B83033E81037E84157C037FB9FC92BA7EA24A85A203F0C9123F0203 + 855D0207717F5D86020F855D021F717F92CAFC864A85143E027E7180147C8602FC865C87 + 0101874A840103875C496C84D97FFF86B70303B812C0A56A647BE375>65 + D69 D73 + D76 + DI80 D82 DI86 + D<913803FFF0027F13FF0103B612E0010F15F890263FFC0013FED97FC090381FFF8049C7 + 6C7F4801C06D7F486D6D7F6E6D7F48836E7F84177F84A36C496E7FA26C5B6C5B013FC8FC + 90C9FCA75F0307B6FC4AB7FC141F91B5EAF03F0103EBFE00010F13F0013F1380D9FFFEC7 + FC485B485B485B485B485B485BA24890C8FC1A7CA2485AA35FA394B5FC7F6C5D6EEB03DF + 6CDB07CFEBC0F86C6DEB0F8F6C6DD91F07EBF3F06C01F8017E14FF6C9027FE01FC0314E0 + C690B5D8F00114C0013F9126C0007F1380010791C7383FFE009026003FF8EC07F846437B + C14D>97 D101 DI105 D<903807FF80B6FCA5C6 + FC7F7FB3B3B3B3AFB712E0A523647CE32A>108 DII<92381FFF804AB512F8020F14FF + 023F15C09126FFFC0313F001039039E0007FFC490180EB1FFED91FFEC73807FF8049486E + 7F49486E7F49486E7F48496F7EA248496F7E4884A248496F7EA2481980A24819C091C97E + A24819E0A5B518F0AD6C19E0A46C6D4B13C0A36C1980A26C6D4B1300A26C606E157F6C60 + 6C6D4B5A6C606D6C4A5B6D6C4A5B6D6C4A5B6D6C6C011F90C7FC010301E0EB7FFC6D9039 + FC03FFF86D6CB612E0020F92C8FC020114F8DA001F138044437CC14D>I<903B07FF8001 + FFE0B6011F13FE047FEBFFC00381B612F0922687FC0313FC923A9FE0007FFEC6DABF806D + 6C7E6D01FEC7000F7F6D496E7F4B824B6E7F4B6E7F4B804B82737EA21B80851BC0A2851B + E0A4851BF0AE4F13E0A41BC061A21B80A24F1300A24F5AA26F4A5B6F4A5B626F4A5B6F4A + 5B03FE4A5B03BF027F90C7FCDB9FC0EBFFFC92268FF8075B0383B612E003801580043F01 + FCC8FC0403138093CBFCB3A4B712E0A54C5D7CC056>I116 D E + %EndDVIPSBitmapFont + end + %%EndProlog + %%BeginSetup + %%Feature: *Resolution 600dpi + TeXDict begin + %%BeginPaperSize: Letter + letter + %%EndPaperSize + end + %%EndSetup + %%Page: 1 1 + TeXDict begin 1 0 bop 627 432 a Fv(An)51 b(LL)-17 b(VM)51 + b(Implemen)l(tation)h(of)h(SSAPRE)876 672 y Fu(T)-8 b(an)m(y)m(a)34 + b(Brethour)183 b(Jo)s(el)32 b(Stanley)183 b(Bill)30 b(W)-8 + b(endling)1023 789 y(Univ)m(ersit)m(y)33 b(of)f(Illinois)e(at)i + (Urbana-Champaign)1002 905 y Ft({tbrethou,jstanley,jwendlin)q(}@ui)q + (uc.e)q(du)1571 1100 y Fu(Decem)m(b)s(er)i(8,)f(2002)0 + 1457 y Fs(1)131 b(In)l(tro)t(duction)0 1639 y Fr(One)23 + b(of)g(the)g(primary)f(goals)g(of)h(a)f(compiler)h(is)g(to)g(eliminate) + g(redundan)n(t)g(computations)f(presen)n(t)g(in)i(the)f(input)h + (program.)0 1739 y(Suc)n(h)36 b(redundancy)g(elimination)g(is)g(esp)r + (ecially)g(b)r(ene\034cial)g(in)h(lo)r(ops,)h(since)e(eliminating)g + (computations)g(from)g(a)g(fre-)0 1838 y(quen)n(tly)24 + b(executed)f(region)g(of)g(co)r(de)h(can)f(lead)g(to)h(massiv)n(e)e(p)r + (erformance)h(gains)g(in)h(the)g(program)d(o)n(v)n(erall.)34 + b(T)-7 b(w)n(o)23 b(indep)r(en-)0 1938 y(den)n(t)g(compiler)g + (optimizations)f(are)g(customarily)g(used)h(to)g(eliminate)g + (redundancies:)34 b(Global)22 b(Common)h(Sub)r(expression)0 + 2038 y(Elimination)h(\(GCSE\))h(and)f(Lo)r(op)f(In)n(v)-5 + b(arian)n(t)23 b(Co)r(de)g(Motion)h(\(LICM\).)g(GCSE)h(essen)n(tially)d + (replaces)h(computation)g(sites)0 2137 y(with)h(a)e(sa)n(v)n(ed)g(v)n + (ersion)f(of)i(a)g(computation,)h(pro)n(vided)e(that)h(the)h(v)-5 + b(alue)23 b(of)g(the)g(computation)g(has)f(not)h(b)r(een)h(altered)e + (since)0 2237 y(the)f(last)g(time)g(it)g(w)n(as)f(made.)35 + b(Lo)r(op-in)n(v)-5 b(arian)n(t)18 b(co)r(de)j(motion)g(is)f(resp)r + (onsible)g(for)h(hoisting)f(lo)r(op-in)n(v)-5 b(arian)n(t)19 + b(computations)0 2336 y(from)27 b(the)h(b)r(o)r(dy)g(of)f(a)h(lo)r(op)f + (or)f(lo)r(op)i(nest,)f(pro)n(vided)g(that)h(it)g(can)f(safely)g(do)g + (so.)125 2436 y(Ho)n(w)n(ev)n(er,)c(neither)j(LICM)f(nor)g(GCSE)h(can)f + (handle)h Fq(p)l(artial)35 b Fr(redundancies:)g(redundan)n(t)25 + b(computations)g(that)h(o)r(ccur)0 2536 y(on)h(some)f(execution)h + (paths)g(reac)n(hing)e(a)i(giv)n(en)f(p)r(oin)n(t,)h(but)h(not)f(on)f + (others.)36 b(A)n(ddressing)26 b(this)h(de\034ciency)g(is)g(the)g(goal) + f(of)0 2635 y(a)j(p)r(o)n(w)n(erful)g(data\035o)n(w-based)e + (optimization)i(kno)n(wn)g(as)g(P)n(artial)g(Redundancy)g(Elimination)h + (\(PRE\).)i(PRE)e(e\033ectiv)n(ely)0 2735 y(subsumes)20 + b(b)r(oth)g(LICM)g(and)f(GCSE,)i(in)f(addition)g(to)g(safely)f + (transforming)g(partial)g(redundancies)g(to)g(full)i(redundancies,)0 + 2835 y(whic)n(h)27 b(can)h(then)g(b)r(e)g(remo)n(v)n(ed.)125 + 2934 y(In)e(this)g(rep)r(ort)f(w)n(e)h(presen)n(t)f(implemen)n(tation)h + (details,)g(empirical)g(p)r(erformance)e(data,)i(and)g(notable)g(mo)r + (di\034cations)0 3034 y(to)40 b(an)h(algorithm)e(for)h(PRE)i(based)e + (on)g([1].)75 b(In)41 b([1],)j(a)c(particular)f(realization)g(of)h + (PRE,)i(kno)n(wn)e(as)g(SSAPRE,)i(is)0 3133 y(describ)r(ed,)23 + b(whic)n(h)f(is)g(more)f(e\036cien)n(t)h(than)g(traditional)g(PRE)h + (implemen)n(tations)f(b)r(ecause)f(it)i(relies)e(on)h(useful)g(prop)r + (erties)0 3233 y(of)g(Static)h(Single-Assignmen)n(t)e(\(SSA\))i(form)f + (to)g(p)r(erform)g(data\035o)n(w)f(analysis)f(in)j(a)f(m)n(uc)n(h)g + (more)f(sparse)g(manner)g(than)i(the)0 3333 y(traditional)e(bit-v)n + (ector-based)e(approac)n(h.)33 b(Our)20 b(implemen)n(tation)i(is)f(sp)r + (eci\034c)h(to)f(a)g(SSA-based)g(compiler)g(infrastructure)0 + 3432 y(kno)n(wn)27 b(as)g(LL)-9 b(VM)27 b(\(Lo)n(w-Lev)n(el)f(Virtual)i + (Mac)n(hine\).)125 3532 y(This)f(pap)r(er)g(describ)r(es)f(the)i + (curren)n(t)e(state)i(of)f(our)f(implemen)n(tation)i(using)f(the)g(LL) + -9 b(VM)28 b(infrastructure,)e(and)h(delin-)0 3632 y(eates)g(imp)r + (ortan)n(t)g(mo)r(di\034cations)g(to)h(the)g(algorithm)e(describ)r(ed)h + (in)h([1].)0 3906 y Fs(2)131 b(Existing)46 b(W)-11 b(ork)0 + 4088 y Fr(PRE)36 b(w)n(as)f(\034rst)g(dev)n(elop)r(ed)f(b)n(y)h(Morel)f + (and)h(Ren)n(v)n(oise)f([1979].)58 b(Their)35 b(implemen)n(tation)g + (used)g(data\035o)n(w)f(analysis)g(to)0 4188 y(determine)g(partial)e + (redundancies)h(and)g(eliminate)h(them.)55 b(This)34 + b(metho)r(d)g(w)n(as)e(enhanced)i(b)n(y)f(the)h(in)n(tro)r(duction)f + (of)g(a)0 4287 y(co)r(de)j(placemen)n(t)f(strategy)f(called)i(lazy)f + (co)r(de)h(motion)f(\(LCM\))h([3],)i(whic)n(h)e(\034nds)g(the)g + (optimal)g(placemen)n(t)f(for)g(co)r(de)0 4387 y(within)27 + b(a)f(con)n(trol)f(\035o)n(w)g(graph)h(\(CF)n(G\).)g(Ho)n(w)n(ev)n(er,) + f(the)i(previous)e(v)n(ersions)f(of)j(PRE)g(are)e(based)h(on)g(a)g + (bit-v)n(ector)f(form)n(u-)0 4486 y(lation)j(of)h(the)g(problem)f(and)g + (on)h(the)g(iterativ)n(e)e(solution)h(of)h(data)f(\035o)n(w)g + (equations[1)o(].)40 b(The)28 b(primary)g(dra)n(wbac)n(k)e(to)j(the)0 + 4586 y(application)22 b(of)h(bit-v)n(ector-based)d(data\035o)n(w)i + (optimizations)g(to)h(an)f(SSA)i(in)n(termediate)e(represen)n(tation)f + (is)i(the)g(high)g(cost)0 4686 y(of)29 b(represen)n(tational)d(con)n(v) + n(ersion.)38 b(In)29 b(order)e(to)i(propagate)d(the)j(data\035o)n(w)f + (predicates)g(prop)r(erly)-7 b(,)28 b(the)h(IR)g(is)f(essen)n(tially)0 + 4785 y(tak)n(en)g(out)h(of)f(SSA)i(form)e(prior)f(to)i(the)g(analysis)e + (and)i(put)g(bac)n(k)f(in)n(to)g(SSA)i(form)e(after,)h(a)f(pro)r(cess)f + (whic)n(h)i(incurs)f(high)0 4885 y(compile-time)f(cost.)125 + 4985 y(The)40 b(SSAPRE)j(pap)r(er)d(pro)n(vides)f(an)i(SSA-based)f(v)n + (ersion)f(of)i(PRE)h(whic)n(h)f(com)n(bines)f(the)h(optimal)f(placemen) + n(t)0 5084 y(prop)r(erties)30 b(of)g(the)i(previous)d(algorithms)g(for) + i(PRE)h(with)f(SSA's)g(sparse)e(use-de\034nition)i(information.)45 + b(In)31 b(particular,)0 5184 y(it)f(lev)n(erages)e(features)h(of)h(SSA) + g(suc)n(h)g(as)f(the)h(single-assignmen)n(t)e(prop)r(ert)n(y)g(and)i + (dominance)f(in)n(v)-5 b(arian)n(ts)29 b(so)g(that)h(PRE)0 + 5283 y(analysis)c(costs)h(are)g(greatly)f(reduced)h(in)h(comparison)e + (to)h(the)h(traditional)f(approac)n(hes.[1)m(])1929 5589 + y(1)p eop end + %%Page: 2 2 + TeXDict begin 2 1 bop 0 83 a Fs(3)131 b(Ov)l(erview)0 + 281 y Fp(3.1)112 b(De\034nitions)0 435 y Fr(W)-7 b(e)28 + b(\034rst)f(presen)n(t)g(a)g(few)h(de\034nitions)g(from)f([1])g(whic)n + (h)h(w)n(e)f(use)g(throughout)g(this)h(pap)r(er:)125 + 634 y Fq(De\034nition)e(\(R)l(e)l(dundant\):)40 b Fr(If)25 + b Fo(E)1171 646 y Fn(1)1234 634 y Fr(and)f Fo(E)1453 + 646 y Fn(2)1515 634 y Fr(are)g(o)r(ccurrences)f(of)i(some)f + (computation)g Fo(E)30 b Fr(and)25 b(there)f(is)h(a)f(con)n(trol)g + (\035o)n(w)0 734 y(path)34 b(from)g Fo(E)464 746 y Fn(1)536 + 734 y Fr(to)g Fo(E)705 746 y Fn(2)777 734 y Fr(con)n(taining)f(nothing) + h(that)g(ma)n(y)g(alter)f(the)i(v)-5 b(alue)34 b(of)g + Fo(E)5 b Fr(,)36 b(w)n(e)e(sa)n(y)f(that)h Fo(E)3194 + 746 y Fn(2)3266 734 y Fr(is)g Fq(r)l(e)l(dundant)h(with)0 + 833 y(r)l(esp)l(e)l(ct)29 b(to)h Fo(E)431 845 y Fn(1)469 + 833 y Fr(.[1)o(])125 1032 y Fq(De\034nition)f(\(Partial)t(ly)j(A)n + (vailable\):)44 b Fr(W)-7 b(e)27 b(sa)n(y)g(a)g(computation)g(is)g + Fq(p)l(artial)t(ly)32 b(available)k Fr(at)28 b(some)f(p)r(oin)n(t)g + Fo(p)h Fr(in)f(the)h(pro-)0 1132 y(gram)35 b(if)h(there)g(is)g(a)g(con) + n(trol)f(\035o)n(w)g(path)h(leading)g(to)g Fo(p)g Fr(from)g(some)f + (real)g(o)r(ccurrence)g(of)h(the)g(computation)g(and)g(not)0 + 1232 y(crossing)26 b(an)n(ything)h(that)g(ma)n(y)g(alter)g(the)h(v)-5 + b(alue)27 b(of)h(the)g(computation.[1)o(])125 1431 y + Fq(De\034nition)g(\(Partial)t(ly)i(R)l(e)l(dundant\):)41 + b Fr(W)-7 b(e)27 b(sa)n(y)e(an)h(o)r(ccurrence)f Fo(!)k + Fr(is)d Fq(p)l(artial)t(ly)31 b(r)l(e)l(dundant)i Fr(if)27 + b(it)g(is)f(an)g(o)r(ccurrence)f(of)0 1531 y(a)i(computation)g(that)h + (is)g(partially)e(a)n(v)-5 b(ailable)26 b(just)j(b)r(efore)e + Fo(!)s Fr(.[1)o(])125 1730 y Fq(De\034nition)35 b(\()p + Fm(\010)p Fq(\):)54 b Fr(In)33 b(the)h(same)f(w)n(a)n(y)g(that)h(the)g + (literature)f(uses)g(a)g Fo(\036)h Fr(op)r(erator)e(in)i(SSA)g(form)f + (to)h(factor)f(the)h(use-)0 1829 y(def)d(relation)f(for)h(v)-5 + b(ariables,)30 b(w)n(e)h(in)n(tro)r(duce)f(a)h Fm(\010)g + Fr(op)r(erator)e(that)i(factors)f(the)h(redundancy)f(relation)g(for)g + (computation)0 1929 y(o)r(ccurrences.[1)n(])125 2128 + y Fq(De\034nition)e(\()p Fl(?)p Fq(\):)41 b Fr(There)25 + b(can)h(b)r(e)h(op)r(erands)e(of)h Fm(\010)g Fr(that)h(are)e(not)h + (partially)f(redundan)n(t;)h(these)h(ha)n(v)n(e)e(no)h(coun)n(terpart)0 + 2228 y(in)i(SSA)g(form,)f(and)h(w)n(e)f(denote)g(them)h(b)n(y)g(the)g + (sym)n(b)r(ol)f Fl(?)p Fr(.[1)o(])125 2427 y Fq(De\034nition)38 + b(\(R)l(epr)l(esentative)g(Oc)l(curr)l(enc)l(e\):)60 + b Fr(W)-7 b(e)37 b(de\034ne)h(the)f Fq(r)l(epr)l(esentative)i(o)l(c)l + (curr)l(enc)l(e)k Fr(for)36 b(an)h(expression)e(to)0 + 2527 y(b)r(e)e(the)f(nearest)g(expression)e(that)j(is)f(either)g(a)g + Fm(\010)g Fr(Occurrence)f(or)g(a)h(non-partially)f(redundan)n(t)h(real) + f(o)r(ccurrence)g(that)0 2626 y(dominates)c(the)h(expression.)35 + b([1])0 2958 y Fp(3.2)112 b(SSAPRE)36 b(Algorithm)0 3112 + y Fr(The)27 b(pap)r(er)g(presen)n(ts)g(t)n(w)n(o)g(v)n(ersions)e(of)j + (the)g(SSAPRE)h(algorithm.)35 b(The)28 b(\034rst)f(v)n(ersion)f(pro)n + (vides)g(ev)n(erything)g(necessary)0 3211 y(to)31 b(create)f(a)g(w)n + (orking)f(v)n(ersion)g(of)i(SSAPRE)h(for)f(a)f(compiler.)46 + b(There)30 b(are)g(six)g(steps)h(in)g(the)g(algorithm:)42 + b Fm(\010)33 b Fq(Insertion)p Fr(,)0 3311 y Fq(R)l(ename)p + Fr(,)40 b Fq(DownSafety)p Fr(,)h Fq(Wil)t(lBeA)n(vail)p + Fr(,)h Fq(Finalize)p Fr(,)g(and)37 b Fq(Co)l(deMotion)p + Fr(.)69 b(Ho)n(w)n(ev)n(er,)38 b(this)g(v)n(ersion)e(isn't)i(sparse)e + (\(there)0 3411 y(are)29 b(p)r(oten)n(tially)g(extraneous)f + Fm(\010)i Fr(no)r(des)g(placed)f(in)n(to)g(the)h(graph,)g(and)f(the)h + (naiv)n(e)f(rename)g(algorithm)f(considers)h(man)n(y)0 + 3510 y(v)n(ersions)38 b(of)j(v)-5 b(ariables)38 b(that)j(ma)n(y)f(not)g + (app)r(ear)f(in)i(an)n(y)e(PRE)i(candidate)f(expression\))f(and)h + (deals)g(with)h(all)f(of)g(the)0 3610 y(expressions)26 + b(in)i(the)g(program)d(sim)n(ultaneously)-7 b(,)27 b(whic)n(h)g(can)g + (induce)h(a)f(large)f(memory)h(fo)r(otprin)n(t.)125 3709 + y(The)33 b(second)g(v)n(ersion)f(of)h(the)h(algorithm)f(is)g(a)g + (practical)g(implemen)n(tation)g(of)h(SSAPRE.)h(It)f(is)f(a)h(w)n + (orklist)e(driv)n(en)0 3809 y(v)n(ersion)25 b(of)h(the)h(algorithm)e + (and)h(requires)f(a)h(prepass)f(o)n(v)n(er)f(the)j(co)r(de)f(to)g + (collect)g(all)g(lexically)g(iden)n(ti\034ed)g(o)r(ccurrences)f(of)0 + 3909 y(expressions)g(in)n(to)h(lexically)f(equiv)-5 b(alen)n(t)26 + b(sets.)37 b(Once)26 b(this)g(is)g(done,)h(ho)n(w)n(ev)n(er,)d(w)n(e)i + (no)h(longer)e(need)h(to)g(lo)r(ok)g(at)g(all)g(of)h(the)0 + 4008 y(co)r(de)k(again)e(but)j(only)e(at)h(the)g(collected)g(o)r + (ccurrences.)45 b(Eac)n(h)30 b(collected)h(o)r(ccurrence)e(set)i(is)g + (placed)g(in)n(to)f(the)h(w)n(orklist)0 4108 y(then)39 + b(remo)n(v)n(ed)f(one)g(at)h(a)g(time)g(so)g(that)g(the)g(algorithm)f + (can)h(b)r(e)g(applied)g(to)g(it.)71 b(The)39 b(practical)f(implemen)n + (tation)0 4208 y(algorithm)28 b(replaces)f(the)i(\034rst)g(t)n(w)n(o)f + (parts)g(of)g(the)h(initial)g(algorithm)f(\025)g Fm(\010)j + Fq(Insertion)k Fr(and)29 b Fq(R)l(ename)34 b Fr(\025)29 + b(with)g(a)f(demand-)0 4307 y(driv)n(en)g(v)n(ersion)e(of)j + Fm(\010)h Fq(Insertion)35 b Fr(and)28 b(a)g(dela)n(y)n(ed)f(v)n(ersion) + g(of)h Fq(R)l(ename)p Fr(.)39 b(See)28 b(Figure)g(1)g(for)f(a)h + (graphical)f(represen)n(tation)0 4407 y(of)h(the)f(implemen)n(tation)h + (of)g(the)f(w)n(orklist)g(driv)n(en)g(algorithm.)125 + 4506 y(W)-7 b(e)27 b(c)n(hose)g(to)g(implemen)n(t)i(the)e(w)n(orklist)g + (driv)n(en)g(v)n(ersion)f(of)h(the)h(algorithm.)0 4781 + y Fs(4)131 b(Implemen)l(tation)0 4963 y Fr(While)36 b(w)n(e)e(c)n(hose) + g(to)h(implemen)n(t)g(the)h(w)n(orklist)e(driv)n(en)g(v)n(ersion)f(of)i + (the)h(SSAPRE)g(algorithm,)g(our)e(implemen)n(tation)0 + 5062 y(do)r(esn't)i(actually)f(use)h(the)h(w)n(orklist)e(in)h(the)g(w)n + (a)n(y)f(a)h(traditional)f(w)n(orklist)g(is)g(used.)63 + b(In)36 b(the)g(pap)r(er,)i(the)e(w)n(orklist)f(is)0 + 5162 y(needed)27 b(for)f(\020comp)r(ound\021)32 b(expressions)25 + b(\(those)i(of)f(the)h(form)f Fo(a)17 b Fm(+)f Fo(b)g + Fl(\000)g Fo(c)p Fr(,)27 b(where)f Fo(a)16 b Fm(+)g Fo(b)26 + b Fr(is)h(a)f(sub)r(expression)f(of)i(the)f(whole)0 5262 + y(expression\).)36 b(LL)-9 b(VM)27 b(is)h(a)f(three-address)e(represen) + n(tation)h(and)h(do)r(esn't)h(allo)n(w)f(for)g(comp)r(ound)g + (expressions.)1929 5589 y(2)p eop end + %%Page: 3 3 + TeXDict begin 3 2 bop 992 2317 a @beginspecial 14 @llx + 14 @lly 244 @urx 292 @ury 2300 @rwi @setspecial + %%BeginDocument: Worklist.ps + %!PS-Adobe-3.0 + %%Creator: GIMP PostScript file plugin V 1.12 by Peter Kirchgessner + %%Title: /home/tonic/CS426/llvm/lib/Transforms/ssapre/doc/Worklist.ps + %%CreationDate: Sun Dec 8 08:59:58 2002 + %%DocumentData: Clean7Bit + %%LanguageLevel: 2 + %%Pages: 1 + %%BoundingBox: 14 14 244 292 + %%EndComments + %%BeginProlog + % Use own dictionary to avoid conflicts + 10 dict begin + %%EndProlog + %%Page: 1 1 + % Translate for offset + 14.173228 14.173228 translate + % Translate to begin of first scanline + 0.000000 277.200000 translate + 228.960000 -277.200000 scale + % Image geometry + 318 385 8 + % Transformation matrix + [ 318 0 0 385 0 0 ] + % Strings to hold RGB-samples per scanline + /rstr 318 string def + /gstr 318 string def + /bstr 318 string def + {currentfile /ASCII85Decode filter /RunLengthDecode filter rstr readstring pop} + {currentfile /ASCII85Decode filter /RunLengthDecode filter gstr readstring pop} + {currentfile /ASCII85Decode filter /RunLengthDecode filter bstr readstring pop} + true 3 + %%BeginData: 86600 ASCII Bytes + colorimage + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + rr2sgJL5ppasI2(s8RT~> + rr2sgJL5ppasI2(s8RT~> + rr2sgJL5ppasI2(s8RT~> + rr3!HH%CKsJB`TIGnes3s*t~> + rr3!HH%CKsJB`TIGnes3s*t~> + rr3!HH%CKsJB`TIGnes3s*t~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnZ)Tkrp8nEJcD\K!V%Q:s*t~> + rr3!HnZ)Tkrp8nEJcD\K!V%Q:s*t~> + rr3!HnZ)Tkrp8nEJcD\K!V%Q:s*t~> + rr3!HnZ)Tknj4S-kPkPFqYqJ`N,DsVf>E5CGE2_'\:KU,PMcE?`.Er2T?[<6!Mm5Vs6TadnL+>9 + J,~> + rr3!HnZ)Tknj4S-kPkPFqYqJ`N,DsVf>E5CGE2_'\:KU,PMcE?`.Er2T?[<6!Mm5Vs6TadnL+>9 + J,~> + rr3!HnZ)Tknj4S-kPkPFqYqJ`N,DsVf>E5CGE2_'\:KU,PMcE?`.Er2T?[<6!Mm5Vs6TadnL+>9 + J,~> + rr3!HnZ)TknN at hikPkO@q#;1I*TI,!e,Ym9p6[l!s3N.>rhV@!s4oT>r;QdT."VEbrrMX;rr7K~> + rr3!HnZ)TknN at hikPkO@q#;1I*TI,!e,Ym9p6[l!s3N.>rhV@!s4oT>r;QdT."VEbrrMX;rr7K~> + rr3!HnZ)TknN at hikPkO@q#;1I*TI,!e,Ym9p6[l!s3N.>rhV@!s4oT>r;QdT."VEbrrMX;rr7K~> + rr3!HnZ)TjrorV.rr>I^rsNW`irB&.!1 + rr3!HnZ)TjrorV.rr>I^rsNW`irB&.!1 + rr3!HnZ)TjrorV.rr>I^rsNW`irB&.!1 + rr3!HnZ)U4Z\5 at XEu$^FLHFDnN#*@4JN'k6V&:9+s",AnhIm*l;qh-K(i1/AnF4L!R/cG6#B$ro + o)8MR#@amWo)/Le"TCrN$^:Dd13aQU;MI6Fs,e-aV)?$fdVOk^d/O'^EKb0<-I3ECNAR:*FCf8d + l2Po;?'p1RlCCm_W;cng-iX-r~> + rr3!HnZ)U4Z\5 at XEu$^FLHFDnN#*@4JN'k6V&:9+s",AnhIm*l;qh-K(i1/AnF4L!R/cG6#B$ro + o)8MR#@amWo)/Le"TCrN$^:Dd13aQU;MI6Fs,e-aV)?$fdVOk^d/O'^EKb0<-I3ECNAR:*FCf8d + l2Po;?'p1RlCCm_W;cng-iX-r~> + rr3!HnZ)U4Z\5 at XEu$^FLHFDnN#*@4JN'k6V&:9+s",AnhIm*l;qh-K(i1/AnF4L!R/cG6#B$ro + o)8MR#@amWo)/Le"TCrN$^:Dd13aQU;MI6Fs,e-aV)?$fdVOk^d/O'^EKb0<-I3ECNAR:*FCf8d + l2Po;?'p1RlCCm_W;cng-iX-r~> + rr3!HnZ)U1pLRJ*s1K;ds&aUIs4J(?s1KV;nFR at Gs,Rrqs3;5Ors*?J=(5W9!1W4f)X@@'-b996*TJT'jM + 9f)G52gOlb%aV-S!V%Q:s*t~> + rr3!HnZ)U1pLRJ*s1K;ds&aUIs4J(?s1KV;nFR at Gs,Rrqs3;5Ors*?J=(5W9!1W4f)X@@'-b996*TJT'jM + 9f)G52gOlb%aV-S!V%Q:s*t~> + rr3!HnZ)U1pLRJ*s1K;ds&aUIs4J(?s1KV;nFR at Gs,Rrqs3;5Ors*?J=(5W9!1W4f)X@@'-b996*TJT'jM + 9f)G52gOlb%aV-S!V%Q:s*t~> + rr3!HnZ)U1pLRJ*s1L&Vs&`"qs4JOVs8Q7&fCT^.s,Rrqs3;5Ors*?\irB&.!1<`b(#ZK6$39;i + s6-k9%04WPs0AZ]IfQ5=s"_JBnGiMW at K51)j3Q"1!Rh#5)H#Q8XoE?Xs8T;[pqt2Q_5F&.B)hm* + =T at tF^&Ra*Yc7X'nL+>9J,~> + rr3!HnZ)U1pLRJ*s1L&Vs&`"qs4JOVs8Q7&fCT^.s,Rrqs3;5Ors*?\irB&.!1<`b(#ZK6$39;i + s6-k9%04WPs0AZ]IfQ5=s"_JBnGiMW at K51)j3Q"1!Rh#5)H#Q8XoE?Xs8T;[pqt2Q_5F&.B)hm* + =T at tF^&Ra*Yc7X'nL+>9J,~> + rr3!HnZ)U1pLRJ*s1L&Vs&`"qs4JOVs8Q7&fCT^.s,Rrqs3;5Ors*?\irB&.!1<`b(#ZK6$39;i + s6-k9%04WPs0AZ]IfQ5=s"_JBnGiMW at K51)j3Q"1!Rh#5)H#Q8XoE?Xs8T;[pqt2Q_5F&.B)hm* + =T at tF^&Ra*Yc7X'nL+>9J,~> + rr3!HnZ)U4pLRJ*s1L&Vs&`"qs4JOVs8Q7&fCT^.s,Rrqs3;5VlKe?I,&A:Zs8URKR/c>(ci=%B + E<,,U\GuU.M?(m#o0RG=E>(P0qYr=g/+ET=7:H5Q*TR1d!!1OJl5EP!NhOITg&M)V2#@7PdSNlq + DJ&qK9j%Ge0"q;X!3iI&!V%Q:s*t~> + rr3!HnZ)U4pLRJ*s1L&Vs&`"qs4JOVs8Q7&fCT^.s,Rrqs3;5VlKe?I,&A:Zs8URKR/c>(ci=%B + E<,,U\GuU.M?(m#o0RG=E>(P0qYr=g/+ET=7:H5Q*TR1d!!1OJl5EP!NhOITg&M)V2#@7PdSNlq + DJ&qK9j%Ge0"q;X!3iI&!V%Q:s*t~> + rr3!HnZ)U4pLRJ*s1L&Vs&`"qs4JOVs8Q7&fCT^.s,Rrqs3;5VlKe?I,&A:Zs8URKR/c>(ci=%B + E<,,U\GuU.M?(m#o0RG=E>(P0qYr=g/+ET=7:H5Q*TR1d!!1OJl5EP!NhOITg&M)V2#@7PdSNlq + DJ&qK9j%Ge0"q;X!3iI&!V%Q:s*t~> + rr3!HnZ)U4ojh/%rjscQs&Vqos4J7Gs326jlLY_ at s)f+Us3D;V_T2WT-3!jY*8phqdK#U3i;d?N + rUX,GlMsZ=rVC@]fDWsks8W(G"17q%rtWEpm/OX6T`3^ei;`bg&@VVQ(Nf\4rid=!rr9/Yp](7T + !OV]@Ac;U&=9%hC]DqI&Y5YI$!V%Q:s*t~> + rr3!HnZ)U4ojh/%rjscQs&Vqos4J7Gs326jlLY_ at s)f+Us3D;V_T2WT-3!jY*8phqdK#U3i;d?N + rUX,GlMsZ=rVC@]fDWsks8W(G"17q%rtWEpm/OX6T`3^ei;`bg&@VVQ(Nf\4rid=!rr9/Yp](7T + !OV]@Ac;U&=9%hC]DqI&Y5YI$!V%Q:s*t~> + rr3!HnZ)U4ojh/%rjscQs&Vqos4J7Gs326jlLY_ at s)f+Us3D;V_T2WT-3!jY*8phqdK#U3i;d?N + rUX,GlMsZ=rVC@]fDWsks8W(G"17q%rtWEpm/OX6T`3^ei;`bg&@VVQ(Nf\4rid=!rr9/Yp](7T + !OV]@Ac;U&=9%hC]DqI&Y5YI$!V%Q:s*t~> + rr3!HnZ)U4.!!!nos7?0h!<)iq#K%C4LdoJcL&M&ZhuE`4 at rH)rBaf>@AnL+>9J,~> + rr3!HnZ)U4.!!!nos7?0h!<)iq#K%C4LdoJcL&M&ZhuE`4 at rH)rBaf>@AnL+>9J,~> + rr3!HnZ)U4.!!!nos7?0h!<)iq#K%C4LdoJcL&M&ZhuE`4 at rH)rBaf>@AnL+>9J,~> + rr3!HnZ)U"`i,idb,D8cp8Fq5s4JOVqu7#pW2S%@\c;]oW4`'.!8d[Q!TDK+W#)K,]DosNW94-Z + ZN&=NW87L4W2Quns82bn!<2or!lHPXrVllJrhohhrr32HW6kSE93_Dq"c+/cW2Qitrt3t`_Z$sE + bG_B5d& + rr3!HnZ)U"`i,idb,D8cp8Fq5s4JOVqu7#pW2S%@\c;]oW4`'.!8d[Q!TDK+W#)K,]DosNW94-Z + ZN&=NW87L4W2Quns82bn!<2or!lHPXrVllJrhohhrr32HW6kSE93_Dq"c+/cW2Qitrt3t`_Z$sE + bG_B5d& + rr3!HnZ)U"`i,idb,D8cp8Fq5s4JOVqu7#pW2S%@\c;]oW4`'.!8d[Q!TDK+W#)K,]DosNW94-Z + ZN&=NW87L4W2Quns82bn!<2or!lHPXrVllJrhohhrr32HW6kSE93_Dq"c+/cW2Qitrt3t`_Z$sE + bG_B5d& + rr3!HnXfa_Shp_"_#FLr0+*a/rs#H4^[99J,~> + rr3!HnXfa_Shp_"_#FLr0+*a/rs#H4^[99J,~> + rr3!HnXfa_Shp_"_#FLr0+*a/rs#H4^[99J,~> + rr3!HnXfa_ZtX6Fci=$8o`##kBkaU9rrqbZKR;,EOoGIP-iX-r~> + rr3!HnXfa_ZtX6Fci=$8o`##kBkaU9rrqbZKR;,EOoGIP-iX-r~> + rr3!HnXfa_ZtX6Fci=$8o`##kBkaU9rrqbZKR;,EOoGIP-iX-r~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`*rrqFk$k*oiJcG$8!V%Q:s*t~> + rr3!HnU^`*rrqFk$k*oiJcG$8!V%Q:s*t~> + rr3!HnU^`*rrqFk$k*oiJcG$8!V%Q:s*t~> + rr3!HnU^`)rrfn=!D;C's6BUbnL+>9J,~> + rr3!HnU^`)rrfn=!D;C's6BUbnL+>9J,~> + rr3!HnU^`)rrfn=!D;C's6BUbnL+>9J,~> + rr3!HnU^`)rr_mB(=.R3l2LeS-iX-r~> + rr3!HnU^`)rr_mB(=.R3l2LeS-iX-r~> + rr3!HnU^`)rr_mB(=.R3l2LeS-iX-r~> + rr3!HnU^`(rrRpGo7?r+rrMX;rr7K~> + rr3!HnU^`(rrRpGo7?r+rrMX;rr7K~> + rr3!HnU^`(rrRpGo7?r+rrMX;rr7K~> + rr3!HnU^`(rrS-trdk+6rrMX;rr7K~> + rr3!HnU^`(rrS-trdk+6rrMX;rr7K~> + rr3!HnU^`(rrS-trdk+6rrMX;rr7K~> + rr3!HnY?*bNtTMP!>ZEk)?C2+U]1Ab-iX-r~> + rr3!HnY?*bNtTMP!>ZEk)?C2+U]1Ab-iX-r~> + rr3!HnY?*bNtTMP!>ZEk)?C2+U]1Ab-iX-r~> + rr3!HnY?*bMiNes!?6rlrrMX;rr7K~> + rr3!HnY?*bMiNes!?6rlrrMX;rr7K~> + rr3!HnY?*bMiNes!?6rlrrMX;rr7K~> + rr3!HnY?*bMiNes!?6rlrrMX;rr7K~> + rr3!HnY?*bMiNes!?6rlrrMX;rr7K~> + rr3!HnY?*bMiNes!?6rlrrMX;rr7K~> + rr3!HnY?*bMiRZ6#2,`^`lG$oqYp_LW;iMCqs47c`i-ScMsJ=]!?6rlrrMX;rr7K~> + rr3!HnY?*bMiRZ6#2,`^`lG$oqYp_LW;iMCqs47c`i-ScMsJ=]!?6rlrrMX;rr7K~> + rr3!HnY?*bMiRZ6#2,`^`lG$oqYp_LW;iMCqs47c`i-ScMsJ=]!?6rlrrMX;rr7K~> + rr3!HnY?*bMiR]7#Lll4s8VmjQhp^cBpJ^[!;cBg!W1. + rr3!HnY?*bMiR]7#Lll4s8VmjQhp^cBpJ^[!;cBg!W1. + rr3!HnY?*bMiR]7#Lll4s8VmjQhp^cBpJ^[!;cBg!W1. + rr3!HnY?*bMiR`8!rQr!rVlnQQhp^c8sTEr!;cBg!."G@!qoC!rr3&T+1&rd!?6rlrrMX;rr7K~> + rr3!HnY?*bMiR`8!rQr!rVlnQQhp^c8sTEr!;cBg!."G@!qoC!rr3&T+1&rd!?6rlrrMX;rr7K~> + rr3!HnY?*bMiR`8!rQr!rVlnQQhp^c8sTEr!;cBg!."G@!qoC!rr3&T+1&rd!?6rlrrMX;rr7K~> + rr3!HnY?*bMiR`8!llSMrVmo%`W+qtWo3pW5cjus1&LO#SA>1)e>oL"n=2GWm/6kaVCqiI3pJ6% + s6ZqgJ*$[NWhcQ?F27gD<69J,~> + rr3!HnY?*bMiR`8!llSMrVmo%`W+qtWo3pW5cjus1&LO#SA>1)e>oL"n=2GWm/6kaVCqiI3pJ6% + s6ZqgJ*$[NWhcQ?F27gD<69J,~> + rr3!HnY?*bMiR`8!llSMrVmo%`W+qtWo3pW5cjus1&LO#SA>1)e>oL"n=2GWm/6kaVCqiI3pJ6% + s6ZqgJ*$[NWhcQ?F27gD<69J,~> + rr3!HnY?*bMiRc9!obV5qYqGnKA4m?bPrI[s#B!/F10mqX5f`.]NkK1GPhCAbT;QRc&(4^t[k?B)V`1)iLKk + !V%Q:s*t~> + rr3!HnY?*bMiRc9!obV5qYqGnKA4m?bPrI[s#B!/F10mqX5f`.]NkK1GPhCAbT;QRc&(4^t[k?B)V`1)iLKk + !V%Q:s*t~> + rr3!HnY?*bMiRc9!obV5qYqGnKA4m?bPrI[s#B!/F10mqX5f`.]NkK1GPhCAbT;QRc&(4^t[k?B)V`1)iLKk + !V%Q:s*t~> + rr3!HnY?*bMiRc9!ndQYrVmr9h;;8Us7o$pl7W,.53JV8aN@>9<6,% + rr3!HnY?*bMiRc9!ndQYrVmr9h;;8Us7o$pl7W,.53JV8aN@>9<6,% + rr3!HnY?*bMiRc9!ndQYrVmr9h;;8Us7o$pl7W,.53JV8aN@>9<6,% + rr3!HnY?*bMiRc9"9,JlpAY('jk"W$jT"Pe6orV at Z9s-A8g.HLL.!DJ(DqZZrQ\9'R2 + rVlm;Mkg:QnL+>9J,~> + rr3!HnY?*bMiRc9"9,JlpAY('jk"W$jT"Pe6orV at Z9s-A8g.HLL.!DJ(DqZZrQ\9'R2 + rVlm;Mkg:QnL+>9J,~> + rr3!HnY?*bMiRc9"9,JlpAY('jk"W$jT"Pe6orV at Z9s-A8g.HLL.!DJ(DqZZrQ\9'R2 + rVlm;Mkg:QnL+>9J,~> + rr3!HnY?*bMiR`8,lDt_o(pnNr;W#)op:QuL6DS=C]E"RqXM\hKZsJKd)I'0\)7,`*;*dIs4_XE + o`)CfroqJsCuP9?hs + rr3!HnY?*bMiR`8,lDt_o(pnNr;W#)op:QuL6DS=C]E"RqXM\hKZsJKd)I'0\)7,`*;*dIs4_XE + o`)CfroqJsCuP9?hs + rr3!HnY?*bMiR`8,lDt_o(pnNr;W#)op:QuL6DS=C]E"RqXM\hKZsJKd)I'0\)7,`*;*dIs4_XE + o`)CfroqJsCuP9?hs + rr3!HnY?*bMiRZ6+jiJR\G?1)p-q!ch+&G?7jf]TqPQMmnc/&W7^rEtj[$uarrr:#7RG#lrr4j, + 7>1F8hF1;bs8S9QJIX/"+!8tg7iWi-s8V4N:W-p)(n#CN7(Du57?RTLdl^XcV7&m#mJQtb)iLKk + !V%Q:s*t~> + rr3!HnY?*bMiRZ6+jiJR\G?1)p-q!ch+&G?7jf]TqPQMmnc/&W7^rEtj[$uarrr:#7RG#lrr4j, + 7>1F8hF1;bs8S9QJIX/"+!8tg7iWi-s8V4N:W-p)(n#CN7(Du57?RTLdl^XcV7&m#mJQtb)iLKk + !V%Q:s*t~> + rr3!HnY?*bMiRZ6+jiJR\G?1)p-q!ch+&G?7jf]TqPQMmnc/&W7^rEtj[$uarrr:#7RG#lrr4j, + 7>1F8hF1;bs8S9QJIX/"+!8tg7iWi-s8V4N:W-p)(n#CN7(Du57?RTLdl^XcV7&m#mJQtb)iLKk + !V%Q:s*t~> + rr3!HnY?*bMiRW5!nGp"rVluSdf0";dKBL?dbt-)!o;;urr3#Mp%eUijjMr_rVmAodc^Z1rn#`s + s8VH6j44+V!VH-cdK&t>rtsD=ptF0Ek1nD5mf2Ium/R+`e(=QeqpO6rrrF'sU]1Ab-iX-r~> + rr3!HnY?*bMiRW5!nGp"rVluSdf0";dKBL?dbt-)!o;;urr3#Mp%eUijjMr_rVmAodc^Z1rn#`s + s8VH6j44+V!VH-cdK&t>rtsD=ptF0Ek1nD5mf2Ium/R+`e(=QeqpO6rrrF'sU]1Ab-iX-r~> + rr3!HnY?*bMiRW5!nGp"rVluSdf0";dKBL?dbt-)!o;;urr3#Mp%eUijjMr_rVmAodc^Z1rn#`s + s8VH6j44+V!VH-cdK&t>rtsD=ptF0Ek1nD5mf2Ium/R+`e(=QeqpO6rrrF'sU]1Ab-iX-r~> + rr3!HnY?*bMi*Mi!?-lkrrMX;rr7K~> + rr3!HnY?*bMi*Mi!?-lkrrMX;rr7K~> + rr3!HnY?*bMi*Mi!?-lkrrMX;rr7K~> + rr3!HnY?*aMi.Q8Mkg:QnL+>9J,~> + rr3!HnY?*aMi.Q8Mkg:QnL+>9J,~> + rr3!HnY?*aMi.Q8Mkg:QnL+>9J,~> + rr3!HnY?*afuL2o?H9,Ifq\QJnL+>9J,~> + rr3!HnY?*afuL2o?H9,Ifq\QJnL+>9J,~> + rr3!HnY?*afuL2o?H9,Ifq\QJnL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`*rrrAlJqE at cJcG$8!V%Q:s*t~> + rr3!HnU^`*rrrAlJqE at cJcG$8!V%Q:s*t~> + rr3!HnU^`*rrrAlJqE at cJcG$8!V%Q:s*t~> + rr3!HnU^`*rrM7hrVur5JcG$8!V%Q:s*t~> + rr3!HnU^`*rrM7hrVur5JcG$8!V%Q:s*t~> + rr3!HnU^`*rrM7hrVur5JcG$8!V%Q:s*t~> + rr3!HnU^`)rrg=L!bUkOs6BUbnL+>9J,~> + rr3!HnU^`)rrg=L!bUkOs6BUbnL+>9J,~> + rr3!HnU^`)rrg=L!bUkOs6BUbnL+>9J,~> + rr3!HnU^`)rr`$V*SQ)El2LeS-iX-r~> + rr3!HnU^`)rr`$V*SQ)El2LeS-iX-r~> + rr3!HnU^`)rr`$V*SQ)El2LeS-iX-r~> + rr3!HnU^`(rrS'Ron!/-rrMX;rr7K~> + rr3!HnU^`(rrS'Ron!/-rrMX;rr7K~> + rr3!HnU^`(rrS'Ron!/-rrMX;rr7K~> + rr3!HnU^`(rrJ(!JcFs6!V%Q:s*t~> + rr3!HnU^`(rrJ(!JcFs6!V%Q:s*t~> + rr3!HnU^`(rrJ(!JcFs6!V%Q:s*t~> + rr3!HnU^`(rrK!gJcFs6!V%Q:s*t~> + rr3!HnU^`(rrK!gJcFs6!V%Q:s*t~> + rr3!HnU^`(rrK!gJcFs6!V%Q:s*t~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnW3\Oqm4$5rrW/.\GZ@/rkto:r;Qlm^P_^JrrUW=a8Z)CjKbBWm>g^irrMX;rr7K~> + rr3!HnW3\Oqm4$5rrW/.\GZ@/rkto:r;Qlm^P_^JrrUW=a8Z)CjKbBWm>g^irrMX;rr7K~> + rr3!HnW3\Oqm4$5rrW/.\GZ@/rkto:r;Qlm^P_^JrrUW=a8Z)CjKbBWm>g^irrMX;rr7K~> + rr3!HnW3\OqP^dtrsSb+Y5eO^o)J[#T`+cf!pME*kPkR,QMpge]h/7gJ+!46!W1W1rrMX;rr7K~> + rr3!HnW3\OqP^dtrsSb+Y5eO^o)J[#T`+cf!pME*kPkR,QMpge]h/7gJ+!46!W1W1rrMX;rr7K~> + rr3!HnW3\OqP^dtrsSb+Y5eO^o)J[#T`+cf!pME*kPkR,QMpge]h/7gJ+!46!W1W1rrMX;rr7K~> + rr3!HnU^]ArkdsorrVF=m-"BLGF&4-!PM)!rrM<%N;iqK-iX-r~> + rr3!HnU^]ArkdsorrVF=m-"BLGF&4-!PM)!rrM<%N;iqK-iX-r~> + rr3!HnU^]ArkdsorrVF=m-"BLGF&4-!PM)!rrM<%N;iqK-iX-r~> + rr3!HnW3\ki6LBGbH]@<`V/*4i;(,a^=(uch#@>q_o1^;kqMK%s!m$GXR*d2oZ![+m`Whfs4ad$ + aI_[@QM]7Yk.O at TcI)Ice]u=Hf4LJsnW*VMnL+>9J,~> + rr3!HnW3\ki6LBGbH]@<`V/*4i;(,a^=(uch#@>q_o1^;kqMK%s!m$GXR*d2oZ![+m`Whfs4ad$ + aI_[@QM]7Yk.O at TcI)Ice]u=Hf4LJsnW*VMnL+>9J,~> + rr3!HnW3\ki6LBGbH]@<`V/*4i;(,a^=(uch#@>q_o1^;kqMK%s!m$GXR*d2oZ![+m`Whfs4ad$ + aI_[@QM]7Yk.O at TcI)Ice]u=Hf4LJsnW*VMnL+>9J,~> + rr3!HnW3\kqMK7LYqDfbE5hX=A,aG6iqN;R:&=m(PF..*kqMK%s!lW`.+j&JmuUEGP+]C:cd#+/ + V$4tbQLK%+qn5T!p)r5^X1bT(kt8JZrJpmYnL+>9J,~> + rr3!HnW3\kqMK7LYqDfbE5hX=A,aG6iqN;R:&=m(PF..*kqMK%s!lW`.+j&JmuUEGP+]C:cd#+/ + V$4tbQLK%+qn5T!p)r5^X1bT(kt8JZrJpmYnL+>9J,~> + rr3!HnW3\kqMK7LYqDfbE5hX=A,aG6iqN;R:&=m(PF..*kqMK%s!lW`.+j&JmuUEGP+]C:cd#+/ + V$4tbQLK%+qn5T!p)r5^X1bT(kt8JZrJpmYnL+>9J,~> + rr3!HnW*ViMJN7[5i)HbT`:Bbs3!gqs8TDqqZ#pImMZ&h0^S]:-hBaUb?+)Pq3OS.s4f=.A#fR` + oQQ:nlMpmt8cSf.h-j43iNquI^5W'mnL+>9J,~> + rr3!HnW*ViMJN7[5i)HbT`:Bbs3!gqs8TDqqZ#pImMZ&h0^S]:-hBaUb?+)Pq3OS.s4f=.A#fR` + oQQ:nlMpmt8cSf.h-j43iNquI^5W'mnL+>9J,~> + rr3!HnW*ViMJN7[5i)HbT`:Bbs3!gqs8TDqqZ#pImMZ&h0^S]:-hBaUb?+)Pq3OS.s4f=.A#fR` + oQQ:nlMpmt8cSf.h-j43iNquI^5W'mnL+>9J,~> + rr3!HnW*ViMJN7[7cXMnT`:Bbs3!gqs8TDqq;-D'f,4PP0^SZ9&!;"&I^5sOB3F?rkV3$H[f6:? + GA(3\s8Tc(s8NtmkDDA]FRMr + rr3!HnW*ViMJN7[7cXMnT`:Bbs3!gqs8TDqq;-D'f,4PP0^SZ9&!;"&I^5sOB3F?rkV3$H[f6:? + GA(3\s8Tc(s8NtmkDDA]FRMr + rr3!HnW*ViMJN7[7cXMnT`:Bbs3!gqs8TDqq;-D'f,4PP0^SZ9&!;"&I^5sOB3F?rkV3$H[f6:? + GA(3\s8Tc(s8NtmkDDA]FRMr + rr3!HnW*ViMJN7[7cXMnT`:Bbs3aI's8TDqp)%QEp)3np0^SZ9&(rYU^K'(ha at OGQb=)A?[f6:? + GEp]Pd/UdNs8NtmB@$V$8+KZoN;iqK-iX-r~> + rr3!HnW*ViMJN7[7cXMnT`:Bbs3aI's8TDqp)%QEp)3np0^SZ9&(rYU^K'(ha at OGQb=)A?[f6:? + GEp]Pd/UdNs8NtmB@$V$8+KZoN;iqK-iX-r~> + rr3!HnW*ViMJN7[7cXMnT`:Bbs3aI's8TDqp)%QEp)3np0^SZ9&(rYU^K'(ha at OGQb=)A?[f6:? + GEp]Pd/UdNs8NtmB@$V$8+KZoN;iqK-iX-r~> + rr3!HnW3\k\5#2KLFAA.6sGaR2:2)DKU',[.)FDDOJ=lkKH#[Bs![hLl0)dLs8BZWMHK;K3+pY= + W'aY*5oY\s.?KW$OABt[QK%nGDN + rr3!HnW3\k\5#2KLFAA.6sGaR2:2)DKU',[.)FDDOJ=lkKH#[Bs![hLl0)dLs8BZWMHK;K3+pY= + W'aY*5oY\s.?KW$OABt[QK%nGDN + rr3!HnW3\k\5#2KLFAA.6sGaR2:2)DKU',[.)FDDOJ=lkKH#[Bs![hLl0)dLs8BZWMHK;K3+pY= + W'aY*5oY\s.?KW$OABt[QK%nGDN + rr3!HnW3\MZi#U[SAkD^%F+q9J,~> + rr3!HnW3\MZi#U[SAkD^%F+q9J,~> + rr3!HnW3\MZi#U[SAkD^%F+q9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^`(s8T*Ms60I`nL+>9J,~> + rr3!HnU^`(s8T*Ms60I`nL+>9J,~> + rr3!HnU^`(s8T*Ms60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`(s8S%/s60I`nL+>9J,~> + rr3!HnU^`*rrqS/*Zd5`JcG$8!V%Q:s*t~> + rr3!HnU^`*rrqS/*Zd5`JcG$8!V%Q:s*t~> + rr3!HnU^`*rrqS/*Zd5`JcG$8!V%Q:s*t~> + rr3!HnU^`*rrr>#"opO8JcG$8!V%Q:s*t~> + rr3!HnU^`*rrr>#"opO8JcG$8!V%Q:s*t~> + rr3!HnU^`*rrr>#"opO8JcG$8!V%Q:s*t~> + rr3!HnU^`)rr_a2&B9;$l2LeS-iX-r~> + rr3!HnU^`)rr_a2&B9;$l2LeS-iX-r~> + rr3!HnU^`)rr_a2&B9;$l2LeS-iX-r~> + rr3!HnU^`(rrRg?nU^`)rrMX;rr7K~> + rr3!HnU^`(rrRg?nU^`)rrMX;rr7K~> + rr3!HnU^`(rrRg?nU^`)rrMX;rr7K~> + rr3!HnU^`(rrS-rrdk+6rrMX;rr7K~> + rr3!HnU^`(rrS-rrdk+6rrMX;rr7K~> + rr3!HnU^`(rrS-rrdk+6rrMX;rr7K~> + rr3!HnU^`(rrHJ&JcFs6!V%Q:s*t~> + rr3!HnU^`(rrHJ&JcFs6!V%Q:s*t~> + rr3!HnU^`(rrHJ&JcFs6!V%Q:s*t~> + rr3!HnU^`+rs/@q.6p-IV"oTAli."U-iX-r~> + rr3!HnU^`+rs/@q.6p-IV"oTAli."U-iX-r~> + rr3!HnU^`+rs/@q.6p-IV"oTAli."U-iX-r~> + rr3!HnU^`-rsS=i01!8Ns1CWNU%!X5mJd4W-iX-r~> + rr3!HnU^`-rsS=i01!8Ns1CWNU%!X5mJd4W-iX-r~> + rr3!HnU^`-rsS=i01!8Ns1CWNU%!X5mJd4W-iX-r~> + rr3!HnU^`/rrhna01!;Krrg#$0:q`cs6osgnL+>9J,~> + rr3!HnU^`/rrhna01!;Krrg#$0:q`cs6osgnL+>9J,~> + rr3!HnU^`/rrhna01!;Krrg#$0:q`cs6osgnL+>9J,~> + rr3!HnU^`1rrrCk.RL`Fq>UWs\j at m9rdk+>rrMX;rr7K~> + rr3!HnU^`1rrrCk.RL`Fq>UWs\j at m9rdk+>rrMX;rr7K~> + rr3!HnU^`1rrrCk.RL`Fq>UWs\j at m9rdk+>rrMX;rr7K~> + rr3!HnU^`2rrf)C5J?jbrri,15:*(Us760jnL+>9J,~> + rr3!HnU^`2rrf)C5J?jbrri,15:*(Us760jnL+>9J,~> + rr3!HnU^`2rrf)C5J?jbrri,15:*(Us760jnL+>9J,~> + rr3!HnU^`5rrr"f.71fKnc&d!TgC3%o7?r7rrMX;rr7K~> + rr3!HnU^`5rrr"f.71fKnc&d!TgC3%o7?r7rrMX;rr7K~> + rr3!HnU^`5rrr"f.71fKnc&d!TgC3%o7?r7rrMX;rr7K~> + rr3!HnU^`7ru^^$0/mWoVQH?@s8BF#XnU4oG4U?7ZaN!!dC_k#T'q71p\t9a-iX-r~> + rr3!HnU^`7ru^^$0/mWoVQH?@s8BF#XnU4oG4U?7ZaN!!dC_k#T'q71p\t9a-iX-r~> + rr3!HnU^`7ru^^$0/mWoVQH?@s8BF#XnU4oG4U?7ZaN!!dC_k#T'q71p\t9a-iX-r~> + rr3!HnU^`9ru:[$/O@,Ihd(ZfY\a?gTA$81mAE;5M7r**6/_bB"MR/RS+_F5q>UKc-iX-r~> + rr3!HnU^`9ru:[$/O@,Ihd(ZfY\a?gTA$81mAE;5M7r**6/_bB"MR/RS+_F5q>UKc-iX-r~> + rr3!HnU^`9ru:[$/O@,Ihd(ZfY\a?gTA$81mAE;5M7r**6/_bB"MR/RS+_F5q>UKc-iX-r~> + rr3!HnU^`:rreu>6bW?qrtK4Js2n+:,,!3#5l^bC5eI'rfg4Qprri236R/8mrs\:K0oD3Bc2[^7 + KPe;grrMX;rr7K~> + rr3!HnU^`:rreu>6bW?qrtK4Js2n+:,,!3#5l^bC5eI'rfg4Qprri236R/8mrs\:K0oD3Bc2[^7 + KPe;grrMX;rr7K~> + rr3!HnU^`:rreu>6bW?qrtK4Js2n+:,,!3#5l^bC5eI'rfg4Qprri236R/8mrs\:K0oD3Bc2[^7 + KPe;grrMX;rr7K~> + rr3!HnU^`=rrr1k-UY]Gr;R":YQ)a?rtrfUq#C@!dlNZks4K]rqu6ir^dBKCq""Forn&$@pr$24 + [A`inB?$D?!V%Q:s*t~> + rr3!HnU^`=rrr1k-UY]Gr;R":YQ)a?rtrfUq#C@!dlNZks4K]rqu6ir^dBKCq""Forn&$@pr$24 + [A`inB?$D?!V%Q:s*t~> + rr3!HnU^`=rrr1k-UY]Gr;R":YQ)a?rtrfUq#C@!dlNZks4K]rqu6ir^dBKCq""Forn&$@pr$24 + [A`inB?$D?!V%Q:s*t~> + rr3!HnU^`?rrhe^/O[>KrtT:Ps2n+:XbcfDVZ,5Rs#e-tk=44lq>UT36nP#!oD]6U(pEt^:]D'P + s8S":Rf + rr3!HnU^`?rrhe^/O[>KrtT:Ps2n+:XbcfDVZ,5Rs#e-tk=44lq>UT36nP#!oD]6U(pEt^:]D'P + s8S":Rf + rr3!HnU^`?rrhe^/O[>KrtT:Ps2n+:XbcfDVZ,5Rs#e-tk=44lq>UT36nP#!oD]6U(pEt^:]D'P + s8S":Rf + rr3!HnU^]CnXD+!^\RmGi_:OR`B>''rN&>*ZCE4Ss"Y^As/T%np\tB274k#!p&>HW(pEt^:]E)m + s8S":Rf + rr3!HnU^]CnXD+!^\RmGi_:OR`B>''rN&>*ZCE4Ss"Y^As/T%np\tB274k#!p&>HW(pEt^:]E)m + s8S":Rf + rr3!HnU^]CnXD+!^\RmGi_:OR`B>''rN&>*ZCE4Ss"Y^As/T%np\tB274k#!p&>HW(pEt^:]E)m + s8S":Rf + rr3!HnUpiFrKo!%^&Ig,(\c+rbjNZti;`PphZ)WZh>bpHf`1`qnb2tdrk1`KR/QdZ%,Mi)s2n.; + `,>/(?-\o=!V%Q:s*t~> + rr3!HnUpiFrKo!%^&Ig,(\c+rbjNZti;`PphZ)WZh>bpHf`1`qnb2tdrk1`KR/QdZ%,Mi)s2n.; + `,>/(?-\o=!V%Q:s*t~> + rr3!HnUpiFrKo!%^&Ig,(\c+rbjNZti;`PphZ)WZh>bpHf`1`qnb2tdrk1`KR/QdZ%,Mi)s2n.; + `,>/(?-\o=!V%Q:s*t~> + rr3!HnV$oFTHZ_9J,~> + rr3!HnV$oFTHZ_9J,~> + rr3!HnV$oFTHZ_9J,~> + rr3!HnW + rr3!HnW + rr3!HnW + rr3!HnWmVH-iX-r~> + rr3!HnWmVH-iX-r~> + rr3!HnWmVH-iX-r~> + rr3!HnYuNg`TaZ7UAt<9;ll?:6c-b@"2[DUR/!redZjb4nL+>9J,~> + rr3!HnYuNg`TaZ7UAt<9;ll?:6c-b@"2[DUR/!redZjb4nL+>9J,~> + rr3!HnYuNg`TaZ7UAt<9;ll?:6c-b@"2[DUR/!redZjb4nL+>9J,~> + rr3!HnZr/rhO0N'-34ETl=L?.!!+ZRAki>]rPSX;rJ(AJq.9Xt&Gd^U8XZ!tTDnr^-iX-r~> + rr3!HnZr/rhO0N'-34ETl=L?.!!+ZRAki>]rPSX;rJ(AJq.9Xt&Gd^U8XZ!tTDnr^-iX-r~> + rr3!HnZr/rhO0N'-34ETl=L?.!!+ZRAki>]rPSX;rJ(AJq.9Xt&Gd^U8XZ!tTDnr^-iX-r~> + rr3!Hn[ST(pX4O+%1a4;rI=n4rpg'flMh7V+,T=^s8:)9*0g0Orri>P`jG4*rrr+\*)=`Uq>UHl + rUKs2r.#)D'cISl(Or.Lpo",mnL+>9J,~> + rr3!Hn[ST(pX4O+%1a4;rI=n4rpg'flMh7V+,T=^s8:)9*0g0Orri>P`jG4*rrr+\*)=`Uq>UHl + rUKs2r.#)D'cISl(Or.Lpo",mnL+>9J,~> + rr3!Hn[ST(pX4O+%1a4;rI=n4rpg'flMh7V+,T=^s8:)9*0g0Orri>P`jG4*rrr+\*)=`Uq>UHl + rUKs2r.#)D'cISl(Or.Lpo",mnL+>9J,~> + rr3!Hn\"l.p=OJ!-6+B^RBYTK!VX/%rrgG at -^!`Nrrf*Ws-sDfrrhYM-W/"LrrT?k>Q,uR1hL?Y + f`%uP!V%Q:s*t~> + rr3!Hn\"l.p=OJ!-6+B^RBYTK!VX/%rrgG at -^!`Nrrf*Ws-sDfrrhYM-W/"LrrT?k>Q,uR1hL?Y + f`%uP!V%Q:s*t~> + rr3!Hn\"l.p=OJ!-6+B^RBYTK!VX/%rrgG at -^!`Nrrf*Ws-sDfrrhYM-W/"LrrT?k>Q,uR1hL?Y + f`%uP!V%Q:s*t~> + rr3!Hn\5#.^J$^(5X:.jd/O6i<%3jmhu9 + J,~> + rr3!Hn\5#.^J$^(5X:.jd/O6i<%3jmhu9 + J,~> + rr3!Hn\5#.^J$^(5X:.jd/O6i<%3jmhu9 + J,~> + rr3!Hn\P50`e?/M1j%QrrrgSB,)c*gru:OMdc0Q1Xm+<9da>PLd_G2:dC%E?c2[h*D9)GO"S at Tr + :X.Vn#h$Uo(]Z43V8KY>!V%Q:s*t~> + rr3!Hn\P50`e?/M1j%QrrrgSB,)c*gru:OMdc0Q1Xm+<9da>PLd_G2:dC%E?c2[h*D9)GO"S at Tr + :X.Vn#h$Uo(]Z43V8KY>!V%Q:s*t~> + rr3!Hn\P50`e?/M1j%QrrrgSB,)c*gru:OMdc0Q1Xm+<9da>PLd_G2:dC%E?c2[h*D9)GO"S at Tr + :X.Vn#h$Uo(]Z43V8KY>!V%Q:s*t~> + rr3!Hn\kG4rle+D!FXdWa8Z>@btf+:rqcX5\#R#^eX@`3WE?a=7X2M$NS_&sQ?mQNs.e`PrrrC` + (/N3Qf)H$Ck-$K?#YN2;[f6Bu-iX-r~> + rr3!Hn\kG4rle+D!FXdWa8Z>@btf+:rqcX5\#R#^eX@`3WE?a=7X2M$NS_&sQ?mQNs.e`PrrrC` + (/N3Qf)H$Ck-$K?#YN2;[f6Bu-iX-r~> + rr3!Hn\kG4rle+D!FXdWa8Z>@btf+:rqcX5\#R#^eX@`3WE?a=7X2M$NS_&sQ?mQNs.e`PrrrC` + (/N3Qf)H$Ck-$K?#YN2;[f6Bu-iX-r~> + rr3!Hn]1Y7roD0<$m^hk_>aYa;&teerVmdi4nA/ul2R&PM#75I@^?%-94docci<,,s2Op8"R_Bm + ;:!Sg#N^qM%00>RjgkBlnL+>9J,~> + rr3!Hn]1Y7roD0<$m^hk_>aYa;&teerVmdi4nA/ul2R&PM#75I@^?%-94docci<,,s2Op8"R_Bm + ;:!Sg#N^qM%00>RjgkBlnL+>9J,~> + rr3!Hn]1Y7roD0<$m^hk_>aYa;&teerVmdi4nA/ul2R&PM#75I@^?%-94docci<,,s2Op8"R_Bm + ;:!Sg#N^qM%00>RjgkBlnL+>9J,~> + rr3!Hn]1Y4`W-EOc+O&^aAaXLkl:Z-4oWnAqu?1dE;]b2@^?%6?"Nh$f_tgMlhpbck`.,laNFMe + dAMa+!h.]PrrMX;rr7K~> + rr3!Hn]1Y4`W-EOc+O&^aAaXLkl:Z-4oWnAqu?1dE;]b2@^?%6?"Nh$f_tgMlhpbck`.,laNFMe + dAMa+!h.]PrrMX;rr7K~> + rr3!Hn]1Y4`W-EOc+O&^aAaXLkl:Z-4oWnAqu?1dE;]b2@^?%6?"Nh$f_tgMlhpbck`.,laNFMe + dAMa+!h.]PrrMX;rr7K~> + rr3!Hn]Ce6Ud#)ZXLS9KbZ5sHmE&,ms7-!`^WU8ms7g'/s6rgHq*s$9rsAJ at q>^K^M^)9H`W$.c + =%!N_UA_h+!V%Q:s*t~> + rr3!Hn]Ce6Ud#)ZXLS9KbZ5sHmE&,ms7-!`^WU8ms7g'/s6rgHq*s$9rsAJ at q>^K^M^)9H`W$.c + =%!N_UA_h+!V%Q:s*t~> + rr3!Hn]Ce6Ud#)ZXLS9KbZ5sHmE&,ms7-!`^WU8ms7g'/s6rgHq*s$9rsAJ at q>^K^M^)9H`W$.c + =%!N_UA_h+!V%Q:s*t~> + rr3!Hn]Uq8a%ctCe[>E'rln:[Lqn%uLr4:1nUi0dpgK&IX3B(X.Y6mbs5l]6qhQ4hc2PT[#5c5L% + 4#cL_#FH*-iX-r~> + rr3!Hn]Uq8a%ctCe[>E'rln:[Lqn%uLr4:1nUi0dpgK&IX3B(X.Y6mbs5l]6qhQ4hc2PT[#5c5L% + 4#cL_#FH*-iX-r~> + rr3!Hn]Uq8a%ctCe[>E'rln:[Lqn%uLr4:1nUi0dpgK&IX3B(X.Y6mbs5l]6qhQ4hc2PT[#5c5L% + 4#cL_#FH*-iX-r~> + rr3!Hn]h(;qMGLfL&J=W'`HBV)+/T1`IX6GZ[nA9@^>Y&s3:Oo!9O4["h]s8;UGBUrrpA2$sJ,J + _Z'Z,-iX-r~> + rr3!Hn]h(;qMGLfL&J=W'`HBV)+/T1`IX6GZ[nA9@^>Y&s3:Oo!9O4["h]s8;UGBUrrpA2$sJ,J + _Z'Z,-iX-r~> + rr3!Hn]h(;qMGLfL&J=W'`HBV)+/T1`IX6GZ[nA9@^>Y&s3:Oo!9O4["h]s8;UGBUrrpA2$sJ,J + _Z'Z,-iX-r~> + rr3!Hn]q.:a$LDXXT&FI<$mXir;Qoqd8QA)q>UT^N[@`L\Gla#Hl4SWi5GWrnL+>9J,~> + rr3!Hn]q.:a$LDXXT&FI<$mXir;Qoqd8QA)q>UT^N[@`L\Gla#Hl4SWi5GWrnL+>9J,~> + rr3!Hn]q.:a$LDXXT&FI<$mXir;Qoqd8QA)q>UT^N[@`L\Gla#Hl4SWi5GWrnL+>9J,~> + rr3!Hn^.:=r2gblaf5:Cb#^!Ll2L\_ir27Ee,0.Jl&-rkb-_0Pj@^LA^%TJG!V%Q:s*t~> + rr3!Hn^.:=r2gblaf5:Cb#^!Ll2L\_ir27Ee,0.Jl&-rkb-_0Pj@^LA^%TJG!V%Q:s*t~> + rr3!Hn^.:=r2gblaf5:Cb#^!Ll2L\_ir27Ee,0.Jl&-rkb-_0Pj@^LA^%TJG!V%Q:s*t~> + rr3!Hn^.: + rr3!Hn^.: + rr3!Hn^.: + rr3!Hn^@F?gKY#=pn[onr6S=VMuEPQ"oX>o;UG?Errr8;72KqAao;D3-iX-r~> + rr3!Hn^@F?gKY#=pn[onr6S=VMuEPQ"oX>o;UG?Errr8;72KqAao;D3-iX-r~> + rr3!Hn^@F?gKY#=pn[onr6S=VMuEPQ"oX>o;UG?Errr8;72KqAao;D3-iX-r~> + rr3!Hn^RRAr6-,g_4U`8d8_0HmJm4RNZ;'HWW*+KL^P5ub5VM4-iX-r~> + rr3!Hn^RRAr6-,g_4U`8d8_0HmJm4RNZ;'HWW*+KL^P5ub5VM4-iX-r~> + rr3!Hn^RRAr6-,g_4U`8d8_0HmJm4RNZ;'HWW*+KL^P5ub5VM4-iX-r~> + rr3!Hn^RR@[/`hBSGsDK="0&c.9F=:eG&LVkPXE#jo>/ + rr3!Hn^RR@[/`hBSGsDK="0&c.9F=:eG&LVkPXE#jo>/ + rr3!Hn^RR@[/`hBSGsDK="0&c.9F=:eG&LVkPXE#jo>/ + rr3!Hn^[XAKE+[7RK"#I2`K%^gh&b2`%8(TOe at Baj. + rr3!Hn^[XAKE+[7RK"#I2`K%^gh&b2`%8(TOe at Baj. + rr3!Hn^[XAKE+[7RK"#I2`K%^gh&b2`%8(TOe at Baj. + rr3!Hn^d^BJceI5QiI)Err3MW8,q&s``COfb]k\/r7&fnrrhaC#C>mcrrMX;rr7K~> + rr3!Hn^d^BJceI5QiI)Err3MW8,q&s``COfb]k\/r7&fnrrhaC#C>mcrrMX;rr7K~> + rr3!Hn^d^BJceI5QiI)Err3MW8,q&s``COfb]k\/r7&fnrrhaC#C>mcrrMX;rr7K~> + rr3!Hn_!jErIG2AqNh0]N;ihfr)ge0qfNRR`l?um4 + rr3!Hn_!jErIG2AqNh0]N;ihfr)ge0qfNRR`l?um4 + rr3!Hn_!jErIG2AqNh0]N;ihfr)ge0qfNRR`l?um4 + rr3!Hn_*pErIFrcPlLcBrVmA"4OjDQ9J,~> + rr3!Hn_*pErIFrcPlLcBrVmA"4OjDQ9J,~> + rr3!Hn_*pErIFrcPlLcBrVmA"4OjDQ9J,~> + rr3!Hn_*pEdJuu2QN%`pd:[+)mf3=J4RE+Jeoe9J,~> + rr3!Hn_*pEdJuu2QN%`pd:[+)mf3=J4RE+Jeoe9J,~> + rr3!Hn_*pEdJuu2QN%`pd:[+)mf3=J4RE+Jeoe9J,~> + rr3!Hn_4!Ffc<]TQ2^mOD>jM<^]4>uUAb)scs3[:JC at r\XT&C],n-m(rrMX;rr7K~> + rr3!Hn_4!Ffc<]TQ2^mOD>jM<^]4>uUAb)scs3[:JC at r\XT&C],n-m(rrMX;rr7K~> + rr3!Hn_4!Ffc<]TQ2^mOD>jM<^]4>uUAb)scs3[:JC at r\XT&C],n-m(rrMX;rr7K~> + rr3!Hn_='Gr[p=TPQ(p<%KqO^UfGY%TDo#O=U;:^rrMX;rr7K~> + rr3!Hn_='Gr[p=TPQ(p<%KqO^UfGY%TDo#O=U;:^rrMX;rr7K~> + rr3!Hn_='Gr[p=TPQ(p<%KqO^UfGY%TDo#O=U;:^rrMX;rr7K~> + rr3!Hn_F-HiCs`uP5bdc9df*'s!a_5rrRWOZ.8jTnL+>9J,~> + rr3!Hn_F-HiCs`uP5bdc9df*'s!a_5rrRWOZ.8jTnL+>9J,~> + rr3!Hn_F-HiCs`uP5bdc9df*'s!a_5rrRWOZ.8jTnL+>9J,~> + rr3!Hn_O3Iq.gRuOT,B@=nn?`!e1KVf)Gd at -iX-r~> + rr3!Hn_O3Iq.gRuOT,B@=nn?`!e1KVf)Gd at -iX-r~> + rr3!Hn_O3Iq.gRuOT,B@=nn?`!e1KVf)Gd at -iX-r~> + rr3!Hn_O3H^At.RrrCcnY5r$+a0,Ksd/O/q%&qkY!V%Q:s*t~> + rr3!Hn_O3H^At.RrrCcnY5r$+a0,Ksd/O/q%&qkY!V%Q:s*t~> + rr3!Hn_O3H^At.RrrCcnY5r$+a0,Ksd/O/q%&qkY!V%Q:s*t~> + rr3!Hn_X9Jbn".Tb5VI"MZ + rr3!Hn_X9Jbn".Tb5VI"MZ + rr3!Hn_X9Jbn".Tb5VI"MZ + rr3!Hn_a?Kq1'72ao;C"M2h30)N2rA"9!]Rin=>4nL+>9J,~> + rr3!Hn_a?Kq1'72ao;C"M2h30)N2rA"9!]Rin=>4nL+>9J,~> + rr3!Hn_a?Kq1'72ao;C"M2h30)N2rA"9!]Rin=>4nL+>9J,~> + rr3!Hn_a?JUB8rdrrJ% + rr3!Hn_a?JUB8rdrrJ% + rr3!Hn_a?JUB8rdrrJ% + rr3!Hn_jEKcRqK'rrJ%4k5PMP@[PjK!?6sArr_7046kT#!V%Q:s*t~> + rr3!Hn_jEKcRqK'rrJ%4k5PMP@[PjK!?6sArr_7046kT#!V%Q:s*t~> + rr3!Hn_jEKcRqK'rrJ%4k5PMP@[PjK!?6sArr_7046kT#!V%Q:s*t~> + rr3!Hn_jEK?6\p[rrJ%9J,~> + rr3!Hn_jEK?6\p[rrJ%9J,~> + rr3!Hn_jEK?6\p[rrJ%9J,~> + rr3!Hn_sKL[O@?ZrrJ% + rr3!Hn_sKL[O@?ZrrJ% + rr3!Hn_sKL[O@?ZrrJ% + rr3!Hn`'QMp*rqYrrJ% + rr3!Hn`'QMp*rqYrrJ% + rr3!Hn`'QMp*rqYrrJ% + rr3!Hn`'QMM&b]trrJ% + rr3!Hn`'QMM&b]trrJ% + rr3!Hn`'QMM&b]trrJ% + rr3!Hn`'QL#uAM>!K3!#s!mY3Y4r!Tk5PH$Moku$lT/>2hu<`I-iX-r~> + rr3!Hn`'QL#uAM>!K3!#s!mY3Y4r!Tk5PH$Moku$lT/>2hu<`I-iX-r~> + rr3!Hn`'QL#uAM>!K3!#s!mY3Y4r!Tk5PH$Moku$lT/>2hu<`I-iX-r~> + rr3!Hn`0WNUCd"7rrJ% + rr3!Hn`0WNUCd"7rrJ% + rr3!Hn`0WNUCd"7rrJ% + rr3!Hn`9]OYm#s$rrJ%9J,~> + rr3!Hn`9]OYm#s$rrJ%9J,~> + rr3!Hn`9]OYm#s$rrJ%9J,~> + rr3!Hn`9]OB+k!WrrJ%9J,~> + rr3!Hn`9]OB+k!WrrJ%9J,~> + rr3!Hn`9]OB+k!WrrJ%9J,~> + rr3!Hn`BcPf+G^5rrJ% + rr3!Hn`BcPf+G^5rrJ% + rr3!Hn`BcPf+G^5rrJ% + rr3!Hn`BcPSH.K_rrJ$\NM$:aMoG\t6NHQ6rrMX;rr7K~> + rr3!Hn`BcPSH.K_rrJ$\NM$:aMoG\t6NHQ6rrMX;rr7K~> + rr3!Hn`BcPSH.K_rrJ$\NM$:aMoG\t6NHQ6rrMX;rr7K~> + rr3!Hn`KiRmOa"f_Z'Xp"-!Kc!K4qs!q7X6ir9&L-iX-r~> + rr3!Hn`KiRmOa"f_Z'Xp"-!Kc!K4qs!q7X6ir9&L-iX-r~> + rr3!Hn`KiRmOa"f_Z'Xp"-!Kc!K4qs!q7X6ir9&L-iX-r~> + rr3!Hn`KiQD?nA$rrJ%VsW=&4VrrMX;rr7K~> + rr3!Hn`KiQD?nA$rrJ%VsW=&4VrrMX;rr7K~> + rr3!Hn`KiQD?nA$rrJ%VsW=&4VrrMX;rr7K~> + rr3!Hn`ToRr$5.TrrJ% + rr3!Hn`ToRr$5.TrrJ% + rr3!Hn`ToRr$5.TrrJ% + rr3!Hn`ToRTbm(2rrJ%9J,~> + rr3!Hn`ToRTbm(2rrJ%9J,~> + rr3!Hn`ToRTbm(2rrJ%9J,~> + rr3!Hn`ToQLE=51!K2umrrMF;rr3!DOh1Pn)iMW6"9+97kN2^EnL+>9J,~> + rr3!Hn`ToQLE=51!K2umrrMF;rr3!DOh1Pn)iMW6"9+97kN2^EnL+>9J,~> + rr3!Hn`ToQLE=51!K2umrrMF;rr3!DOh1Pn)iMW6"9+97kN2^EnL+>9J,~> + rr3!Hn`]uSbmfuRrrJ%9J,~> + rr3!Hn`]uSbmfuRrrJ%9J,~> + rr3!Hn`]uSbmfuRrrJ%9J,~> + rr3!Hn`]uR=TuP>!K2ums!#N]s8'E)q>^K*US./KQ("qS`;fkUVNBp>oph;OYdNDlWrE##WMHNf + h>[KpMo#DpAK^@%rrMX;rr7K~> + rr3!Hn`]uR=TuP>!K2ums!#N]s8'E)q>^K*US./KQ("qS`;fkUVNBp>oph;OYdNDlWrE##WMHNf + h>[KpMo#DpAK^@%rrMX;rr7K~> + rr3!Hn`]uR=TuP>!K2ums!#N]s8'E)q>^K*US./KQ("qS`;fkUVNBp>oph;OYdNDlWrE##WMHNf + h>[KpMo#DpAK^@%rrMX;rr7K~> + rr3!Hn`]uR/m,jf!K2ums!aXH`jfaQs8KWXeWOP at KiQpD54//taj,G:qijY,gfC`58&bJ$NRrT8 + h>[KpMo#Dp_uPeZrrMX;rr7K~> + rr3!Hn`]uR/m,jf!K2ums!aXH`jfaQs8KWXeWOP at KiQpD54//taj,G:qijY,gfC`58&bJ$NRrT8 + h>[KpMo#Dp_uPeZrrMX;rr7K~> + rr3!Hn`]uR/m,jf!K2ums!aXH`jfaQs8KWXeWOP at KiQpD54//taj,G:qijY,gfC`58&bJ$NRrT8 + h>[KpMo#Dp_uPeZrrMX;rr7K~> + rr3!Hn`g&T`X(21rrJ%9J,~> + rr3!Hn`g&T`X(21rrJ%9J,~> + rr3!Hn`g&T`X(21rrJ%9J,~> + rr3!Hn`g&T:K[V1rrJ% + rr3!Hn`g&T:K[V1rrJ% + rr3!Hn`g&T:K[V1rrJ% + rr3!Hn`g&S7r>s>!K2uns!mUpm/R)YC!kRkjo=)`nM0_:Q at f,Tc1Q16ZLg6Bs/'-&btJ*7Ie!?e + gthu2)iMK2!F^69rrMX;rr7K~> + rr3!Hn`g&S7r>s>!K2uns!mUpm/R)YC!kRkjo=)`nM0_:Q at f,Tc1Q16ZLg6Bs/'-&btJ*7Ie!?e + gthu2)iMK2!F^69rrMX;rr7K~> + rr3!Hn`g&S7r>s>!K2uns!mUpm/R)YC!kRkjo=)`nM0_:Q at f,Tc1Q16ZLg6Bs/'-&btJ*7Ie!?e + gthu2)iMK2!F^69rrMX;rr7K~> + rr3!Hn`p,Ui>9nTrrJ%\sh7gDfhs2lsFhrmp8]o>JtJX73?m_LbtHS(m](Nc>l._IVmaoC-a + >g2"'!?6s3rrUs_^Zb[unL+>9J,~> + rr3!Hn`p,Ui>9nTrrJ%\sh7gDfhs2lsFhrmp8]o>JtJX73?m_LbtHS(m](Nc>l._IVmaoC-a + >g2"'!?6s3rrUs_^Zb[unL+>9J,~> + rr3!Hn`p,Ui>9nTrrJ%\sh7gDfhs2lsFhrmp8]o>JtJX73?m_LbtHS(m](Nc>l._IVmaoC-a + >g2"'!?6s3rrUs_^Zb[unL+>9J,~> + rr3!Hn`p,UH8bH0rrJ%\t[`l?(!s7XUqs8UNfp=dO+f%n?cq>&%^l,i\>`m`kc`p(XcmJm4/ + bkTun!?6s2rrE9nkl1\R-iX-r~> + rr3!Hn`p,UH8bH0rrJ%\t[`l?(!s7XUqs8UNfp=dO+f%n?cq>&%^l,i\>`m`kc`p(XcmJm4/ + bkTun!?6s2rrE9nkl1\R-iX-r~> + rr3!Hn`p,UH8bH0rrJ%\t[`l?(!s7XUqs8UNfp=dO+f%n?cq>&%^l,i\>`m`kc`p(XcmJm4/ + bkTun!?6s2rrE9nkl1\R-iX-r~> + rr3!Hna$2VpGYORrrJ% + rr3!Hna$2VpGYORrrJ% + rr3!Hna$2VpGYORrrJ% + rr3!Hna$2Vli=K,rrJ?#a;Y'ia;P'oPeR/!l3Mk'rrMX;rr7K~> + rr3!Hna$2Vli=K,rrJ?#a;Y'ia;P'oPeR/!l3Mk'rrMX;rr7K~> + rr3!Hna$2Vli=K,rrJ?#a;Y'ia;P'oPeR/!l3Mk'rrMX;rr7K~> + rr3!Hna$2VfGs"(s8S%0rrQOgpZhbZnL+>9J,~> + rr3!Hna$2VfGs"(s8S%0rrQOgpZhbZnL+>9J,~> + rr3!Hna$2VfGs"(s8S%0rrQOgpZhbZnL+>9J,~> + rr3!Hna$2U=b))'!rn4 + rr3!Hna$2U=b))'!rn4 + rr3!Hna$2U=b))'!rn4 + rr3!Hna$2U#G6SI!rn4 + rr3!Hna$2U#G6SI!rn4 + rr3!Hna$2U#G6SI!rn4 + rr3!Hna-8WRL.5jrrqnl8P+TnKDu"W#O^pX!V%Q:s*t~> + rr3!Hna-8WRL.5jrrqnl8P+TnKDu"W#O^pX!V%Q:s*t~> + rr3!Hna-8WRL.5jrrqnl8P+TnKDu"W#O^pX!V%Q:s*t~> + rr3!Hna-8VP9PSX"nREL!"d2'rrU%Am-FZPnL+>9J,~> + rr3!Hna-8VP9PSX"nREL!"d2'rrU%Am-FZPnL+>9J,~> + rr3!Hna-8VP9PSX"nREL!"d2'rrU%Am-FZPnL+>9J,~> + rr3!Hna-8V7#$9m"TRHo#H!(P!CraIrrMX;rr7K~> + rr3!Hna-8V7#$9m"TRHo#H!(P!CraIrrMX;rr7K~> + rr3!Hna-8V7#$9m"TRHo#H!(P!CraIrrMX;rr7K~> + rr3!Hna6>Xit^L'rriB$B/8e(rrJ`6li."U-iX-r~> + rr3!Hna6>Xit^L'rriB$B/8e(rrJ`6li."U-iX-r~> + rr3!Hna6>Xit^L'rriB$B/8e(rrJ`6li."U-iX-r~> + rr3!Hna6>XX8r$Hs8W*#N+Dg:rrSenTBuRYnL+>9J,~> + rr3!Hna6>XX8r$Hs8W*#N+Dg:rrSenTBuRYnL+>9J,~> + rr3!Hna6>XX8r$Hs8W*#N+Dg:rrSenTBuRYnL+>9J,~> + rr3!Hna6>XX9n]Rs8W*"N-'XN"98<>M9J,~> + rr3!Hna6>XX9n]Rs8W*"N-'XN"98<>M9J,~> + rr3!Hna6>XX9n]Rs8W*"N-'XN"98<>M9J,~> + rr3!Hna6>W at r-_rrr<"lJcGcM!Lk4urrMX;rr7K~> + rr3!Hna6>W at r-_rrr<"lJcGcM!Lk4urrMX;rr7K~> + rr3!Hna6>W at r-_rrr<"lJcGcM!Lk4urrMX;rr7K~> + rr3!Hna6>W3Phfs!TVQ&rrM?,qu6]a`VTT9iP=mXrsS8 + rr3!Hna6>W3Phfs!TVQ&rrM?,qu6]a`VTT9iP=mXrsS8 + rr3!Hna6>W3Phfs!TVQ&rrM?,qu6]a`VTT9iP=mXrsS8 + rr3!Hna?DYcO&L1rrK';q>Uc0 at fQK'mJm4*;u6LqmQ\ScrsZoBiTcYBr5Po%l9J,~> + rr3!Hna?DYcO&L1rrK';q>Uc0 at fQK'mJm4*;u6LqmQ\ScrsZoBiTcYBr5Po%l9J,~> + rr3!Hna?DYcO&L1rrK';q>Uc0 at fQK'mJm4*;u6LqmQ\ScrsZoBiTcYBr5Po%l9J,~> + rr3!Hna?DYN<%k;rrN)qq>Ud#qZ$T]d/X.FqYC-l7)Jj$$oI&Fs8%WD#I4=/hD>02"5Q*no&BZN + r^PD:rrW*UW9sTcnL+>9J,~> + rr3!Hna?DYN<%k;rrN)qq>Ud#qZ$T]d/X.FqYC-l7)Jj$$oI&Fs8%WD#I4=/hD>02"5Q*no&BZN + r^PD:rrW*UW9sTcnL+>9J,~> + rr3!Hna?DYN<%k;rrN)qq>Ud#qZ$T]d/X.FqYC-l7)Jj$$oI&Fs8%WD#I4=/hD>02"5Q*no&BZN + r^PD:rrW*UW9sTcnL+>9J,~> + rr3!Hna?DY;DIaEruV%)nbqh8md933q!RYOn:&1 at p$V8Js6/e6q#C@^_Ya?A5aCj=s3U?YL%PE< + WrE##cG_O&q>VE#mHX,sm,IHsh#?^*lLk,CjQu + rr3!Hna?DY;DIaEruV%)nbqh8md933q!RYOn:&1 at p$V8Js6/e6q#C@^_Ya?A5aCj=s3U?YL%PE< + WrE##cG_O&q>VE#mHX,sm,IHsh#?^*lLk,CjQu + rr3!Hna?DY;DIaEruV%)nbqh8md933q!RYOn:&1 at p$V8Js6/e6q#C@^_Ya?A5aCj=s3U?YL%PE< + WrE##cG_O&q>VE#mHX,sm,IHsh#?^*lLk,CjQu + rr3!Hna?DX;H'[s*qQC5nV]/hRVSbh[RgGA40 at -!_)hVr:l9G)s8PL(qu7&`3C-KGqu?7k6VuA5 + rri>4s+HF.ru??TE/mYX/rOKFpi^\/Sb&77Fe3?KrVf0=cA'6;rrV'jfC&Y>nL+>9J,~> + rr3!Hna?DX;H'[s*qQC5nV]/hRVSbh[RgGA40 at -!_)hVr:l9G)s8PL(qu7&`3C-KGqu?7k6VuA5 + rri>4s+HF.ru??TE/mYX/rOKFpi^\/Sb&77Fe3?KrVf0=cA'6;rrV'jfC&Y>nL+>9J,~> + rr3!Hna?DX;H'[s*qQC5nV]/hRVSbh[RgGA40 at -!_)hVr:l9G)s8PL(qu7&`3C-KGqu?7k6VuA5 + rri>4s+HF.ru??TE/mYX/rOKFpi^\/Sb&77Fe3?KrVf0=cA'6;rrV'jfC&Y>nL+>9J,~> + rr3!HnaHJZoJ`qRruJd5s55^!s3F::cR/\S8'V)6hA?4laS=^Rs8PL(qYq6#gQsXJs8VZ>HR3"u + s7M`Yb";U0ruJaps-SfGq`i$dQi,5"ocsM1A#94o6[er$bQ!o[X8`7Y!1rWY!V%Q:s*t~> + rr3!HnaHJZoJ`qRruJd5s55^!s3F::cR/\S8'V)6hA?4laS=^Rs8PL(qYq6#gQsXJs8VZ>HR3"u + s7M`Yb";U0ruJaps-SfGq`i$dQi,5"ocsM1A#94o6[er$bQ!o[X8`7Y!1rWY!V%Q:s*t~> + rr3!HnaHJZoJ`qRruJd5s55^!s3F::cR/\S8'V)6hA?4laS=^Rs8PL(qYq6#gQsXJs8VZ>HR3"u + s7M`Yb";U0ruJaps-SfGq`i$dQi,5"ocsM1A#94o6[er$bQ!o[X8`7Y!1rWY!V%Q:s*t~> + rr3!HnaHJZhAP4OruJd5s56B:s3F::cR/\S8'V)6hA?4lM6"-:s8PL(qu6Z at rr3)WJGGl;rs?4l + s8U0O`k`Slqu6r]C]0I9s8,::rr3S*R`6*Bp1:K.s'/h.7b%I)JZJePqascSrrMX;rr7K~> + rr3!HnaHJZhAP4OruJd5s56B:s3F::cR/\S8'V)6hA?4lM6"-:s8PL(qu6Z at rr3)WJGGl;rs?4l + s8U0O`k`Slqu6r]C]0I9s8,::rr3S*R`6*Bp1:K.s'/h.7b%I)JZJePqascSrrMX;rr7K~> + rr3!HnaHJZhAP4OruJd5s56B:s3F::cR/\S8'V)6hA?4lM6"-:s8PL(qu6Z at rr3)WJGGl;rs?4l + s8U0O`k`Slqu6r]C]0I9s8,::rr3S*R`6*Bp1:K.s'/h.7b%I)JZJePqascSrrMX;rr7K~> + rr3!HnaHJYe2jW0*PFK5i(!8:cUn/_-NE7"c2[h#(]SE&s6;-7s$Xa$rsr?%s8VkSnIj at Os4og; + s2"^7!g4Gur;RebIZ1l + rr3!HnaHJYe2jW0*PFK5i(!8:cUn/_-NE7"c2[h#(]SE&s6;-7s$Xa$rsr?%s8VkSnIj at Os4og; + s2"^7!g4Gur;RebIZ1l + rr3!HnaHJYe2jW0*PFK5i(!8:cUn/_-NE7"c2[h#(]SE&s6;-7s$Xa$rsr?%s8VkSnIj at Os4og; + s2"^7!g4Gur;RebIZ1l + rr3!HnaHJYCc\Ws+7YaOjL.(ojet8eW#sajGFPMYZkLufD9oU6>e2kbn,32$6DLg3UYYGFJ\oa( + g=r[3ThcT/-"s.*3:_^06p at u8LGWp7kiZ0HXLeuSfP`ZFF6rrMX;rr7K~> + rr3!HnaHJYCc\Ws+7YaOjL.(ojet8eW#sajGFPMYZkLufD9oU6>e2kbn,32$6DLg3UYYGFJ\oa( + g=r[3ThcT/-"s.*3:_^06p at u8LGWp7kiZ0HXLeuSfP`ZFF6rrMX;rr7K~> + rr3!HnaHJYCc\Ws+7YaOjL.(ojet8eW#sajGFPMYZkLufD9oU6>e2kbn,32$6DLg3UYYGFJ\oa( + g=r[3ThcT/-"s.*3:_^06p at u8LGWp7kiZ0HXLeuSfP`ZFF6rrMX;rr7K~> + rr3!HnaHJYCc\Ws#KfY2Rn?:nSGYtgFT:oL\'7N;@/l`hW/pmL!5e[6(9RV*9%3h5B)ca at s8R=9 + 9"+cX<(]d0rVmq2UqOH at 2b?V6f)PcZ8r]iXp1:A at jSunc8mS\o8nP.(!q7_sn,EFY-iX-r~> + rr3!HnaHJYCc\Ws#KfY2Rn?:nSGYtgFT:oL\'7N;@/l`hW/pmL!5e[6(9RV*9%3h5B)ca at s8R=9 + 9"+cX<(]d0rVmq2UqOH at 2b?V6f)PcZ8r]iXp1:A at jSunc8mS\o8nP.(!q7_sn,EFY-iX-r~> + rr3!HnaHJYCc\Ws#KfY2Rn?:nSGYtgFT:oL\'7N;@/l`hW/pmL!5e[6(9RV*9%3h5B)ca at s8R=9 + 9"+cX<(]d0rVmq2UqOH at 2b?V6f)PcZ8r]iXp1:A at jSunc8mS\o8nP.(!q7_sn,EFY-iX-r~> + rr3!HnaHJYChJ>!li./`f)PcO.Id*3!qp30TDnpQIdd:;nL+>9J,~> + rr3!HnaHJYChJ>!li./`f)PcO.Id*3!qp30TDnpQIdd:;nL+>9J,~> + rr3!HnaHJYChJ>!li./`f)PcO.Id*3!qp30TDnpQIdd:;nL+>9J,~> + rr3!HnaHJYCor9gli.1`QAgd#pAXje"QUF3)98EM!BP&crrMX;rr7K~> + rr3!HnaHJYCor9gli.1`QAgd#pAXje"QUF3)98EM!BP&crrMX;rr7K~> + rr3!HnaHJYCor9gli.1`QAgd#pAXje"QUF3)98EM!BP&crrMX;rr7K~> + rr3!HnaQP[q_>U3s8;osmt(N:rrIRbn,EFY-iX-r~> + rr3!HnaQP[q_>U3s8;osmt(N:rrIRbn,EFY-iX-r~> + rr3!HnaQP[q_>U3s8;osmt(N:rrIRbn,EFY-iX-r~> + rr3!HnaQPZp`Y4gqu?\TJcGZJ!j*XBnG`OZ-iX-r~> + rr3!HnaQPZp`Y4gqu?\TJcGZJ!j*XBnG`OZ-iX-r~> + rr3!HnaQPZp`Y4gqu?\TJcGZJ!j*XBnG`OZ-iX-r~> + rr3!HnaQPZclmu?qu?\TJcGZJ!q%!%nG`OZ-iX-r~> + rr3!HnaQPZclmu?qu?\TJcGZJ!q%!%nG`OZ-iX-r~> + rr3!HnaQPZclmu?qu?\TJcGZJ!q%!%nG`OZ-iX-r~> + rr3!HnaQPZKcu$Iqu?\TJcGWI!?mTprrMX;rr7K~> + rr3!HnaQPZKcu$Iqu?\TJcGWI!?mTprrMX;rr7K~> + rr3!HnaQPZKcu$Iqu?\TJcGWI!?mTprrMX;rr7K~> + rr3!HnaQPZKcu$Iqu?\TJcGWI!?m0drrMX;rr7K~> + rr3!HnaQPZKcu$Iqu?\TJcGWI!?m0drrMX;rr7K~> + rr3!HnaQPZKcu$Iqu?\TJcGWI!?m0drrMX;rr7K~> + rr3!HnaQPZ4#_`jrVm&sh/RG[o7?r?rrF9)nG`OZ-iX-r~> + rr3!HnaQPZ4#_`jrVm&sh/RG[o7?r?rrF9)nG`OZ-iX-r~> + rr3!HnaQPZ4#_`jrVm&sh/RG[o7?r?rrF9)nG`OZ-iX-r~> + rr3!HnaQPZ&sInHrVlo`B`7u3^OcF`rrI9UnG`OZ-iX-r~> + rr3!HnaQPZ&sInHrVlo`B`7u3^OcF`rrI9UnG`OZ-iX-r~> + rr3!HnaQPZ&sInHrVlo`B`7u3^OcF`rrI9UnG`OZ-iX-r~> + rr3!HnaQPZ&sInHr;QoG%0LqLJcG]K!L"/crrMX;rr7K~> + rr3!HnaQPZ&sInHr;QoG%0LqLJcG]K!L"/crrMX;rr7K~> + rr3!HnaQPZ&sInHr;QoG%0LqLJcG]K!L"/crrMX;rr7K~> + rr3!HnaQPZ&t"7Mr;Qlr73gfCs8;ltq&/]%!V%Q:s*t~> + rr3!HnaQPZ&t"7Mr;Qlr73gfCs8;ltq&/]%!V%Q:s*t~> + rr3!HnaQPZ&t"7Mr;Qlr73gfCs8;ltq&/]%!V%Q:s*t~> + rr3!HnaQPY)1hharrS-[pOWAArr + rr3!HnaQPY)1hharrS-[pOWAArr + rr3!HnaQPY)1hharrS-[pOWAArr + rr3!HnaQPY)7BJEilAh8C0&Bj!91Ed!=c^3rrMX;rr7K~> + rr3!HnaQPY)7BJEilAh8C0&Bj!91Ed!=c^3rrMX;rr7K~> + rr3!HnaQPY)7BJEilAh8C0&Bj!91Ed!=c^3rrMX;rr7K~> + rr3!HnaZV[h%R3r!K/[l=9/_d[Jp8;T(2g]nL+>9J,~> + rr3!HnaZV[h%R3r!K/[l=9/_d[Jp8;T(2g]nL+>9J,~> + rr3!HnaZV[h%R3r!K/[l=9/_d[Jp8;T(2g]nL+>9J,~> + rr3!HnaZV[So1t9!K2ttrrF's[Jp8RT(2g]nL+>9J,~> + rr3!HnaZV[So1t9!K2ttrrF's[Jp8RT(2g]nL+>9J,~> + rr3!HnaZV[So1t9!K2ttrrF's[Jp8RT(2g]nL+>9J,~> + rr3!HnaZV[SpIgE!K3!#rs/4X9?+uDL[j[0"oZce`i9J,~> + rr3!HnaZV[SpIgE!K3!#rs/4X9?+uDL[j[0"oZce`i9J,~> + rr3!HnaZV[SpIgE!K3!#rs/4X9?+uDL[j[0"oZce`i9J,~> + rr3!HnaZV[SpIgE!K3!"rrJ=;rr3%6-i**."lH6Xs6)fGrrg^in_E:)rrMr3i;WfsMm`QcH7SOc + !V%Q:s*t~> + rr3!HnaZV[SpIgE!K3!"rrJ=;rr3%6-i**."lH6Xs6)fGrrg^in_E:)rrMr3i;WfsMm`QcH7SOc + !V%Q:s*t~> + rr3!HnaZV[SpIgE!K3!"rrJ=;rr3%6-i**."lH6Xs6)fGrrg^in_E:)rrMr3i;WfsMm`QcH7SOc + !V%Q:s*t~> + rr3!HnaZV[I!W4#!K3!"rrIVUK3Xl03[)iM-(!I?9drrMX; + rr7K~> + rr3!HnaZV[I!W4#!K3!"rrIVUK3Xl03[)iM-(!I?9drrMX; + rr7K~> + rr3!HnaZV[I!W4#!K3!"rrIVUK3Xl03[)iM-(!I?9drrMX; + rr7K~> + rr3!HnaZV[.seW'!K3!"rrHf + rr3!HnaZV[.seW'!K3!"rrHf + rr3!HnaZV[.seW'!K3!"rrHf + rr3!HnaZV[.seW'!K3!"rrGR;rr5!%!;PGome0*Kd7!`,5N2:5r2i?Zjsjg>s4r_b9()_XbP629 + s+?X;m8VX(44a0Ms8W)#.f9":q<7hZ)iM-(!jhs:o)Aa\-iX-r~> + rr3!HnaZV[.seW'!K3!"rrGR;rr5!%!;PGome0*Kd7!`,5N2:5r2i?Zjsjg>s4r_b9()_XbP629 + s+?X;m8VX(44a0Ms8W)#.f9":q<7hZ)iM-(!jhs:o)Aa\-iX-r~> + rr3!HnaZV[.seW'!K3!"rrGR;rr5!%!;PGome0*Kd7!`,5N2:5r2i?Zjsjg>s4r_b9()_XbP629 + s+?X;m8VX(44a0Ms8W)#.f9":q<7hZ)iM-(!jhs:o)Aa\-iX-r~> + rr3!HnaZV[.seW'!K3!#rrVUXjSo/s?6[EY`W,mHs6h]5GoXhus8Rh;s5Y#Nqsj[c'3*cec)A<7 + f)Jsfs,1O/_KP"72ZE^ZeJ?c2pZMPW)iM-(!pouso)Aa\-iX-r~> + rr3!HnaZV[.seW'!K3!#rrVUXjSo/s?6[EY`W,mHs6h]5GoXhus8Rh;s5Y#Nqsj[c'3*cec)A<7 + f)Jsfs,1O/_KP"72ZE^ZeJ?c2pZMPW)iM-(!pouso)Aa\-iX-r~> + rr3!HnaZV[.seW'!K3!#rrVUXjSo/s?6[EY`W,mHs6h]5GoXhus8Rh;s5Y#Nqsj[c'3*cec)A<7 + f)Jsfs,1O/_KP"72ZE^ZeJ?c2pZMPW)iM-(!pouso)Aa\-iX-r~> + rr3!HnaZV[.seW'!K3!#rrLM;rr3nY8+)j!g]-U]s8P?ViFcoVs8P::s4@=qjIuSQ% + rr3!HnaZV[.seW'!K3!#rrLM;rr3nY8+)j!g]-U]s8P?ViFcoVs8P::s4@=qjIuSQ% + rr3!HnaZV[.seW'!K3!#rrLM;rr3nY8+)j!g]-U]s8P?ViFcoVs8P::s4@=qjIuSQ% + rr3!HnaZV[.seW'!K3!#s#mW#s8U#^g].;\X7(tWs8SCXs1N.Cs6rD;s-@<_DemVt_o(Y*IK,Hn + P05'Ls4iV+jM1 at t>1(([s)`_dk5PH$Mm`Qdm/XWdrrMX;rr7K~> + rr3!HnaZV[.seW'!K3!#s#mW#s8U#^g].;\X7(tWs8SCXs1N.Cs6rD;s-@<_DemVt_o(Y*IK,Hn + P05'Ls4iV+jM1 at t>1(([s)`_dk5PH$Mm`Qdm/XWdrrMX;rr7K~> + rr3!HnaZV[.seW'!K3!#s#mW#s8U#^g].;\X7(tWs8SCXs1N.Cs6rD;s-@<_DemVt_o(Y*IK,Hn + P05'Ls4iV+jM1 at t>1(([s)`_dk5PH$Mm`Qdm/XWdrrMX;rr7K~> + rr3!HnaZV[.seW'!K3!$rrsMU%2p-ip\t0prC[mZrr4 at 3pA_gls5k+&7YV9`C,>C<)NOgsq)KAD + "`=nR3WK,c(gHk:rb?i[rrL@%jo5?#Mm`Qdm/XWdrrMX;rr7K~> + rr3!HnaZV[.seW'!K3!$rrsMU%2p-ip\t0prC[mZrr4 at 3pA_gls5k+&7YV9`C,>C<)NOgsq)KAD + "`=nR3WK,c(gHk:rb?i[rrL@%jo5?#Mm`Qdm/XWdrrMX;rr7K~> + rr3!HnaZV[.seW'!K3!$rrsMU%2p-ip\t0prC[mZrr4 at 3pA_gls5k+&7YV9`C,>C<)NOgsq)KAD + "`=nR3WK,c(gHk:rb?i[rrL@%jo5?#Mm`Qdm/XWdrrMX;rr7K~> + rr3!HnaZV[/+'bE!K2u at rr_>Kk-j at N!?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2u at rr_>Kk-j at N!?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2u at rr_>Kk-j at N!?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2u at rrV1.S)aML)iM*'!F`J.rrMX;rr7K~> + rr3!HnaZV[/+'bE!K2u at rrV1.S)aML)iM*'!F`J.rrMX;rr7K~> + rr3!HnaZV[/+'bE!K2u at rrV1.S)aML)iM*'!F`J.rrMX;rr7K~> + rr3!HnaZV[/+'bE!K1HiZ2o<:j0A\!MmWKb at CPh-!V%Q:s*t~> + rr3!HnaZV[/+'bE!K1HiZ2o<:j0A\!MmWKb at CPh-!V%Q:s*t~> + rr3!HnaZV[/+'bE!K1HiZ2o<:j0A\!MmWKb at CPh-!V%Q:s*t~> + rr3!HnaZV[/+'bE!/la8!/n5a!F`J.rrMX;rr7K~> + rr3!HnaZV[/+'bE!/la8!/n5a!F`J.rrMX;rr7K~> + rr3!HnaZV[/+'bE!/la8!/n5a!F`J.rrMX;rr7K~> + rr3!HnaZV[/+'bE!K0I-JH64<[/U/8\+9P"nL+>9J,~> + rr3!HnaZV[/+'bE!K0I-JH64<[/U/8\+9P"nL+>9J,~> + rr3!HnaZV[/+'bE!K0I-JH64<[/U/8\+9P"nL+>9J,~> + rr3!HnaZV[/+'bE!K3!$ruLdiiUd*JhVRo)n(mU3h#I3(m/5]%s7G1-lg*a0pAY-WnG`XRnGi:; + kPkQ%MmWKb@<1r=!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!$ruLdiiUd*JhVRo)n(mU3h#I3(m/5]%s7G1-lg*a0pAY-WnG`XRnGi:; + kPkQ%MmWKb@<1r=!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!$ruLdiiUd*JhVRo)n(mU3h#I3(m/5]%s7G1-lg*a0pAY-WnG`XRnGi:; + kPkQ%MmWKb@<1r=!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!$ruUKODWq,q:e'^Lgm%!T49+mnKD@`:s6<7!g=hfWg\CdMnMg(0rrd#9 + s7$lfrrF's[/U047IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K3!$ruUKODWq,q:e'^Lgm%!T49+mnKD@`:s6<7!g=hfWg\CdMnMg(0rrd#9 + s7$lfrrF's[/U047IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K3!$ruUKODWq,q:e'^Lgm%!T49+mnKD@`:s6<7!g=hfWg\CdMnMg(0rrd#9 + s7$lfrrF's[/U047IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K3!#ruIJWs8VVT;ZHdL\c;]os5+QDmOVWCoJF#Vs3^nkq#:D`5gf-%"S29d + fb*EI!?6s(rrLV + rr3!HnaZV[/+'bE!K3!#ruIJWs8VVT;ZHdL\c;]os5+QDmOVWCoJF#Vs3^nkq#:D`5gf-%"S29d + fb*EI!?6s(rrLV + rr3!HnaZV[/+'bE!K3!#ruIJWs8VVT;ZHdL\c;]os5+QDmOVWCoJF#Vs3^nkq#:D`5gf-%"S29d + fb*EI!?6s(rrLV + rr3!HnaZV[/+'bE!K3!#ruSIXs8Ts?/b&e\q#C?ms47j8l6T^8nLVNVs.]V>s8N#rrr_T!>eL(9 + #6+T#s8N#trr2rts8N&u!RMA?rrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K3!#ruSIXs8Ts?/b&e\q#C?ms47j8l6T^8nLVNVs.]V>s8N#rrr_T!>eL(9 + #6+T#s8N#trr2rts8N&u!RMA?rrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K3!#ruSIXs8Ts?/b&e\q#C?ms47j8l6T^8nLVNVs.]V>s8N#rrr_T!>eL(9 + #6+T#s8N#trr2rts8N&u!RMA?rrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K3!#s$"h#s89P03o9&*s7M//s1q%Ch_hnCl7UZXYqic[plf]5df0:Hbk$1P + s8Vt1)Q<*eA@$!1?KD. at 8*^,^9'?3T)iM*'!RsR/rrMX;rr7K~> + rr3!HnaZV[/+'bE!K3!#s$"h#s89P03o9&*s7M//s1q%Ch_hnCl7UZXYqic[plf]5df0:Hbk$1P + s8Vt1)Q<*eA@$!1?KD. at 8*^,^9'?3T)iM*'!RsR/rrMX;rr7K~> + rr3!HnaZV[/+'bE!K3!#s$"h#s89P03o9&*s7M//s1q%Ch_hnCl7UZXYqic[plf]5df0:Hbk$1P + s8Vt1)Q<*eA@$!1?KD. at 8*^,^9'?3T)iM*'!RsR/rrMX;rr7K~> + rr3!HnaZV[/+'bE!K3!#rs7 at Kp9E-I3n(D6ruHoWs0$/:ejBE:j=Jg1_)A7aLlDA5!:g*M_>i"Q + rr3Sm1"H)rs23=chI6Ha)?9`0Gj#)-)iM*'!RsR/rrMX;rr7K~> + rr3!HnaZV[/+'bE!K3!#rs7 at Kp9E-I3n(D6ruHoWs0$/:ejBE:j=Jg1_)A7aLlDA5!:g*M_>i"Q + rr3Sm1"H)rs23=chI6Ha)?9`0Gj#)-)iM*'!RsR/rrMX;rr7K~> + rr3!HnaZV[/+'bE!K3!#rs7 at Kp9E-I3n(D6ruHoWs0$/:ejBE:j=Jg1_)A7aLlDA5!:g*M_>i"Q + rr3Sm1"H)rs23=chI6Ha)?9`0Gj#)-)iM*'!RsR/rrMX;rr7K~> + rr3!HnaZV[/+'bE!K3!"rs)!(VZ6[.V7HU*$VekFEi8r*JH,YHErQ(`AH88f\Ake0q>[;%`jdu# + s8Vn&Nm$Vc[\L]XGQ5W\s8QT:kPkQ%MmWKbe4&s.!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!"rs)!(VZ6[.V7HU*$VekFEi8r*JH,YHErQ(`AH88f\Ake0q>[;%`jdu# + s8Vn&Nm$Vc[\L]XGQ5W\s8QT:kPkQ%MmWKbe4&s.!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!"rs)!(VZ6[.V7HU*$VekFEi8r*JH,YHErQ(`AH88f\Ake0q>[;%`jdu# + s8Vn&Nm$Vc[\L]XGQ5W\s8QT:kPkQ%MmWKbe4&s.!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!"rs(uKf`1tm?1e-r&fL`L4P]sH[K$8HW;lnn4 at uVZr;Quic2[h87c+.E + &=?=orf:mks(nh;PD9,;0'h^#!?6s(rrLV + rr3!HnaZV[/+'bE!K3!"rs(uKf`1tm?1e-r&fL`L4P]sH[K$8HW;lnn4 at uVZr;Quic2[h87c+.E + &=?=orf:mks(nh;PD9,;0'h^#!?6s(rrLV + rr3!HnaZV[/+'bE!K3!"rs(uKf`1tm?1e-r&fL`L4P]sH[K$8HW;lnn4 at uVZr;Quic2[h87c+.E + &=?=orf:mks(nh;PD9,;0'h^#!?6s(rrLV + rr3!HnaZV[/+'bE!K3!"rrI\[rr4sLRK*<2F8Z'6YjAa4l?^eVs6DeY + pAb02 at .F8dAFPgJKumi$nC]qbkPkQ%MmWKbe4&s.!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!"rrI\[rr4sLRK*<2F8Z'6YjAa4l?^eVs6DeY + pAb02 at .F8dAFPgJKumi$nC]qbkPkQ%MmWKbe4&s.!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!"rrI\[rr4sLRK*<2F8Z'6YjAa4l?^eVs6DeY + pAb02 at .F8dAFPgJKumi$nC]qbkPkQ%MmWKbe4&s.!V%Q:s*t~> + rr3!HnaZV[/+'bE!K3!"rrCCDrrfpos8Q[$.0*rXrt&?fd]+`F?2sq/.4KZEs5LEbrrZ^Zn:UQd + !%mC6!?6s(rrLV + rr3!HnaZV[/+'bE!K3!"rrCCDrrfpos8Q[$.0*rXrt&?fd]+`F?2sq/.4KZEs5LEbrrZ^Zn:UQd + !%mC6!?6s(rrLV + rr3!HnaZV[/+'bE!K3!"rrCCDrrfpos8Q[$.0*rXrt&?fd]+`F?2sq/.4KZEs5LEbrrZ^Zn:UQd + !%mC6!?6s(rrLV + rr3!HnaZV[/+'bE!K2ttrrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K2ttrrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K2ttrrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K.nV0ED?8[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K.nV0ED?8[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K.nV0ED?8[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K.#=!s&C[[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K.#=!s&C[[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K.#=!s&C[[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K2ttrrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K2ttrrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K2ttrrF's[/U0V7IpHZnL+>9J,~> + rr3!HnaZV[/+'bE!K2umrrVlFdf/;1b3JoPqXjdkrm^B9iQfjN!?6s(rrLV + rr3!HnaZV[/+'bE!K2umrrVlFdf/;1b3JoPqXjdkrm^B9iQfjN!?6s(rrLV + rr3!HnaZV[/+'bE!K2umrrVlFdf/;1b3JoPqXjdkrm^B9iQfjN!?6s(rrLV + rr3!HnaZV[/+'bE!K2umrrVh;:&a)SM7`+Am.C;]r`cZ-J3;6Z!?6s(rrLV + rr3!HnaZV[/+'bE!K2umrrVh;:&a)SM7`+Am.C;]r`cZ-J3;6Z!?6s(rrLV + rr3!HnaZV[/+'bE!K2umrrVh;:&a)SM7`+Am.C;]r`cZ-J3;6Z!?6s(rrLV + rr3!HnaZV[/+'bE!K2ulrrH/Wqu6]erUg*nqE(t^p[?N0!?6s(rrJoao)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2ulrrH/Wqu6]erUg*nqE(t^p[?N0!?6s(rrJoao)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2ulrrH/Wqu6]erUg*nqE(t^p[?N0!?6s(rrJoao)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!(=$s697WrqQ6eq!n.Rp&G'ip%S+Xs7nLVqY0d`o(VhGqZ$Qg!<1dR + !?6s(rrHQ7o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!(=$s697WrqQ6eq!n.Rp&G'ip%S+Xs7nLVqY0d`o(VhGqZ$Qg!<1dR + !?6s(rrHQ7o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!(=$s697WrqQ6eq!n.Rp&G'ip%S+Xs7nLVqY0d`o(VhGqZ$Qg!<1dR + !?6s(rrHQ7o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!KD5l at eI&qlFQ/SL0nmAD at .$Dj=tus7Ru%j$M/H9U0-+]^Bm"Fk,:I + !?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!KD5l at eI&qlFQ/SL0nmAD at .$Dj=tus7Ru%j$M/H9U0-+]^Bm"Fk,:I + !?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!KD5l at eI&qlFQ/SL0nmAD at .$Dj=tus7Ru%j$M/H9U0-+]^Bm"Fk,:I + !?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!J]=gTKuEs1M\;js77Q:ru:ppeCn3eq.I)7L.L," + !?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!J]=gTKuEs1M\;js77Q:ru:ppeCn3eq.I)7L.L," + !?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2uls!J]=gTKuEs1M\;js77Q:ru:ppeCn3eq.I)7L.L," + !?6s(rrHQ;o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2ums!Yrcs8VQ_s8RA;s.FZ;s!t#ITVJSmOT2P!s3"1:qs.b0s-$3o`iui* + rrF's[/U/8\+9P"nL+>9J,~> + rr3!HnaZV[/+'bE!K2ums!Yrcs8VQ_s8RA;s.FZ;s!t#ITVJSmOT2P!s3"1:qs.b0s-$3o`iui* + rrF's[/U/8\+9P"nL+>9J,~> + rr3!HnaZV[/+'bE!K2ums!Yrcs8VQ_s8RA;s.FZ;s!t#ITVJSmOT2P!s3"1:qs.b0s-$3o`iui* + rrF's[/U/8\+9P"nL+>9J,~> + rr3!HnaZV[/+'bE!K2umrrJg + rr3!HnaZV[/+'bE!K2umrrJg + rr3!HnaZV[/+'bE!K2umrrJg + rr3!HnaZV[/+'bE!K2unrr_P"G3/`',4O)Ha5BIpnsiqHP]#Hd3.8hCWSq`PiJ;U3T$dG(\(n7? + h#@BoMmWKb at CPh-!V%Q:s*t~> + rr3!HnaZV[/+'bE!K2unrr_P"G3/`',4O)Ha5BIpnsiqHP]#Hd3.8hCWSq`PiJ;U3T$dG(\(n7? + h#@BoMmWKb at CPh-!V%Q:s*t~> + rr3!HnaZV[/+'bE!K2unrr_P"G3/`',4O)Ha5BIpnsiqHP]#Hd3.8hCWSq`PiJ;U3T$dG(\(n7? + h#@BoMmWKb at CPh-!V%Q:s*t~> + rr3!HnaZV[/+'bE!K2unrr[0u2c'GQ!1EaD#u%?X2cfrc2l1us2[2MHs85SYleDF?)iM-(!rG[# + o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2unrr[0u2c'GQ!1EaD#u%?X2cfrc2l1us2[2MHs85SYleDF?)iM-(!rG[# + o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2unrr[0u2c'GQ!1EaD#u%?X2cfrc2l1us2[2MHs85SYleDF?)iM-(!rG[# + o)Aa\-iX-r~> + rr3!HnaZV[/+'bE!K2ttrrF's[Jp + rr3!HnaZV[/+'bE!K2ttrrF's[Jp + rr3!HnaZV[/+'bE!K2ttrrF's[Jp + rr3!HnaZV[/+'bE!K0j8PQ;>R[Jp + rr3!HnaZV[/+'bE!K0j8PQ;>R[Jp + rr3!HnaZV[/+'bE!K0j8PQ;>R[Jp + rr3!HnaZV[/+'bE!0bG9rsHdZ!0ahj!pouso)Aa\-iX-r~> + rr3!HnaZV[/+'bE!0bG9rsHdZ!0ahj!pouso)Aa\-iX-r~> + rr3!HnaZV[/+'bE!0bG9rsHdZ!0ahj!pouso)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!pouso)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!pouso)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!pouso)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!h'+uo)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!h'+uo)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!h'+uo)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!dZ-_o)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!dZ-_o)Aa\-iX-r~> + rr3!HnaZV[/+%ofqZ$SSJcGTH!dZ-_o)Aa\-iX-r~> + rr3!HnaZV[/%:*0r;QriX at c*?iIV%,rrIErnc&X[-iX-r~> + rr3!HnaZV[/%:*0r;QriX at c*?iIV%,rrIErnc&X[-iX-r~> + rr3!HnaZV[/%:*0r;QriX at c*?iIV%,rrIErnc&X[-iX-r~> + rr3!HnaZV[.scdHr;QrkK)u#`a+=9grrIErnc&X[-iX-r~> + rr3!HnaZV[.scdHr;QrkK)u#`a+=9grrIErnc&X[-iX-r~> + rr3!HnaZV[.scdHr;QrkK)u#`a+=9grrIErnc&X[-iX-r~> + rr3!HnaZV[.scdHqu6cW&dP7as82fsH:@B(!V%Q:s*t~> + rr3!HnaZV[.scdHqu6cW&dP7as82fsH:@B(!V%Q:s*t~> + rr3!HnaZV[.scdHqu6cW&dP7as82fsH:@B(!V%Q:s*t~> + rr3!HnaZV[.scdHqu6ctAhiS%s82fsHCj[,!V%Q:s*t~> + rr3!HnaZV[.scdHqu6ctAhiS%s82fsHCj[,!V%Q:s*t~> + rr3!HnaZV[.scdHqu6ctAhiS%s82fsHCj[,!V%Q:s*t~> + rr3!HnaZV[.scdHqYpVUA,CiWqu6\CT(2g]nL+>9J,~> + rr3!HnaZV[.scdHqYpVUA,CiWqu6\CT(2g]nL+>9J,~> + rr3!HnaZV[.scdHqYpVUA,CiWqu6\CT(2g]nL+>9J,~> + rr3!HnaZV[.scdHqYpSTFFjJgrrEh]nc&X[-iX-r~> + rr3!HnaZV[.scdHqYpSTFFjJgrrEh]nc&X[-iX-r~> + rr3!HnaZV[.scdHqYpSTFFjJgrrEh]nc&X[-iX-r~> + rr3!HnaZV[.scdHqZ$TFJcGTH!#b;+!V%Q:s*t~> + rr3!HnaZV[.scdHqZ$TFJcGTH!#b;+!V%Q:s*t~> + rr3!HnaZV[.scdHqZ$TFJcGTH!#b;+!V%Q:s*t~> + rr3!HnaZV[.sdri"67tfnauh_nBoVZrsRE5iSWGjqpF3ThWk(>!S[2*rrV];"`!V%Q: + s*t~> + rr3!HnaZV[.sdri"67tfnauh_nBoVZrsRE5iSWGjqpF3ThWk(>!S[2*rrV];"`!V%Q: + s*t~> + rr3!HnaZV[.sdri"67tfnauh_nBoVZrsRE5iSWGjqpF3ThWk(>!S[2*rrV];"`!V%Q: + s*t~> + rr3!HnaZV[.se#k"o"p^jkH9srrVnf9J,~> + rr3!HnaZV[.se#k"o"p^jkH9srrVnf9J,~> + rr3!HnaZV[.se#k"o"p^jkH9srrVnf9J,~> + rr3!HnaZV[/pa>n"k=."s8;W_rrKB)qu7'PoDej[MWHers8UEOrr3)I4?*)qrrKN9J,~> + rr3!HnaZV[/pa>n"k=."s8;W_rrKB)qu7'PoDej[MWHers8UEOrr3)I4?*)qrrKN9J,~> + rr3!HnaZV[/pa>n"k=."s8;W_rrKB)qu7'PoDej[MWHers8UEOrr3)I4?*)qrrKN9J,~> + rr3!HnaZV[SpI75(Al,]\*reYp[7/3n*KuPp?1l.qu + rr3!HnaZV[SpI75(Al,]\*reYp[7/3n*KuPp?1l.qu + rr3!HnaZV[SpI75(Al,]\*reYp[7/3n*KuPp?1l.qu + rr3!HnaZV[SpI75(A4sAUXl8hc]TuDSSZpXZ;-T^ci:7Mqu7&[4\0PJr;Wo]:KcHOrri84s)jn. + ru?*NClh)N09'CdjYWN:md?,nLm_bps0Y7\c[a99rrF9snG`OZ-iX-r~> + rr3!HnaZV[SpI75(A4sAUXl8hc]TuDSSZpXZ;-T^ci:7Mqu7&[4\0PJr;Wo]:KcHOrri84s)jn. + ru?*NClh)N09'CdjYWN:md?,nLm_bps0Y7\c[a99rrF9snG`OZ-iX-r~> + rr3!HnaZV[SpI75(A4sAUXl8hc]TuDSSZpXZ;-T^ci:7Mqu7&[4\0PJr;Wo]:KcHOrri84s)jn. + ru?*NClh)N09'CdjYWN:md?,nLm_bps0Y7\c[a99rrF9snG`OZ-iX-r~> + rr3!HnaZV[SpI44("<`2s0cD:mQ&o!GbG)ohtsWbs05T#rt=S5=W`e+r8Ot\-H,ral(e9p;>U;5 + Z at Mt4SH&7Ec0<=Ab5[3[s6*&!s3i[`[9*D.M3"J4!?m0drrMX;rr7K~> + rr3!HnaZV[SpI44("<`2s0cD:mQ&o!GbG)ohtsWbs05T#rt=S5=W`e+r8Ot\-H,ral(e9p;>U;5 + Z at Mt4SH&7Ec0<=Ab5[3[s6*&!s3i[`[9*D.M3"J4!?m0drrMX;rr7K~> + rr3!HnaZV[SpI44("<`2s0cD:mQ&o!GbG)ohtsWbs05T#rt=S5=W`e+r8Ot\-H,ral(e9p;>U;5 + Z at Mt4SH&7Ec0<=Ab5[3[s6*&!s3i[`[9*D.M3"J4!?m0drrMX;rr7K~> + rr3!HnaZV[SpI44("<`2s0cD:mRH7:GbG)[K#X6Ws05T$rtE]Xs800Vo at j6Eri3=)s2;Oh^`<4N + *SkW5Mp24o7c"+Em<$*`LB$I5ec57qh6gens+uf4rrF;.nG`OZ-iX-r~> + rr3!HnaZV[SpI44("<`2s0cD:mRH7:GbG)[K#X6Ws05T$rtE]Xs800Vo at j6Eri3=)s2;Oh^`<4N + *SkW5Mp24o7c"+Em<$*`LB$I5ec57qh6gens+uf4rrF;.nG`OZ-iX-r~> + rr3!HnaZV[SpI44("<`2s0cD:mRH7:GbG)[K#X6Ws05T$rtE]Xs800Vo at j6Eri3=)s2;Oh^`<4N + *SkW5Mp24o7c"+Em<$*`LB$I5ec57qh6gens+uf4rrF;.nG`OZ-iX-r~> + rr3!HnaZV[SpI44("<`2s0cD:mRH7:GbE27nc$C's05T$rsr*(s8VPKjD+\os3\:Ts2"^7!J?^8 + ruK:3N5,Dmog[d;qC9VeOGgVH)#3V#!V%Q:s*t~> + rr3!HnaZV[SpI44("<`2s0cD:mRH7:GbE27nc$C's05T$rsr*(s8VPKjD+\os3\:Ts2"^7!J?^8 + ruK:3N5,Dmog[d;qC9VeOGgVH)#3V#!V%Q:s*t~> + rr3!HnaZV[SpI44("<`2s0cD:mRH7:GbE27nc$C's05T$rsr*(s8VPKjD+\os3\:Ts2"^7!J?^8 + ruK:3N5,Dmog[d;qC9VeOGgVH)#3V#!V%Q:s*t~> + rr3!HnaZV[YVi9W(\Fj=UA(BZdDS)_l!f=u9?5;?.?BT\hYdBh2P&71SDiNhWmT+bn_0R;n,N*M + 1su$qruTl\?XKGfaZ?j(r*cGLHo$*48Z:%A^$M"^fBR?un>?3dX_dJ+!V%Q:s*t~> + rr3!HnaZV[YVi9W(\Fj=UA(BZdDS)_l!f=u9?5;?.?BT\hYdBh2P&71SDiNhWmT+bn_0R;n,N*M + 1su$qruTl\?XKGfaZ?j(r*cGLHo$*48Z:%A^$M"^fBR?un>?3dX_dJ+!V%Q:s*t~> + rr3!HnaZV[YVi9W(\Fj=UA(BZdDS)_l!f=u9?5;?.?BT\hYdBh2P&71SDiNhWmT+bn_0R;n,N*M + 1su$qruTl\?XKGfaZ?j(r*cGLHo$*48Z:%A^$M"^fBR?un>?3dX_dJ+!V%Q:s*t~> + rr3!HnaQPY)5[?:dmlo(hK\uh$"g#(8'Tjb?N5$E7f[i4rt_^.7sG"5lbLP2;?-Z47n:;ngIt+- + g&D!nlAMXQ\k!o47n;M;o4:GU9PZ:@DmX%,[rVZ-["D"%B)nL+>9J,~> + rr3!HnaQPY)5[?:dmlo(hK\uh$"g#(8'Tjb?N5$E7f[i4rt_^.7sG"5lbLP2;?-Z47n:;ngIt+- + g&D!nlAMXQ\k!o47n;M;o4:GU9PZ:@DmX%,[rVZ-["D"%B)nL+>9J,~> + rr3!HnaQPY)5[?:dmlo(hK\uh$"g#(8'Tjb?N5$E7f[i4rt_^.7sG"5lbLP2;?-Z47n:;ngIt+- + g&D!nlAMXQ\k!o47n;M;o4:GU9PZ:@DmX%,[rVZ-["D"%B)nL+>9J,~> + rr3!HnaQPY)1hhUrs-F_jT#7P/,T)@!pEG1S,WLMD"%B)nL+>9J,~> + rr3!HnaQPY)1hhUrs-F_jT#7P/,T)@!pEG1S,WLMD"%B)nL+>9J,~> + rr3!HnaQPY)1hhUrs-F_jT#7P/,T)@!pEG1S,WLMD"%B)nL+>9J,~> + rr3!HnaQPY)1hhUrs&DmOGo.!p%SIhf,+rOigg#L3hu0D!V%Q:s*t~> + rr3!HnaQPY)1hhUrs&DmOGo.!p%SIhf,+rOigg#L3hu0D!V%Q:s*t~> + rr3!HnaQPY)1hhUrs&DmOGo.!p%SIhf,+rOigg#L3hu0D!V%Q:s*t~> + rr3!HnaQPY)1hhas8VS>s8Ds!hAG, + rr3!HnaQPY)1hhas8VS>s8Ds!hAG, + rr3!HnaQPY)1hhas8VS>s8Ds!hAG, + rr3!HnaQPZ'XiSmqu?\TJcG]K!ld4mn,EFY-iX-r~> + rr3!HnaQPZ'XiSmqu?\TJcG]K!ld4mn,EFY-iX-r~> + rr3!HnaQPZ'XiSmqu?\TJcG]K!ld4mn,EFY-iX-r~> + rr3!HnaQPZ&sInHqu?\TJcG]K!Gk[%rrMX;rr7K~> + rr3!HnaQPZ&sInHqu?\TJcG]K!Gk[%rrMX;rr7K~> + rr3!HnaQPZ&sInHqu?\TJcG]K!Gk[%rrMX;rr7K~> + rr3!HnaQPZ&sInHqu?\TJcG`L!q at pAmf*=X-iX-r~> + rr3!HnaQPZ&sInHqu?\TJcG`L!q at pAmf*=X-iX-r~> + rr3!HnaQPZ&sInHqu?\TJcG`L!q at pAmf*=X-iX-r~> + rr3!HnaQPZ&sInHqu?\TJcG`L!oF!>mf*=X-iX-r~> + rr3!HnaQPZ&sInHqu?\TJcG`L!oF!>mf*=X-iX-r~> + rr3!HnaQPZ&sInHqu?\TJcG`L!oF!>mf*=X-iX-r~> + rr3!HnaQPZ&q5E3rVm&eO>A\!eq*i's5*gqmf*=X-iX-r~> + rr3!HnaQPZ&q5E3rVm&eO>A\!eq*i's5*gqmf*=X-iX-r~> + rr3!HnaQPZ&q5E3rVm&eO>A\!eq*i's5*gqmf*=X-iX-r~> + rr3!HnaQPZ1Eh>LrVm&qQNR:5d=M<"s,/Armf*=X-iX-r~> + rr3!HnaQPZ1Eh>LrVm&qQNR:5d=M<"s,/Armf*=X-iX-r~> + rr3!HnaQPZ1Eh>LrVm&qQNR:5d=M<"s,/Armf*=X-iX-r~> + rr3!HnaQPZKcu$Ir;Ql`'FM7!s8W*"Cmj\j!V%Q:s*t~> + rr3!HnaQPZKcu$Ir;Ql`'FM7!s8W*"Cmj\j!V%Q:s*t~> + rr3!HnaQPZKcu$Ir;Ql`'FM7!s8W*"Cmj\j!V%Q:s*t~> + rr3!HnaQPZKcu$Iqu6_C3pqS!"980%XR6#gnL+>9J,~> + rr3!HnaQPZKcu$Iqu6_C3pqS!"980%XR6#gnL+>9J,~> + rr3!HnaQPZKcu$Iqu6_C3pqS!"980%XR6#gnL+>9J,~> + rr3!HnaQPZKcu$Iqu6_VCAi_`"98-0h9J,~> + rr3!HnaQPZKcu$Iqu6_VCAi_`"98-0h9J,~> + rr3!HnaQPZKcu$Iqu6_VCAi_`"98-0h9J,~> + rr3!HnaQPZe02:#!3aF>!A#M::]R]1rrK,Bm/I+V-iX-r~> + rr3!HnaQPZe02:#!3aF>!A#M::]R]1rrK,Bm/I+V-iX-r~> + rr3!HnaQPZe02:#!3aF>!A#M::]R]1rrK,Bm/I+V-iX-r~> + rr3!HnaQPZp`[*G!K/Xk9J,~> + rr3!HnaQPZp`[*G!K/Xk9J,~> + rr3!HnaQPZp`[*G!K/Xk9J,~> + rr3!HnaQPZp`[*G!K2ttrrF's]Dhr_$^9rW!V%Q:s*t~> + rr3!HnaQPZp`[*G!K2ttrrF's]Dhr_$^9rW!V%Q:s*t~> + rr3!HnaQPZp`[*G!K2ttrrF's]Dhr_$^9rW!V%Q:s*t~> + rr3!HnaQP[p^bi_rrJ%9J,~> + rr3!HnaQP[p^bi_rrJ%9J,~> + rr3!HnaQP[p^bi_rrJ%9J,~> + rr3!HnaQP[r'd`srrJ% + rr3!HnaQP[r'd`srrJ% + rr3!HnaQP[r'd`srrJ% + rr3!HnaHJYCot2H!K3!$rs89s_u9W8^]NBfrrW1f6Mg]an\m + rr3!HnaHJYCot2H!K3!$rs89s_u9W8^]NBfrrW1f6Mg]an\m + rr3!HnaHJYCot2H!K3!$rs89s_u9W8^]NBfrrW1f6Mg]an\m + rr3!HnaHJYCk0"p!K3!$rrTE-oD\akl7:`drrW.V6Mg]fm+FtVs8UuV')DP.r+ssa!?6s0rrT\1 + m-FZPnL+>9J,~> + rr3!HnaHJYCk0"p!K3!$rrTE-oD\akl7:`drrW.V6Mg]fm+FtVs8UuV')DP.r+ssa!?6s0rrT\1 + m-FZPnL+>9J,~> + rr3!HnaHJYCk0"p!K3!$rrTE-oD\akl7:`drrW.V6Mg]fm+FtVs8UuV')DP.r+ssa!?6s0rrT\1 + m-FZPnL+>9J,~> + rr3!HnaHJYCc]'*!K3!%rrW'IWVlcVb4b=_NN`3YrNi#r97Hp/A:U!?s6SEVWrM4oY"/Nlq3I#1 + puuWr`nBs:R.1'jNJcKiTIu^nDYE;o!?6s0rrTP\p$;VYnL+>9J,~> + rr3!HnaHJYCc]'*!K3!%rrW'IWVlcVb4b=_NN`3YrNi#r97Hp/A:U!?s6SEVWrM4oY"/Nlq3I#1 + puuWr`nBs:R.1'jNJcKiTIu^nDYE;o!?6s0rrTP\p$;VYnL+>9J,~> + rr3!HnaHJYCc]'*!K3!%rrW'IWVlcVb4b=_NN`3YrNi#r97Hp/A:U!?s6SEVWrM4oY"/Nlq3I#1 + puuWr`nBs:R.1'jNJcKiTIu^nDYE;o!?6s0rrTP\p$;VYnL+>9J,~> + rr3!HnaHJYCc]'*!K3!%rrS;mi;?lMgnT-iX-r~> + rr3!HnaHJYCc]'*!K3!%rrS;mi;?lMgnT-iX-r~> + rr3!HnaHJYCc]'*!K3!%rrS;mi;?lMgnT-iX-r~> + rr3!HnaHJYLH;pE!K3!%rrT8:i;N[(f?$g]s8QnZYsdpXkXaK_@`HEGY5c9&cUm`;s(&M)B6+%P + R7bjtY5\G29[0Lgnc.Ylhm[(ps##SqrrF's^&J.c!7U65!V%Q:s*t~> + rr3!HnaHJYLH;pE!K3!%rrT8:i;N[(f?$g]s8QnZYsdpXkXaK_@`HEGY5c9&cUm`;s(&M)B6+%P + R7bjtY5\G29[0Lgnc.Ylhm[(ps##SqrrF's^&J.c!7U65!V%Q:s*t~> + rr3!HnaHJYLH;pE!K3!%rrT8:i;N[(f?$g]s8QnZYsdpXkXaK_@`HEGY5c9&cUm`;s(&M)B6+%P + R7bjtY5\G29[0Lgnc.Ylhm[(ps##SqrrF's^&J.c!7U65!V%Q:s*t~> + rr3!HnaHJYhE&.G!K3!$rrGihrr3T#]Z;kCs77R]R9B+\d6%A?Xo/2DN;ro0V + rr3!HnaHJYhE&.G!K3!$rrGihrr3T#]Z;kCs77R]R9B+\d6%A?Xo/2DN;ro0V + rr3!HnaHJYhE&.G!K3!$rrGihrr3T#]Z;kCs77R]R9B+\d6%A?Xo/2DN;ro0V + rr3!HnaHJYhE&.G!K3!$s$,RnY55f?pA`m#ool]Npm&qgC.SBhJaMR/h=jnKs&6K.jsK^"l at JQ' + S*S-Z_mAaa56(YS_:O7ir*$l8^f]e"!?6s2rrVQpXm,idnL+>9J,~> + rr3!HnaHJYhE&.G!K3!$s$,RnY55f?pA`m#ool]Npm&qgC.SBhJaMR/h=jnKs&6K.jsK^"l at JQ' + S*S-Z_mAaa56(YS_:O7ir*$l8^f]e"!?6s2rrVQpXm,idnL+>9J,~> + rr3!HnaHJYhE&.G!K3!$s$,RnY55f?pA`m#ool]Npm&qgC.SBhJaMR/h=jnKs&6K.jsK^"l at JQ' + S*S-Z_mAaa56(YS_:O7ir*$l8^f]e"!?6s2rrVQpXm,idnL+>9J,~> + rr3!HnaHJZn1DYirrJ% + rr3!HnaHJZn1DYirrJ% + rr3!HnaHJZn1DYirrJ% + rr3!Hna?DX;T?6H!K2ttrrF's^Ae3;GNf&-nL+>9J,~> + rr3!Hna?DX;T?6H!K2ttrrF's^Ae3;GNf&-nL+>9J,~> + rr3!Hna?DX;T?6H!K2ttrrF's^Ae3;GNf&-nL+>9J,~> + rr3!Hna?DX;K95H!K2ttrrF's^]+Am$G>U&!V%Q:s*t~> + rr3!Hna?DX;K95H!K2ttrrF's^]+Am$G>U&!V%Q:s*t~> + rr3!Hna?DX;K95H!K2ttrrF's^]+Am$G>U&!V%Q:s*t~> + rr3!Hna?DX;H(+*!K3!+rrMrWUAk65Mnf8mA3oDY!V%Q:s*t~> + rr3!Hna?DX;H(+*!K3!+rrMrWUAk65Mnf8mA3oDY!V%Q:s*t~> + rr3!Hna?DX;H(+*!K3!+rrMrWUAk65Mnf8mA3oDY!V%Q:s*t~> + rr3!Hna?DY;C_.GrrJ%oq]1XYrrMX;rr7K~> + rr3!Hna?DY;C_.GrrJ%oq]1XYrrMX;rr7K~> + rr3!Hna?DY;C_.GrrJ%oq]1XYrrMX;rr7K~> + rr3!Hna?DYQN5pRrrJ%Y+mTh>cnsL]7;U + rdJ>RlMgl(Mno>oAe=k&rrMX;rr7K~> + rr3!Hna?DYQN5pRrrJ%Y+mTh>cnsL]7;U + rdJ>RlMgl(Mno>oAe=k&rrMX;rr7K~> + rr3!Hna?DYQN5pRrrJ%Y+mTh>cnsL]7;U + rdJ>RlMgl(Mno>oAe=k&rrMX;rr7K~> + rr3!Hna?DY`;nf+rrJ%aSf&T6b2!V%Q:s*t~> + rr3!Hna?DY`;nf+rrJ%aSf&T6b2!V%Q:s*t~> + rr3!Hna?DY`;nf+rrJ%aSf&T6b2!V%Q:s*t~> + rr3!Hna?DYo.Ak1rrJ% + rr3!Hna?DYo.Ak1rrJ% + rr3!Hna?DYo.Ak1rrJ% + rr3!Hna6>W3T%CI!K3!-s!aLns8TcVFoT8po!qJ1\WDIndTUgU3?o_<6So(W0hWO[&n + qu7?fZ,Xe`6MLNUD^QgCs8VLY+$c\%rr3;+s1;8-s8QO9l1"]R)iMT5!q7dtjo5AO-iX-r~> + rr3!Hna6>W3T%CI!K3!-s!aLns8TcVFoT8po!qJ1\WDIndTUgU3?o_<6So(W0hWO[&n + qu7?fZ,Xe`6MLNUD^QgCs8VLY+$c\%rr3;+s1;8-s8QO9l1"]R)iMT5!q7dtjo5AO-iX-r~> + rr3!Hna6>W3T%CI!K3!-s!aLns8TcVFoT8po!qJ1\WDIndTUgU3?o_<6So(W0hWO[&n + qu7?fZ,Xe`6MLNUD^QgCs8VLY+$c\%rr3;+s1;8-s8QO9l1"]R)iMT5!q7dtjo5AO-iX-r~> + rr3!Hna6>WG\t"k!K3!-rrI:mrr47>FoVIZs8Qi.s7fo:Z97"DoGmc.nF,s + rr3!Hna6>WG\t"k!K3!-rrI:mrr47>FoVIZs8Qi.s7fo:Z97"DoGmc.nF,s + rr3!Hna6>WG\t"k!K3!-rrI:mrr47>FoVIZs8Qi.s7fo:Z97"DoGmc.nF,s + rr3!Hna6>XXB5D4rrJ%ZO]h&12rr3;kMuWh(bgOp1`p + rr3!Hna6>XXB5D4rrJ%ZO]h&12rr3;kMuWh(bgOp1`p + rr3!Hna6>XXB5D4rrJ%ZO]h&12rr3;kMuWh(bgOp1`p + rr3!Hna6>XX8r%,rrJ%9J,~> + rr3!Hna6>XX8r%,rrJ%9J,~> + rr3!Hna6>XX8r%,rrJ%9J,~> + rr3!Hna6>XX8r%,rrJ%VsfGdZIrrMX;rr7K~> + rr3!Hna6>XX8r%,rrJ%VsfGdZIrrMX;rr7K~> + rr3!Hna6>XX8r%,rrJ%VsfGdZIrrMX;rr7K~> + rr3!Hna6>Xq]>ODrrJ%:s0$p%]DqD]It,c?li$>Q!?6s8rrSMsqW%SVnL+>9J,~> + rr3!Hna6>Xq]>ODrrJ%:s0$p%]DqD]It,c?li$>Q!?6s8rrSMsqW%SVnL+>9J,~> + rr3!Hna6>Xq]>ODrrJ%:s0$p%]DqD]It,c?li$>Q!?6s8rrSMsqW%SVnL+>9J,~> + rr3!Hna-8V+LJ`[!K3!,rrUiXrVQTtpt8i/o>1G.aeAFtrrF's`W$#",`Ug`!V%Q:s*t~> + rr3!Hna-8V+LJ`[!K3!,rrUiXrVQTtpt8i/o>1G.aeAFtrrF's`W$#",`Ug`!V%Q:s*t~> + rr3!Hna-8V+LJ`[!K3!,rrUiXrVQTtpt8i/o>1G.aeAFtrrF's`W$#",`Ug`!V%Q:s*t~> + rr3!Hna-8VE/(t(!K3!,rrW/Q^\e$6h*=4l_86-P]Ai;Z!?6s9rrPP*oA]cNnL+>9J,~> + rr3!Hna-8VE/(t(!K3!,rrW/Q^\e$6h*=4l_86-P]Ai;Z!?6s9rrPP*oA]cNnL+>9J,~> + rr3!Hna-8VE/(t(!K3!,rrW/Q^\e$6h*=4l_86-P]Ai;Z!?6s9rrPP*oA]cNnL+>9J,~> + rr3!Hna-8VP:F0D!K2ttrrF's`r?+n%>s-E!V%Q:s*t~> + rr3!Hna-8VP:F0D!K2ttrrF's`r?+n%>s-E!V%Q:s*t~> + rr3!Hna-8VP:F0D!K2ttrrF's`r?+n%>s-E!V%Q:s*t~> + rr3!Hna-8WP7#gOrrJ% + rr3!Hna-8WP7#gOrrJ% + rr3!Hna-8WP7#gOrrJ% + rr3!Hna-8Wc30cOrrJ% + rr3!Hna-8Wc30cOrrJ% + rr3!Hna-8Wc30cOrrJ% + rr3!Hna$2U*hU(E!K3!!rrGF/rVlri2r_1D!?6s9J,~> + rr3!Hna$2U*hU(E!K3!!rrGF/rVlri2r_1D!?6s9J,~> + rr3!Hna$2U*hU(E!K3!!rrGF/rVlri2r_1D!?6s9J,~> + rr3!Hna$2UH$m7(!K3!!rrGF/rVlri2r_1D!?6s=rrV:m3Ssc:nL+>9J,~> + rr3!Hna$2UH$m7(!K3!!rrGF/rVlri2r_1D!?6s=rrV:m3Ssc:nL+>9J,~> + rr3!Hna$2UH$m7(!K3!!rrGF/rVlri2r_1D!?6s=rrV:m3Ssc:nL+>9J,~> + rr3!Hna$2VW#F[.rrJ%9J,~> + rr3!Hna$2VW#F[.rrJ%9J,~> + rr3!Hna$2VW#F[.rrJ%9J,~> + rr3!Hna$2Vli=Q.rrJ%^qbT"s4O'WL6C"c at cBSF + ku<<5ru91Y^4=hS0V?ur[]t*K]rc#!^eT-T$*(/DTgeDL!?6s>rrTn9V;;.PnL+>9J,~> + rr3!Hna$2Vli=Q.rrJ%^qbT"s4O'WL6C"c at cBSF + ku<<5ru91Y^4=hS0V?ur[]t*K]rc#!^eT-T$*(/DTgeDL!?6s>rrTn9V;;.PnL+>9J,~> + rr3!Hna$2Vli=Q.rrJ%^qbT"s4O'WL6C"c at cBSF + ku<<5ru91Y^4=hS0V?ur[]t*K]rc#!^eT-T$*(/DTgeDL!?6s>rrTn9V;;.PnL+>9J,~> + rr3!Hna$2Vli;+>rrJ%"4nVao\KNJnL+>9J,~> + rr3!Hna$2Vli;+>rrJ%"4nVao\KNJnL+>9J,~> + rr3!Hna$2Vli;+>rrJ%"4nVao\KNJnL+>9J,~> + rr3!Hna$2Vq*[ZarrJ% + rr3!Hna$2Vq*[ZarrJ% + rr3!Hna$2Vq*[ZarrJ% + rr3!Hn`p,UM(S20rrJ%9J,~> + rr3!Hn`p,UM(S20rrJ%9J,~> + rr3!Hn`p,UM(S20rrJ%9J,~> + rr3!Hn`p,Udf at e/rrJ%(Qm@%Drr3\dDC_p;=[:3qI=mHBs8U_d + s0Igdqu7VpG)(t,PqLV''mINg + rr3!Hn`p,Udf at e/rrJ%(Qm@%Drr3\dDC_p;=[:3qI=mHBs8U_d + s0Igdqu7VpG)(t,PqLV''mINg + rr3!Hn`p,Udf at e/rrJ%(Qm@%Drr3\dDC_p;=[:3qI=mHBs8U_d + s0Igdqu7VpG)(t,PqLV''mINg + rr3!Hn`g&S7pit0!K3!+rtFjfP44L9J,~> + rr3!Hn`g&S7pit0!K3!+rtFjfP44L9J,~> + rr3!Hn`g&S7pit0!K3!+rtFjfP44L9J,~> + rr3!Hn`g)R?bQI?MiP(B"O;L!ir7s;!?6sCrr^:W6MfC8!V%Q:s*t~> + rr3!Hn`g)R?bQI?MiP(B"O;L!ir7s;!?6sCrr^:W6MfC8!V%Q:s*t~> + rr3!Hn`g)R?bQI?MiP(B"O;L!ir7s;!?6sCrr^:W6MfC8!V%Q:s*t~> + rr3!Hn`g&T\ejkMrrJ% + rr3!Hn`g&T\ejkMrrJ% + rr3!Hn`g&T\ejkMrrJ% + rr3!Hn`g&Tod>R0rrJ% + rr3!Hn`g&Tod>R0rrJ% + rr3!Hn`g&Tod>R0rrJ% + rr3!Hn`]uR1^^ts!K2uXrrW&jo_ndnq""@^pA+=[!P?eArrF'sdf0Et8e]M$rrMX;rr7K~> + rr3!Hn`]uR1^^ts!K2uXrrW&jo_ndnq""@^pA+=[!P?eArrF'sdf0Et8e]M$rrMX;rr7K~> + rr3!Hn`]uR1^^ts!K2uXrrW&jo_ndnq""@^pA+=[!P?eArrF'sdf0Et8e]M$rrMX;rr7K~> + rr3!Hn`]uRY6_lB!K3!$rrMlmir9,qYpTirquctqnCkJrrF'se,KOC=;'$3 + rrMX;rr7K~> + rr3!Hn`]uRY6_lB!K3!$rrMlmir9,qYpTirquctqnCkJrrF'se,KOC=;'$3 + rrMX;rr7K~> + rr3!Hn`]uRY6_lB!K3!$rrMlmir9,qYpTirquctqnCkJrrF'se,KOC=;'$3 + rrMX;rr7K~> + rr3!Hn`ToQ(9tXS!K3!$rrL:7iVru(8,3&_">\L,m.L5T!Q=j3rrVhNp?2GV)iN5G"4p]mb1-Fl + nL+>9J,~> + rr3!Hn`ToQ(9tXS!K3!$rrL:7iVru(8,3&_">\L,m.L5T!Q=j3rrVhNp?2GV)iN5G"4p]mb1-Fl + nL+>9J,~> + rr3!Hn`ToQ(9tXS!K3!$rrL:7iVru(8,3&_">\L,m.L5T!Q=j3rrVhNp?2GV)iN5G"4p]mb1-Fl + nL+>9J,~> + rr3!Hn`ToQEAYH1!K3!%rrW.Ko\ofObt%R-rrFn)q#:EUPkt:W!r6fQkPkQ%Mq.h0d6SSie,KI= + -iX-r~> + rr3!Hn`ToQEAYH1!K3!%rrW.Ko\ofObt%R-rrFn)q#:EUPkt:W!r6fQkPkQ%Mq.h0d6SSie,KI= + -iX-r~> + rr3!Hn`ToQEAYH1!K3!%rrW.Ko\ofObt%R-rrFn)q#:EUPkt:W!r6fQkPkQ%Mq.h0d6SSie,KI= + -iX-r~> + rr3!Hn`ToRL_/4SrrJ%J"TH[Y'[+r)!V%Q:s*t~> + rr3!Hn`ToRL_/4SrrJ%J"TH[Y'[+r)!V%Q:s*t~> + rr3!Hn`ToRL_/4SrrJ%J"TH[Y'[+r)!V%Q:s*t~> + rr3!Hn`ToRrB?ggrrJ%:s#K!%VsTt^s4or[h^Id&GKiYFUuhXV + 1=Z>GJa at pNs+gW>C\mo-!KD?errF'sf`)'LScDL3rrMX;rr7K~> + rr3!Hn`ToRrB?ggrrJ%:s#K!%VsTt^s4or[h^Id&GKiYFUuhXV + 1=Z>GJa at pNs+gW>C\mo-!KD?errF'sf`)'LScDL3rrMX;rr7K~> + rr3!Hn`ToRrB?ggrrJ%:s#K!%VsTt^s4or[h^Id&GKiYFUuhXV + 1=Z>GJa at pNs+gW>C\mo-!KD?errF'sf`)'LScDL3rrMX;rr7K~> + rr3!Hn`KiQDA1[=rrJ% + rr3!Hn`KiQDA1[=rrJ% + rr3!Hn`KiQDA1[=rrJ% + rr3!Hn`KiQ`;mimrrJ% + rr3!Hn`KiQ`;mimrrJ% + rr3!Hn`KiQ`;mimrrJ% + rr3!Hn`KiRqfk?q_Z'XpNp-KMjtl/9s3Y9CP'kaVs"OD0P5TF/s8TrPnq)PKha[2:s34(/S2ess + 1=Z>GJ_W9/oSEOY + rr3!Hn`KiRqfk?q_Z'XpNp-KMjtl/9s3Y9CP'kaVs"OD0P5TF/s8TrPnq)PKha[2:s34(/S2ess + 1=Z>GJ_W9/oSEOY + rr3!Hn`KiRqfk?q_Z'XpNp-KMjtl/9s3Y9CP'kaVs"OD0P5TF/s8TrPnq)PKha[2:s34(/S2ess + 1=Z>GJ_W9/oSEOY + rr3!Hn`BcP`rOr4rrJ%rrF'sh>[WUSg"d?bl7_6-iX-r~> + rr3!Hn`BcP`rOr4rrJ%rrF'sh>[WUSg"d?bl7_6-iX-r~> + rr3!Hn`BcP`rOr4rrJ%rrF'sh>[WUSg"d?bl7_6-iX-r~> + rr3!Hn`BcQkr2W=_uBaqNiN*\k)fB$rrF'shZ!]);[[ckrrMX;rr7K~> + rr3!Hn`BcQkr2W=_uBaqNiN*\k)fB$rrF'shZ!]);[[ckrrMX;rr7K~> + rr3!Hn`BcQkr2W=_uBaqNiN*\k)fB$rrF'shZ!]);[[ckrrMX;rr7K~> + rr3!Hn`9]OXoP98rrJ% + rr3!Hn`9]OXoP98rrJ% + rr3!Hn`9]OXoP98rrJ% + rr3!Hn`9]On/PWLrrJ% + rr3!Hn`9]On/PWLrrJ% + rr3!Hn`9]On/PWLrrJ% + rr3!Hn`0WN]EP(KrrJ#da;+db!p17!$52G9!$>nL+>9J,~> + rr3!Hn`0WN]EP(KrrJ#da;+db!p17!$52G9!$>nL+>9J,~> + rr3!Hn`0WN]EP(KrrJ#da;+db!p17!$52G9!$>nL+>9J,~> + rr3!Hn`'QM8gX5NrrC9iO91&U>Q+U'&j!sm!6jU*"o at 4_!$8)WrrMX;rr7K~> + rr3!Hn`'QM8gX5NrrC9iO91&U>Q+U'&j!sm!6jU*"o at 4_!$8)WrrMX;rr7K~> + rr3!Hn`'QM8gX5NrrC9iO91&U>Q+U'&j!sm!6jU*"o at 4_!$8)WrrMX;rr7K~> + rr3!Hn`'QMdm7`7rs at M],nUYW;d%uErZoIg;EpknL+>9J,~> + rr3!Hn`'QMdm7`7rs at M],nUYW;d%uErZoIg;EpknL+>9J,~> + rr3!Hn`'QMdm7`7rs at M],nUYW;d%uErZoIg;EpknL+>9J,~> + rr3!Hn_sKLLCgn`rs?f)4?ODp;,Y9J,~> + rr3!Hn_sKLLCgn`rs?f)4?ODp;,Y9J,~> + rr3!Hn_sKLLCgn`rs?f)4?ODp;,Y9J,~> + rr3!Hn_sKMq*,;SU&PJeQ'IOW$NM_th<(O5"i?NZ!,po4rrMX;rr7K~> + rr3!Hn_sKMq*,;SU&PJeQ'IOW$NM_th<(O5"i?NZ!,po4rrMX;rr7K~> + rr3!Hn_sKMq*,;SU&PJeQ'IOW$NM_th<(O5"i?NZ!,po4rrMX;rr7K~> + rr3!Hn_jEKgE8\Xrse_jTR2#M&eP^GOn\VHV#LYqO*D*GNq^6e!V%Q:s*t~> + rr3!Hn_jEKgE8\Xrse_jTR2#M&eP^GOn\VHV#LYqO*D*GNq^6e!V%Q:s*t~> + rr3!Hn_jEKgE8\Xrse_jTR2#M&eP^GOn\VHV#LYqO*D*GNq^6e!V%Q:s*t~> + rr3!Hn_a?KZ3?ulY5\mseC:j61B7b4>FsQ at rrpr37fZlG])Mg$-iX-r~> + rr3!Hn_a?KZ3?ulY5\mseC:j61B7b4>FsQ at rrpr37fZlG])Mg$-iX-r~> + rr3!Hn_a?KZ3?ulY5\mseC:j61B7b4>FsQ at rrpr37fZlG])Mg$-iX-r~> + rr3!Hn_X9JB`NMK[Jp6mrjiE/81=N=12s_3a.NA;p:@h9!XtI*qRQV,nL+>9J,~> + rr3!Hn_X9JB`NMK[Jp6mrjiE/81=N=12s_3a.NA;p:@h9!XtI*qRQV,nL+>9J,~> + rr3!Hn_X9JB`NMK[Jp6mrjiE/81=N=12s_3a.NA;p:@h9!XtI*qRQV,nL+>9J,~> + rr3!Hn_X9Jl at o;*\Gli8Ti`H + rr3!Hn_X9Jl at o;*\Gli8Ti`H + rr3!Hn_X9Jl at o;*\Gli8Ti`H + rr3!Hn_O3Jn6cMhou@"3r;HHsY_QBs'c%]KrHJA'p7;3jrqcK)4r"SjG`qU'rrMX;rr7K~> + rr3!Hn_O3Jn6cMhou@"3r;HHsY_QBs'c%]KrHJA'p7;3jrqcK)4r"SjG`qU'rrMX;rr7K~> + rr3!Hn_O3Jn6cMhou@"3r;HHsY_QBs'c%]KrHJA'p7;3jrqcK)4r"SjG`qU'rrMX;rr7K~> + rr3!Hn_='GX;(rLbl7k7i8B*&/H,VN&Kc,oOT;JMrs at fFSQ#Ru.$9Y(YQ"Xn-iX-r~> + rr3!Hn_='GX;(rLbl7k7i8B*&/H,VN&Kc,oOT;JMrs at fFSQ#Ru.$9Y(YQ"Xn-iX-r~> + rr3!Hn_='GX;(rLbl7k7i8B*&/H,VN&Kc,oOT;JMrs at fFSQ#Ru.$9Y(YQ"Xn-iX-r~> + rr3!Hn_4!G[lOst`7Y(irr0q + rr3!Hn_4!G[lOst`7Y(irr0q + rr3!Hn_4!G[lOst`7Y(irr0q + rr3!Hn_*pHr-oOuU93G=rrDliXT2u43rK$_.T00J`Pq/0rrCdOXU1pe3Xc!?;KKhTVuHef-iX-r~> + rr3!Hn_*pHr-oOuU93G=rrDliXT2u43rK$_.T00J`Pq/0rrCdOXU1pe3Xc!?;KKhTVuHef-iX-r~> + rr3!Hn_*pHr-oOuU93G=rrDliXT2u43rK$_.T00J`Pq/0rrCdOXU1pe3Xc!?;KKhTVuHef-iX-r~> + rr3!Hn^mdEkdEPQ'gqGR!,29R!$;% + rr3!Hn^mdEkdEPQ'gqGR!,29R!$;% + rr3!Hn^mdEkdEPQ'gqGR!,29R!$;% + rr3!Hn^[XCr:o6)KhVCW!%IVq!5/($!;WMl!;ZW]#+9d)#6tD4p(@@9qLnpmqtL0jSc8`\-iX-r~> + rr3!Hn^[XCr:o6)KhVCW!%IVq!5/($!;WMl!;ZW]#+9d)#6tD4p(@@9qLnpmqtL0jSc8`\-iX-r~> + rr3!Hn^[XCr:o6)KhVCW!%IVq!5/($!;WMl!;ZW]#+9d)#6tD4p(@@9qLnpmqtL0jSc8`\-iX-r~> + rr3!HnU^_prsA,B_dG_0"=u*^r1 + rr3!HnU^_prsA,B_dG_0"=u*^r1 + rr3!HnU^_prsA,B_dG_0"=u*^r1 + rr3!HnU^_rrs81_.f]lFTX_^es8)`rnL+>9J,~> + rr3!HnU^_rrs81_.f]lFTX_^es8)`rnL+>9J,~> + rr3!HnU^_rrs81_.f]lFTX_^es8)`rnL+>9J,~> + rr3!HnU^_trs%"+,TL0%fRa(rrrMX;rr7K~> + rr3!HnU^_trs%"+,TL0%fRa(rrrMX;rr7K~> + rr3!HnU^_trs%"+,TL0%fRa(rrrMX;rr7K~> + rr3!HnU^`!rrq:1$Ug'GJcG?A!V%Q:s*t~> + rr3!HnU^`!rrq:1$Ug'GJcG?A!V%Q:s*t~> + rr3!HnU^`!rrq:1$Ug'GJcG?A!V%Q:s*t~> + rr3!HnU^`#rrrCk+W45XJcG9?!V%Q:s*t~> + rr3!HnU^`#rrrCk+W45XJcG9?!V%Q:s*t~> + rr3!HnU^`#rrrCk+W45XJcG9?!V%Q:s*t~> + rr3!HnU^`$rrhPB!(?7+s6osgnL+>9J,~> + rr3!HnU^`$rrhPB!(?7+s6osgnL+>9J,~> + rr3!HnU^`$rrhPB!(?7+s6osgnL+>9J,~> + rr3!HnU^`$rrYOiQgTG)mf*=X-iX-r~> + rr3!HnU^`$rrYOiQgTG)mf*=X-iX-r~> + rr3!HnU^`$rrYOiQgTG)mf*=X-iX-r~> + rr3!HnU^`%rrS,_Tn371rrMX;rr7K~> + rr3!HnU^`%rrS,_Tn371rrMX;rr7K~> + rr3!HnU^`%rrS,_Tn371rrMX;rr7K~> + rr3!HnU^`&rrU. at Ck;WPrrMX;rr7K~> + rr3!HnU^`&rrU. at Ck;WPrrMX;rr7K~> + rr3!HnU^`&rrU. at Ck;WPrrMX;rr7K~> + rr3!HnU^`'rr_^50^sYnli."U-iX-r~> + rr3!HnU^`'rr_^50^sYnli."U-iX-r~> + rr3!HnU^`'rr_^50^sYnli."U-iX-r~> + rr3!HnU^`*rrr,A\>B7uJcG$8!V%Q:s*t~> + rr3!HnU^`*rrr,A\>B7uJcG$8!V%Q:s*t~> + rr3!HnU^`*rrr,A\>B7uJcG$8!V%Q:s*t~> + rr3!HnU^`*rrMJ)rVur5JcG$8!V%Q:s*t~> + rr3!HnU^`*rrMJ)rVur5JcG$8!V%Q:s*t~> + rr3!HnU^`*rrMJ)rVur5JcG$8!V%Q:s*t~> + rr3!HnU^`)rrgj_!.4Qns6BUbnL+>9J,~> + rr3!HnU^`)rrgj_!.4Qns6BUbnL+>9J,~> + rr3!HnU^`)rrgj_!.4Qns6BUbnL+>9J,~> + rr3!HnU^`)rr`3u!2P2Gl2LeS-iX-r~> + rr3!HnU^`)rr`3u!2P2Gl2LeS-iX-r~> + rr3!HnU^`)rr`3u!2P2Gl2LeS-iX-r~> + rr3!HnU^`(rrTA8i.:pmrrMX;rr7K~> + rr3!HnU^`(rrTA8i.:pmrrMX;rr7K~> + rr3!HnU^`(rrTA8i.:pmrrMX;rr7K~> + rr3!HnU^`(rrL7[JcFs6!V%Q:s*t~> + rr3!HnU^`(rrL7[JcFs6!V%Q:s*t~> + rr3!HnU^`(rrL7[JcFs6!V%Q:s*t~> + rr3!HnU^`(rrMp5JcFs6!V%Q:s*t~> + rr3!HnU^`(rrMp5JcFs6!V%Q:s*t~> + rr3!HnU^`(rrMp5JcFs6!V%Q:s*t~> + rr3!HnU^`'rrDqIs60I`nL+>9J,~> + rr3!HnU^`'rrDqIs60I`nL+>9J,~> + rr3!HnU^`'rrDqIs60I`nL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnXfa]r64O-!9F"V)4QFYDPHobA6Of0s6,2pN22^rrMX;rr7K~> + rr3!HnXfa]r64O-!9F"V)4QFYDPHobA6Of0s6,2pN22^rrMX;rr7K~> + rr3!HnXfa]r64O-!9F"V)4QFYDPHobA6Of0s6,2pN22^rrMX;rr7K~> + rr3!HnXfa]ng<`'!0$aR!pou:rr3U2..7,Y8s9/KKhhZt>^H8HRkt!B!jMj&JcG9?!V%Q:s*t~> + rr3!HnXfa]ng<`'!0$aR!pou:rr3U2..7,Y8s9/KKhhZt>^H8HRkt!B!jMj&JcG9?!V%Q:s*t~> + rr3!HnXfa]ng<`'!0$aR!pou:rr3U2..7,Y8s9/KKhhZt>^H8HRkt!B!jMj&JcG9?!V%Q:s*t~> + rr3!HnXfa]VC(^1!Omp]rrVQfIfB?[<@I;8 at fXjTs41HTIK6_Ss6E/PrrS#]EIn/[rrMX;rr7K~> + rr3!HnXfa]VC(^1!Omp]rrVQfIfB?[<@I;8 at fXjTs41HTIK6_Ss6E/PrrS#]EIn/[rrMX;rr7K~> + rr3!HnXfa]VC(^1!Omp]rrVQfIfB?[<@I;8 at fXjTs41HTIK6_Ss6E/PrrS#]EIn/[rrMX;rr7K~> + rr3!HnZMm at rMajkGi8UZ%"8/A"K;?k)@TQ*rtl8JHShPus"b26s/-$djGY?8;pbFA!pou/rok%j + ..7,"+Y8b^iVNSP.NaPPh>.$L"MIQ4(AI\*1PHSY<.d$3s.1&ZWA^pZiGXQjZhj^TDiSdG(#'W4 + Y$5Z?SOS&mao?r-"K%/U[a0pNc)q!HnL+>9J,~> + rr3!HnZMm at rMajkGi8UZ%"8/A"K;?k)@TQ*rtl8JHShPus"b26s/-$djGY?8;pbFA!pou/rok%j + ..7,"+Y8b^iVNSP.NaPPh>.$L"MIQ4(AI\*1PHSY<.d$3s.1&ZWA^pZiGXQjZhj^TDiSdG(#'W4 + Y$5Z?SOS&mao?r-"K%/U[a0pNc)q!HnL+>9J,~> + rr3!HnZMm at rMajkGi8UZ%"8/A"K;?k)@TQ*rtl8JHShPus"b26s/-$djGY?8;pbFA!pou/rok%j + ..7,"+Y8b^iVNSP.NaPPh>.$L"MIQ4(AI\*1PHSY<.d$3s.1&ZWA^pZiGXQjZhj^TDiSdG(#'W4 + Y$5Z?SOS&mao?r-"K%/U[a0pNc)q!HnL+>9J,~> + rr3!HnZMm(]I;_;SLVDSA:+ at U!2oks7OJ-7''9bSs3)X>l2M7 at s8N[rs8Q2Vq>UN`!&X[h'-epn + s8UtA"98dhj8\I;#lk-WhZ!NYI+6OE at -%1a1=6ots19P5o'@.I3-b*gM#??fOoIgps.D#cs8OjV + I5COQ;>l8Ip]&M=W;iSM^&N7YXoAFl-iX-r~> + rr3!HnZMm(]I;_;SLVDSA:+ at U!2oks7OJ-7''9bSs3)X>l2M7 at s8N[rs8Q2Vq>UN`!&X[h'-epn + s8UtA"98dhj8\I;#lk-WhZ!NYI+6OE at -%1a1=6ots19P5o'@.I3-b*gM#??fOoIgps.D#cs8OjV + I5COQ;>l8Ip]&M=W;iSM^&N7YXoAFl-iX-r~> + rr3!HnZMm(]I;_;SLVDSA:+ at U!2oks7OJ-7''9bSs3)X>l2M7 at s8N[rs8Q2Vq>UN`!&X[h'-epn + s8UtA"98dhj8\I;#lk-WhZ!NYI+6OE at -%1a1=6ots19P5o'@.I3-b*gM#??fOoIgps.D#cs8OjV + I5COQ;>l8Ip]&M=W;iSM^&N7YXoAFl-iX-r~> + rr3!HnZVs*i$0<4s2Y1Ss($KVrW&krs$e at 7rt=H3huE^i!6Y + rr3!HnZVs*i$0<4s2Y1Ss($KVrW&krs$e at 7rt=H3huE^i!6Y + rr3!HnZVs*i$0<4s2Y1Ss($KVrW&krs$e at 7rt=H3huE^i!6Y + rr3!HnZVsBe,UQZs2Y1Ss($KVrW&krs$e at 8df8GIhuE^i!6Y + rr3!HnZVsBe,UQZs2Y1Ss($KVrW&krs$e at 8df8GIhuE^i!6Y + rr3!HnZVsBe,UQZs2Y1Ss($KVrW&krs$e at 8df8GIhuE^i!6Y + rr3!HnZVsBr0AJXrJhbWs(6QViW,YMs%"I4MZ;fOdf7f0CZPL,ciaK?_"*s!@C"!.">< + ohm1!qI:5FoC]O at O+%M4nFapQHi*D^p&G'R'`u8Kr;SS#)W1S1(NA^#("<-]jt2,\gaQq:TV8Bc + bPM210W4gJ9EKV at R6Bp5`W4HeS3$HDE\73lrrMX;rr7K~> + rr3!HnZVsBr0AJXrJhbWs(6QViW,YMs%"I4MZ;fOdf7f0CZPL,ciaK?_"*s!@C"!.">< + ohm1!qI:5FoC]O at O+%M4nFapQHi*D^p&G'R'`u8Kr;SS#)W1S1(NA^#("<-]jt2,\gaQq:TV8Bc + bPM210W4gJ9EKV at R6Bp5`W4HeS3$HDE\73lrrMX;rr7K~> + rr3!HnZVsBr0AJXrJhbWs(6QViW,YMs%"I4MZ;fOdf7f0CZPL,ciaK?_"*s!@C"!.">< + ohm1!qI:5FoC]O at O+%M4nFapQHi*D^p&G'R'`u8Kr;SS#)W1S1(NA^#("<-]jt2,\gaQq:TV8Bc + bPM210W4gJ9EKV at R6Bp5`W4HeS3$HDE\73lrrMX;rr7K~> + rr3!HnZDg/^L:Q&nc/X at 7qn1f!5SWT5VJZ-jq!!$7_Sg$$_g"&Nt!<5s3`Jcir&fV+oVHB0C\o? + (P?4BKa.T"jo9d>P7IX(gAdTA!-nPDFoD@@I/O!Ld1qCo8B1[nrW!MWs8VP2B3`^]npt(R?T_TF + rW!Xls8%6gDSS74ErZ2No`+tma8u at RY5\Om-iX-r~> + rr3!HnZDg/^L:Q&nc/X at 7qn1f!5SWT5VJZ-jq!!$7_Sg$$_g"&Nt!<5s3`Jcir&fV+oVHB0C\o? + (P?4BKa.T"jo9d>P7IX(gAdTA!-nPDFoD@@I/O!Ld1qCo8B1[nrW!MWs8VP2B3`^]npt(R?T_TF + rW!Xls8%6gDSS74ErZ2No`+tma8u at RY5\Om-iX-r~> + rr3!HnZDg/^L:Q&nc/X at 7qn1f!5SWT5VJZ-jq!!$7_Sg$$_g"&Nt!<5s3`Jcir&fV+oVHB0C\o? + (P?4BKa.T"jo9d>P7IX(gAdTA!-nPDFoD@@I/O!Ld1qCo8B1[nrW!MWs8VP2B3`^]npt(R?T_TF + rW!Xls8%6gDSS74ErZ2No`+tma8u at RY5\Om-iX-r~> + rr3!HnZDfnqSTQ"rVmAJYg]h\li6q3Yj_VS);k>k"o,=+cF(7_rrL$Oqu6Z-ricF;qYdW7f[&dO + Z`q7Fs4?3%\?NLCs5:,cec5[!ricCRr;QiG,jG:-!8[XY!:g'g%,eG/s8Q:Yp&G')'D)4-'\r`g + m'=5"bHTI"Yg<6OYfcC + rr3!HnZDfnqSTQ"rVmAJYg]h\li6q3Yj_VS);k>k"o,=+cF(7_rrL$Oqu6Z-ricF;qYdW7f[&dO + Z`q7Fs4?3%\?NLCs5:,cec5[!ricCRr;QiG,jG:-!8[XY!:g'g%,eG/s8Q:Yp&G')'D)4-'\r`g + m'=5"bHTI"Yg<6OYfcC + rr3!HnZDfnqSTQ"rVmAJYg]h\li6q3Yj_VS);k>k"o,=+cF(7_rrL$Oqu6Z-ricF;qYdW7f[&dO + Z`q7Fs4?3%\?NLCs5:,cec5[!ricCRr;QiG,jG:-!8[XY!:g'g%,eG/s8Q:Yp&G')'D)4-'\r`g + m'=5"bHTI"Yg<6OYfcC + rr3!HnX9CY0a2=-rr\K:#_):C#.eEFkLt,hQ2^mT-iX-r~> + rr3!HnX9CY0a2=-rr\K:#_):C#.eEFkLt,hQ2^mT-iX-r~> + rr3!HnX9CY0a2=-rr\K:#_):C#.eEFkLt,hQ2^mT-iX-r~> + rr3!HnX9CYEH%A^rr]THE2N+("noBYK"h#FrrMX;rr7K~> + rr3!HnX9CYEH%A^rr]THE2N+("noBYK"h#FrrMX;rr7K~> + rr3!HnX9CYEH%A^rr]THE2N+("noBYK"h#FrrMX;rr7K~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!HnU^^ks3:QEnL+>9J,~> + rr3!H[=Q,E^s0Xt[2nW6s*t~> + rr3!H[=Q,E^s0Xt[2nW6s*t~> + rr3!H[=Q,E^s0Xt[2nW6s*t~> + rr2t=JQ[P,b#neks8RT~> + rr2t=JQ[P,b#neks8RT~> + rr2t=JQ[P,b#neks8RT~> + JcC<$_uG5~> + JcC<$_uG5~> + JcC<$_uG5~> + %%EndData + showpage + %%Trailer + end + %%EOF + + %%EndDocument + @endspecial 1033 2499 a Fr(Figure)27 b(1:)37 b(PRE)28 + b(W)-7 b(orklist)27 b(Driv)n(en)h(Approac)n(h)e(from)h([1])0 + 2764 y Fp(4.1)112 b(Assumptions)0 2917 y Fr(The)33 b(assumptions)f + (that)h(w)n(e)g(mak)n(e)f(are)g(as)h(follo)n(ws)f(\(the)h(\034rst)g(t)n + (w)n(o)f(assumptions)g(are)g(directly)h(stated)g(in)g(the)h(pap)r(er,)0 + 3017 y(and)27 b(the)h(latter)g(t)n(w)n(o)e(can)h(easily)g(b)r(e)h + (inferred\):)125 3193 y Fl(\017)41 b Fr("Eac)n(h)26 b + Fo(\036)i Fr(assignmen)n(t)e(has)g(the)i(prop)r(ert)n(y)d(that)j(its)f + (left-hand)g(side)g(and)g(all)g(of)g(its)g(op)r(erands)f(are)g(v)n + (ersions)g(of)h(the)208 3293 y(same)g(original)e(program)h(v)-5 + b(ariable"[1)n(])125 3456 y Fl(\017)41 b Fr("The)27 b(liv)n(e)g(ranges) + f(of)h(di\033eren)n(t)h(v)n(ersions)e(of)h(the)h(same)f(original)f + (program)g(v)-5 b(ariable)26 b(do)h(not)h(o)n(v)n(erlap"[1)m(])125 + 3620 y Fl(\017)41 b Fr(All)28 b(critical)e(edges)h(are)g(brok)n(en;)f + (and)125 3783 y Fl(\017)41 b Fr(W)-7 b(e)28 b(ha)n(v)n(e)e(access)g(to) + i(the)g(dominator)e(tree)h(and)h(dominance)f(fron)n(tiers)f(of)h(basic) + g(blo)r(c)n(ks)125 3959 y(Because)19 b(of)i(the)h(\034rst)f(t)n(w)n(o)f + (assumptions,)h(w)n(e)g(need)g(to)g(disable)g(running)f(a)h(few)g + (optimization)g(passes)f(b)r(efore)h(our)f(pass)0 4059 + y(is)i(run.)35 b(In)23 b(particular,)f Fk(instcombine,)39 + b(mem2reg,)h Fr(and)22 b Fk(reassociate)39 b Fr(shouldn't)23 + b(b)r(e)g(run)f(as)g(they)h(could)f(p)r(oten)n(tially)0 + 4158 y(violate)k(the)i(\034rst)f(t)n(w)n(o)f(assumptions.)36 + b(Of)27 b(course,)f(since)h(our)g(pass)f(is)h(supp)r(osed)g(to)g + (subsume)g(GCSE)h(and)f(LICM,)h(b)r(oth)0 4258 y Fk(gcse)42 + b Fr(and)32 b Fk(licm)41 b Fr(shouldn't)32 b(b)r(e)h(run.)49 + b(In)32 b(order)f(to)h(ensure)f(that)h(critical)f(edges)g(ha)n(v)n(e)g + (b)r(een)h(brok)n(en,)g(the)g(break-crit-)0 4358 y(edges)27 + b(is)g(required)g(b)r(efore)g(our)g(pass.)0 4589 y Fp(4.2)112 + b(Data)38 b(Structures)0 4742 y Fr(Our)30 b(implemen)n(tation)i(of)f + (the)g(algorithm)f(is)h(based)g(on)g(infrastructure)f(that)h(consists)g + (of)g(a)g(hierarc)n(h)n(y)e(of)i(Occurrence)0 4842 y(classes.)55 + b(There)34 b(are)f(5)g(t)n(yp)r(es)h(of)h(o)r(ccurrences:)48 + b(Real,)35 b Fm(\010)p Fr(,)h Fm(\010)e Fr(Op)r(erand,)h(Exit,)i(and)d + (Inserted;)j(their)d(instances)f(trac)n(k)0 4941 y(an)n(y)h + (information)g(ab)r(out)g(them)h(that)g(the)g(pap)r(er)f(sp)r + (eci\034es)g(as)g(necessary)-7 b(.)56 b(The)35 b(main)f(Occurrence)f + (class)h(main)n(tains)0 5041 y(information)c(that)h(is)f(shared)f(b)n + (y)i(all)f(t)n(yp)r(es)g(of)h(o)r(ccurrences.)44 b(This)30 + b(information)g(includes:)43 b(the)31 b(basic)f(blo)r(c)n(k)g(it)g + (exists)0 5141 y(in,)37 b(the)e(instruction)f(it)h(represen)n(ts,)g + (the)g(cac)n(hed)f(temp)r(orary)f(instruction)i(that)g(sa)n(v)n(es)d + (the)k(result)e(\(if)h(an)n(y\),)h(and)f(the)0 5240 y(Redundancy)30 + b(Class)g(Num)n(b)r(er)h(\(R)n(CN\).)g(The)f(Real)h(Occurrence)d(class) + i(has)g(additional)g(\035ags)f(asso)r(ciated)g(with)i(it)g(suc)n(h)0 + 5340 y(as:)57 b(Reload,)40 b(Sa)n(v)n(e,)g(and)e(a)f(p)r(oin)n(ter)h + (to)g(its)g(represen)n(tativ)n(e)e(Occurrence.)67 b Fm(\010)38 + b Fr(Occurrences)e(ha)n(v)n(e)h(\035ags)g(to)h(indicate)1929 + 5589 y(3)p eop end + %%Page: 4 4 + TeXDict begin 4 3 bop 0 83 a Fr(whether)29 b(they)h(are)e(do)n(wnsafe,) + h(extraneous,)g(\020can)n(b)r(ea)n(v)-5 b(ail\021,)28 + b(or)g(are)h(\020later\021.)41 b Fm(\010)30 b Fr(Op)r(erand)e(o)r + (ccurrences)g(main)n(tain)h(what)0 183 y(their)22 b(represen)n(tativ)n + (e)f(o)r(ccurrence)g(is,)i(what)f Fm(\010)h Fr(they)f(b)r(elong)g(to,)i + (what)e(instruction)g(w)n(ould)g(b)r(e)h(inserted)f(there)g(if)h + (needed,)0 282 y(and)31 b(a)g(\035ag)f(indicating)h(if)g(they)h(ha)n(v) + n(e)d(a)i(real)f(use.)47 b(Inserted)31 b(Occurrences)e(and)i(Exit)h + (Occurrences)d(do)i(not)g(store)f(an)n(y)0 382 y(additional)d + (information.)0 614 y Fp(4.3)112 b(P)m(ass)38 b(Details)0 + 768 y Fr(The)28 b(SSAPRE)h(algorithm)d(is)i(done)f(in)h(six)f(separate) + f(phases,)h(whic)n(h)g(are)g(discussed)g(in)h(detail)f(b)r(elo)n(w.)0 + 983 y Fj(4.3.1)94 b(Collect)30 b(Occurrences)0 1137 y + Fr(The)20 b(main)g(idea)g(b)r(ehind)h(the)g(Collect)e(Occurrences)g + (phase)g(is)h(to)g(iden)n(tify)h(lexically)e(iden)n(ti\034ed)3004 + 1106 y Fi(1)3062 1137 y Fr(expressions)g(to)h(partition)0 + 1236 y(them)37 b(in)f(to)h(equiv)-5 b(alence)35 b(classes)g(\(also)h + (referred)f(to)h(as)g(\020o)r(ccurrence)e(sets\021\).)63 + b(Unfortunately)-7 b(,)38 b(the)f(authors)e(do)h(not)0 + 1336 y(describ)r(e)27 b(an)n(y)g(information)g(ho)n(w)g(this)h(is)f(b)r + (est)h(accomplished.)125 1435 y(Since)h(LL)-9 b(VM)30 + b(do)r(es)f(not)g(explicitly)h(represen)n(t)e(the)i(\020SSA)g(v)n + (ersion\021)35 b(of)29 b(a)g(particular)f(\020original\021)35 + b(program)27 b(v)-5 b(ariable,)0 1535 y(w)n(e)25 b(disco)n(v)n(er)e(v)n + (ersions)g(of)i(the)h(same)f(SSA)g(v)-5 b(ariable)24 + b(b)n(y)h(examining)g(where)f(v)-5 b(alues)25 b(are)f(merged)h(b)n(y)f + Fo(\036)p Fr(-no)r(des)i(in)f(the)h(SSA)0 1635 y(represen)n(tation.)38 + b(Whenev)n(er)28 b(w)n(e)g(witness)h(a)f Fo(\036)p Fr(-no)r(de)h(in)g + (the)g(linear)e(scan)h(of)h(the)g(program)d(instructions)3392 + 1605 y Fi(2)3429 1635 y Fr(,)j(w)n(e)f(consider)0 1734 + y(the)33 b(def)g(of)f(the)h Fo(\036)g Fr(and)f(its)h(op)r(erands)e + (\020equiv)-5 b(alen)n(t\021)38 b(for)32 b(purp)r(oses)g(of)g(hashing)g + (expressions)f(to)h(the)h(prop)r(er)e(lexically-)0 1834 + y(iden)n(ti\034ed)24 b(equiv)-5 b(alence)23 b(classes.)35 + b(The)23 b(hashing)g(step)h(can)g(b)r(e)g(made)f(more)g(e\033ectiv)n(e) + h(through)f(the)h(previous)f(application)0 1934 y(of)h(reasso)r + (ciation,)f(but)i(w)n(e)f(ha)n(v)n(e)f(not)i(fully)g(explored)e(the)i + (e\036cacy)e(of)i(suc)n(h)f(reasso)r(ciation,)f(as)g(the)i(LL)-9 + b(VM)24 b(reasso)r(ciation)0 2033 y(pass)j(has)g(the)g(p)r(oten)n(tial) + h(to)f(violate)g(the)h Fo(\036)p Fr(-op)r(erand)e(deadness)h(in)n(v)-5 + b(arian)n(t)26 b(required)h(b)n(y)g(the)h(SSAPRE)h(algorithm.)36 + b(F)-7 b(or)0 2133 y(e\036ciency)g(,)33 b(w)n(e)f(use)g(a)f(Union-Find) + i(mec)n(hanism)e(with)i(b)r(oth)f(Union-By-Rank)f(and)h(P)n(ath)g + (Compression,)g(so)f(that)i(the)0 2232 y(run)n(time)25 + b(cost)f(of)h(determining)g(di\033eren)n(t)f(v)n(ersions)f(of)i(the)g + (same)g(v)-5 b(ariable)23 b(is)i(a)g Fq(smal)t(l)34 b + Fr(\020constan)n(t\021)3153 2202 y Fi(3)3214 2232 y Fr(for)24 + b(an)n(y)g(conceiv)-5 b(able)0 2332 y(program)25 b(size.[4])0 + 2548 y Fj(4.3.2)94 b Fm(\010)34 b Fh(Insertion)0 2701 + y Fr(Our)25 b(implemen)n(tation)h(uses)f(the)i(demand-driv)n(en)d + Fm(\010)k Fq(Insertion)33 b Fr(algorithm[1)n(].)j(\020The)26 + b(resulting)f(algorithm)g(is)g(sparse)g(in)0 2801 y(the)g(sense)f(that) + h(all)f(the)h Fm(\010)p Fr(s)f(inserted)h(are)e(justi\034ed)j(either)e + (b)n(y)g(app)r(earing)g(in)g(the)h(iterated)g(dominance)f(fron)n(tier)f + (of)i(some)0 2900 y(real)e(o)r(ccurrence)g(of)i(the)f(expression)f(or)h + (b)n(y)g(app)r(earing)f(at)h(a)g(p)r(oin)n(t)g(where)g(the)h + (expression)e(is)h(partially)f(an)n(ticipated.\021)7 + b([1)o(])125 3000 y(With)32 b(LL)-9 b(VM,)32 b(sparse)f + Fm(\010)h Fr(insertion)f(is)h(easy)-7 b(.)49 b(Using)32 + b(the)g(dominance)g(fron)n(tier)f(information)g(supplied)h(b)n(y)g(LL) + -9 b(VM,)0 3100 y(w)n(e)31 b(determine)g(the)h(iterated)f(dominance)f + (fron)n(tier)g(\(IDF\))j(for)e(the)g(basic)g(blo)r(c)n(k)g(of)g(an)g + (expression's)e(real)h(o)r(ccurrence.)0 3199 y(That)24 + b(is,)h(w)n(e)f(get)f(the)i(initial)f(dominance)g(fron)n(tier)f(for)h + (the)g(original)f(basic)g(blo)r(c)n(k)h(and)g(then)g(recurse)f(on)h + (eac)n(h)f(individual)0 3299 y(basic)29 b(blo)r(c)n(k)h(in)g(that)h + (dominance)e(fron)n(tier)g(adding)h(to)g(the)g(IDF)h(if)g(it)f(isn't)h + (in)f(there)g(already)-7 b(.)43 b(Also,)31 b(LL)-9 b(VM)30 + b(pro)n(vides)0 3398 y(quic)n(k)c(access)f(to)h(the)g(de\034nitions)g + (of)h(op)r(erands)e(in)h(expressions,)f(so)g(determining)h(if)h(they)f + (w)n(ere)f(SSA)i Fo(\036)g Fr(no)r(des)f(or)f(not)h(is)0 + 3498 y(simple.)37 b(This)27 b(in)n(v)n(olv)n(es)f(a)h(recursiv)n(e)f + (step)i(on)f(the)h Fo(\036)g Fr(no)r(de)g(to)f(see)g(if)h(its)g(op)r + (erands)f(w)n(ere)f(de\034ned)i(b)n(y)f Fo(\036)i Fr(no)r(des)e(or)g + (not.)0 3714 y Fj(4.3.3)94 b Fh(R)-5 b(ename)0 3867 y + Fr(The)26 b(primary)e(purp)r(ose)h(of)h(the)g Fq(R)l(ename)32 + b Fr(pass)25 b(is)g(to)h(assign)e(redundancy)h(class)g(n)n(um)n(b)r + (ers)g(\(R)n(CNs\))h(to)g(eac)n(h)f(o)r(ccurrence)0 3967 + y(whic)n(h)35 b(places)g(them)h(in)n(to)f(equiv)-5 b(alence)34 + b(classes.)59 b(T)-7 b(w)n(o)34 b(o)r(ccurrences)g(with)i(equiv)-5 + b(alen)n(t)35 b(R)n(CNs)g(ha)n(v)n(e)f(the)i(same)e(v)-5 + b(alue)0 4066 y(throughout)31 b(the)g(program.)46 b(That)32 + b(is,)g(they)g(are)e(a)h Fq(r)l(e\034nement)38 b Fr(of)32 + b(the)f(o)r(ccurrence)f(sets,)i(whic)n(h)g(are)e(p)r(opulated)i(with)0 + 4166 y(lexically)20 b(iden)n(ti\034ed)h(expressions.)33 + b(F)-7 b(urthermore,)21 b(it)h(is)f(straigh)n(tforw)n(ard)c(to)k + (conclude)g(that)g(an)n(y)f(t)n(w)n(o)g(o)r(ccurrences)f(along)0 + 4266 y(a)i(con)n(trol)f(path)i(with)g(t)n(w)n(o)f(di\033eren)n(t)g(R)n + (CNs)g(will)h(ha)n(v)n(e)e(a)h(rede\034nition)h(of)f(one)g(of)h(their)f + (v)-5 b(ariables)20 b(at)i(some)f(p)r(oin)n(t)g(b)r(et)n(w)n(een)0 + 4365 y(the)29 b(o)r(ccurrences)e(on)h(that)h(path.)40 + b(The)29 b(secondary)e(purp)r(ose)h(of)g Fq(R)l(ename)35 + b Fr(is)28 b(to)h(construct)f(the)h(F)-7 b(actored)27 + b(Redundancy)0 4465 y(Graph)e(\(FR)n(G\).)i(The)f(FR)n(G)f(is)h + (de\034ned)g(as)f(a)h(collection)f(of)g(real)g(o)r(ccurrences,)g(and)g + Fm(\010)p Fr(\261)h(in)g(the)g(same)f(redundancy)g(class,)0 + 4564 y(whic)n(h)g(represen)n(t)g(the)g(no)r(des.)36 b(Up)n(w)n(ard)25 + b(edges)g(in)g(the)h(FR)n(G)g(are)e(from)h(eac)n(h)g(partially)g + (redundan)n(t)g Fm(\010)g Fr(Op)r(erand)g(or)f(Real)0 + 4664 y(Occurrence)i(to)h(their)h(represen)n(tativ)n(e)d(o)r(ccurrence.) + 125 4764 y(The)38 b(non-w)n(orklist)f(driv)n(en)h(approac)n(h)e(for)i + Fq(R)l(ename)45 b Fr(is)38 b(mo)r(deled)h(after)f(the)h(SSA)g(Renaming) + f(algorithm)g(in)g([5],)0 4863 y(mo)r(di\034ed)33 b(sligh)n(tly)f(to)g + (main)n(tain)g(a)g(stac)n(k)f(for)h(eac)n(h)g(expression)e(in)j + (addition)f(to)h(stac)n(ks)e(for)h(eac)n(h)f(v)-5 b(ariable.)50 + b(The)33 b(sole)p 0 4933 1560 4 v 92 4986 a Fg(1)127 + 5010 y Ff(Recall)26 b(that)h(t)n(w)n(o)g(expressions)g(are)g(lexically) + e(iden)n(ti\034ed)i(if)e(their)i(resp)r(ectiv)n(e)h(op)r(erands)g(are)f + (v)n(ersions)f(of)g(the)h(same)e(program)h(v)l(ariable.)0 + 5088 y(Th)n(us,)d Fe(a)235 5097 y Fd(5)286 5088 y Fc(+)16 + b Fe(b)387 5097 y Fd(4)445 5088 y Ff(is)23 b(lexically)g(iden)n + (ti\034ed)i(with)f Fe(a)1296 5097 y Fd(0)1346 5088 y + Fc(+)16 b Fe(b)1447 5097 y Fd(19)92 5144 y Fg(2)127 5167 + y Ff(This)23 b(is)g(the)i(only)e(time)g(the)i(en)n(tire)g(program)f(is) + f(visited)h(b)n(y)g(SSAPRE)92 5223 y Fg(3)127 5247 y + Ff(That)g(is,)f(the)h(In)n(v)n(erse)i(A)n(c)n(k)n(erman's)e(function) + 1929 5589 y Fr(4)p eop end + %%Page: 5 5 + TeXDict begin 5 4 bop 0 83 a Fr(purp)r(ose)30 b(of)g(ha)n(ving)f(the)i + (v)n(ersion)e(stac)n(ks)g(for)h(the)g(v)-5 b(ariables)29 + b(is)i(to)f(determine)g(whether)g(or)g(not)g(a)g(new)h(R)n(CN)f(needs)g + (to)0 183 y(b)r(e)k(assigned.)52 b(Because)32 b(p)r(erforming)g(rename) + h(this)g(w)n(a)n(y)f(requires)g(the)h(examination)f(of)i(man)n(y)e(v)n + (ersions)f(of)i(v)-5 b(ariables)0 282 y(that)31 b(ma)n(y)f(not)h(app)r + (ear)e(in)i(an)n(y)f(PRE)i(candidate)e(expression,)g(the)h(algorithm)f + (is)g(not)h(sparse.)45 b(Th)n(us,)31 b(Kennedy)f(et)h(al.)0 + 382 y(presen)n(ts)c(an)g(alternativ)n(e)f(algorithm)h(called)g(Dela)n + (y)n(ed)f(Renaming[1)o(].)125 482 y(F)-7 b(or)18 b(pure)i(redundancy)f + (class)f(assignmen)n(t,)i Fq(Delaye)l(d)k(R)l(enaming)i + Fr(uses)20 b(a)f(redundancy)g(class)f(stac)n(k)h(for)g(the)h + (expression)0 581 y(b)r(eing)k(analyzed.)34 b Fq(Delaye)l(d)28 + b(R)l(enaming)j Fr(main)n(tains)23 b(the)h(in)n(v)-5 + b(arian)n(t)23 b(that,)i(at)e(an)n(y)g(p)r(oin)n(t)h(during)g + (analysis,)f(the)h(top)g(of)g(the)0 681 y(stac)n(k)g(represen)n(ts)g + (the)i(curren)n(t)e(R)n(CN)h(and)g(the)h(represen)n(tativ)n(e)d(o)r + (ccurrence)h(no)r(de)h(for)g(the)h(expression.)34 b(Eac)n(h)25 + b(R)n(CN)h(has)0 780 y(a)i(represen)n(tativ)n(e)f(o)r(ccurrence,)h + (whic)n(h)h(means)f(that)h(w)n(e)g(can)f(safely)g(replace)g(other)g(o)r + (ccurrences)f(with)j(the)f(same)f(R)n(CN)0 880 y(and)34 + b(still)g(main)n(tain)f(the)i(original)d(program)g(seman)n(tics.)55 + b(This)34 b(is)g(due)g(to)f(the)i(prop)r(ert)n(y)d(expressed)h(ab)r(o)n + (v)n(e)g(that)h(t)n(w)n(o)0 980 y(o)r(ccurrences)26 b(of)i(the)h(same)e + (R)n(CN)i(ha)n(v)n(e)d(the)j(same)e(v)-5 b(alue.)39 b(A)28 + b(represen)n(tativ)n(e)e(o)r(ccurrence)h(is)h(alw)n(a)n(ys)e(a)h(real)h + (o)r(ccurrence)0 1079 y(or)i(a)g Fm(\010)h Fr(Occurrence,)e(and)i + Fm(\010)f Fr(Occurrences)f(alw)n(a)n(ys)g(get)h(a)g(new)h(R)n(CN)g + (\(since)f(they)h(represen)n(t)e(a)h(merge)g(of)h(expression)0 + 1179 y(computations\),)h(so)f(there)h(are)e(only)h(four)h(situations)f + (that)h(migh)n(t)f(arise)g(when)g(attempting)h(to)g(assign)e(a)h(R)n + (CN)h(to)f(an)0 1279 y(Occurrence:)101 1461 y(1.)42 b(The)27 + b(top)h(of)f(the)h(stac)n(k)f(is)g(a)g(Real)h(Occurrence)e(and)243 + 1627 y(\(a\))41 b(Our)27 b(curren)n(t)g(o)r(ccurrence)f(is)h(a)h(Real) + 238 1760 y(\(b\))42 b(Our)27 b(curren)n(t)g(o)r(ccurrence)f(is)h(a)h + Fm(\010)f Fr(Op)r(erand)101 1926 y(2.)42 b(The)27 b(top)h(of)f(the)h + (stac)n(k)f(is)g(a)g Fm(\010)h Fr(Occurrence)e(and)243 + 2092 y(\(a\))41 b(Our)27 b(curren)n(t)g(o)r(ccurrence)f(is)h(a)h(Real) + 238 2225 y(\(b\))42 b(Our)27 b(curren)n(t)g(o)r(ccurrence)f(is)h(a)h + Fm(\010)f Fr(Op)r(erand)125 2408 y Fq(Delaye)l(d)i(R)l(enaming)k + Fr(is)26 b(p)r(erformed)g(in)g(t)n(w)n(o)f(steps.)37 + b(The)26 b(\034rst,)g Fq(R)l(ename1)p Fr(,)g(pro)r(cesses)f(eac)n(h)g + (Occurrence)g(separately)-7 b(,)0 2507 y(pushing)31 b(items)h(on)n(to)e + (the)i(stac)n(k)e(when)i(they)f(are)f(assigned)g(a)h(new)h(R)n(CN,)f + (and)g(p)r(opping)g(items)h(if)g(they)f(do)g(not)h(dom-)0 + 2607 y(inate)g(the)h(curren)n(t)e(o)r(ccurrence.)49 b(If)33 + b(the)f(top)h(of)f(the)g(stac)n(k)f(is)i(a)e(Real)h(Occurrence,)g(w)n + (e)g(ha)n(v)n(e)f(the)h(curren)n(t)g(v)n(ersion)e(of)0 + 2707 y(the)35 b(v)-5 b(ariables)33 b(a)n(v)-5 b(ailable)33 + b(and)h(assigning)f(a)h(new)h(R)n(CN)f(is)g(as)g(simple)h(as)e + (comparing)g(those)h(v)n(ersions)f(to)h(the)h(curren)n(t)0 + 2806 y(o)r(ccurrence.)g(In)28 b(LL)-9 b(VM)27 b(there)g(is)g(no)g + (notion)g(of)h(v)n(ersions,)d(so)i(this)h(is)f(equiv)-5 + b(alen)n(t)27 b(to)g(p)r(erforming)f(comparisons)g(of)h(eac)n(h)0 + 2906 y(op)r(erand's)c(V)-7 b(alue)24 b(p)r(oin)n(ter.)35 + b(If)24 b(the)h(top)f(of)g(the)g(stac)n(k)f(is)h(a)f + Fm(\010)h Fr(Occurrence,)f(the)i(v)n(ersions)d(of)i(v)-5 + b(ariables)22 b(are)h(not)h(pro)n(vided.)0 3005 y(T)-7 + b(o)30 b(resolv)n(e)f(this)i(issue,)g Fq(R)l(ename1)42 + b Fr(uses)30 b(dominance)g(information)g(to)g(determine)h(whic)n(h)f(R) + n(CN)h(is)f(appropriate.)44 b(This)0 3105 y(dominance)25 + b(relation)g(is)h(that)g(if)g(all)f(v)-5 b(ariable)25 + b(de\034nitions)h(of)f(the)i(curren)n(t)d(o)r(ccurrence)h(dominate)g + (the)h Fm(\010)g Fr(Occurrence)e(at)0 3205 y(the)k(top)g(of)f(the)h + (stac)n(k,)f(then)h(the)g(v)n(ersions)d(are)i(iden)n(tical[1)o(].)125 + 3304 y(Ho)n(w)n(ev)n(er,)22 b(there)h(is)g(one)g(small)g(detail)g(o)n + (v)n(erlo)r(ok)n(ed)e(in)i Fq(R)l(ename1)p Fr(.)36 b(When)24 + b(the)f(curren)n(t)g(Occurrence)e(is)j(a)e Fm(\010)i + Fr(Op)r(erand,)0 3404 y(there)32 b(exists)g(no)g(Real)g(Occurrence)e + (whic)n(h)j(can)f(pro)n(vide)f(us)h(with)h(the)f(curren)n(t)g(v)n + (ersions)e(of)i(the)h(v)-5 b(ariables.)50 b(In)32 b(these)0 + 3504 y(cases,)j(Rename1)e(mak)n(es)g(an)g(optimistic)i(assumption)e + (and)h(assumes)f(that)h(the)g(top)g(of)g(the)h(redundancy)e(class)g + (stac)n(k)0 3603 y(pro)n(vides)24 b(its)h(v)-5 b(ariables)25 + b(v)n(ersions)e(and)i(therefore)g(is)g(giv)n(en)g(the)g(same)g(R)n(CN.) + h(This)f(assumption)g(is)g(either)g(correct)f(or)h(the)0 + 3703 y Fm(\010)30 b Fr(op)r(erand)f(will)h(ha)n(v)n(e)f(no)h(represen)n + (tativ)n(e)e(o)r(ccurrence,)h Fl(?)p Fr(.)44 b(Ha)n(ving)29 + b(no)g(represen)n(tativ)n(e)f(o)r(ccurrence)h(means)g(that)i(the)0 + 3802 y Fm(\010)26 b Fr(Op)r(erand)f(is)g(not)h(partially)f(redundan)n + (t.)35 b Fq(R)l(ename1)i Fr(k)n(eeps)25 b(trac)n(k)g(of)g(eac)n(h)g + (Real)h(Occurrence)e(that)i(is)f(de\034ned)h(b)n(y)g(a)f + Fm(\010)0 3902 y Fr(and)h(places)g(them)i(in)n(to)e(a)g(set)h(to)f(b)r + (e)h(pro)r(cessed.)36 b(This)26 b(set)h(is)g(pro)r(cessed)e(b)n(y)h + Fq(R)l(ename2)38 b Fr(whic)n(h)27 b(corrects)e(the)i(optimistic)0 + 4002 y(assumption)g(regarding)e Fm(\010)j Fr(op)r(erands)e(if)j + (necessary)-7 b(.)125 4101 y Fq(R)l(ename2)42 b Fr(pro)r(cesses)30 + b(eac)n(h)h(item)g(in)h(the)g(set)f(constructed)g(b)n(y)g + Fq(R)l(ename1)p Fr(.)48 b(Eac)n(h)31 b(of)g(these)h(Real)f(Occurrences) + e(are)0 4201 y(de\034ned)i(b)n(y)g(a)f Fm(\010)i Fr(and)e(pro)n(vides)g + (the)h(v)n(ersions)e(of)i(the)g(v)-5 b(ariables)30 b(at)h(that)g + Fm(\010)g Fr(that)g(de\034nes)g(it.)48 b Fq(R)l(ename2)42 + b Fr(\034rst)31 b(obtains)0 4301 y(the)i Fm(\010)f Fr(for)g(the)h(Real) + f(Occurrence)f(and)h(notes)g(what)h(basic)f(blo)r(c)n(k)f(it)i(resides) + f(in.)52 b(If)32 b(there)h(exists)f(a)g Fo(\036)h Fr(for)f(an)n(y)f(of) + i(the)0 4400 y(v)-5 b(ariables)28 b(of)h(that)g(Real)g(Occurrence)f(in) + h(the)h(basic)e(blo)r(c)n(k)h(of)g(its)g(de\034ning)g + Fm(\010)p Fr(,)h(w)n(e)f(m)n(ust)g(double)g(c)n(hec)n(k)f(our)h + (optimistic)0 4500 y(assumption)e(made)g(to)h(the)g Fm(\010)f + Fr(op)r(erands.)125 4599 y(F)-7 b(or)22 b(eac)n(h)g Fm(\010)h + Fr(Op)r(erand,)g(a)g(Real)g(Occurrence)e(is)i(man)n(ufactured)f(with)i + (the)f(correct)f(v)n(ersions)f(of)i(the)g(v)-5 b(ariables)22 + b(at)h(that)0 4699 y(p)r(oin)n(t.)41 b(The)29 b Fo(\036)h + Fr(for)e(the)h(v)-5 b(ariable)28 b(pro)n(vides)g(us)h(with)g(the)g(v)n + (ersion)f(to)g(use)h(when)g(man)n(ufacturing)f(this)h(real)f(o)r + (ccurrence.)0 4799 y(The)d(man)n(ufactured)f(Real)h(Occurrence)e(is)i + (compared)e(to)i(the)h(represen)n(tativ)n(e)c(o)r(ccurrence)i(for)g + (the)i Fm(\010)e Fr(Op)r(erands.)35 b(If)26 b(the)0 4898 + y(represen)n(tativ)n(e)c(o)r(ccurrence)g(is)i(a)f(Real)g(Occurrence)f + (then)j(p)r(oin)n(ters)e(are)f(compared.)35 b(If)24 b(it)g(is)g(a)f + Fm(\010)h Fr(Occurrence,)f(w)n(e)g(c)n(hec)n(k)0 4998 + y(if)28 b(all)g(the)g(de\034nitions)g(of)g(the)g(v)-5 + b(ariables)27 b(in)h(the)g(man)n(ufactured)f(o)r(ccurrence)g(dominate)g + (that)h Fm(\010)p Fr(.)38 b(If)28 b(not)g(in)g(either)g(case,)0 + 5098 y(the)j(optimistic)f(assumption)g(w)n(as)f(indeed)i(wrong)e(and)h + (the)h Fm(\010)f Fr(Op)r(erand)g(is)g(set)g(to)h Fl(?)p + Fr(.)45 b(If)30 b(the)h(R)n(CN)g(is)f(determined)g(to)0 + 5197 y(b)r(e)f(correct)d(and)j(the)f(represen)n(tativ)n(e)e(o)r + (ccurrence)h(is)h(a)g Fm(\010)p Fr(,)h(the)f(man)n(ufactured)g(o)r + (ccurrence)f(needs)h(to)g(b)r(e)h(added)f(to)g(the)0 + 5297 y(set)g(for)f(further)g(pro)r(cessing)f(in)i(order)e(to)i(ensure)e + (that)i(the)g(op)r(erands)f(of)g(that)h Fm(\010)g Fr(are)e(also)h + (correct.)1929 5589 y(5)p eop end + %%Page: 6 6 + TeXDict begin 6 5 bop 125 83 a Fr(It)28 b(is)g(imp)r(ortan)n(t)g(to)g + (note)h(that)f(the)h(pap)r(er)f(did)g(not)h(explain)f(ho)n(w)f(to)h + (create)g(this)g(man)n(ufactured)g(real)f(o)r(ccurrence,)0 + 183 y(nor)f(ho)n(w)h(its)g(def)g(edge)g(ough)n(t)f(to)h(b)r(e)g(set.)37 + b(Initially)27 b(it)h(seemed)e(as)h(simple)g(as)f(cloning)h(the)g(Real) + g(Occurrence,)e(but)j(later)0 282 y(pro)n(v)n(ed)h(to)i(b)r(e)g(more)f + (complicated)h(b)r(ecause)f(a)h(critical)f(detail)h(w)n(as)e(simply)i + (left)h(out)f(in)g(the)g(algorithm.)46 b(The)30 b(edge)h(in)0 + 382 y(the)26 b(FR)n(G)g(from)f(this)g(man)n(ufactured)g(o)r(ccurrence)f + (m)n(ust)i(not)f(b)r(e)h(an)g(exact)f(cop)n(y)-7 b(,)25 + b(but)h(should)f(b)r(e)h(to)f(the)h(represen)n(tativ)n(e)0 + 482 y(o)r(ccurrence)31 b(for)g(the)i Fm(\010)f Fr(Op)r(erand)g(b)r + (eing)g(examined.)50 b(It)33 b(is)f(critical)f(to)h(recursiv)n(ely)e(c) + n(hec)n(k)i Fm(\010)g Fr(Occurrences)e(and)i(their)0 + 581 y(op)r(erands)26 b(as)h(men)n(tioned)h(ab)r(o)n(v)n(e.)125 + 681 y(Up)r(on)i(completion,)f Fq(Delaye)l(d)k(R)l(enaming)k + Fr(will)30 b(ha)n(v)n(e)e(assigned)g(R)n(CNs,)i(and)g(created)e(FR)n + (Gs)i(for)f(eac)n(h)g(redundancy)0 780 y(class)k(of)h(the)g(v)-5 + b(ariable.)54 b(This)34 b(\034rst)g(pass)f(is)g(crucial)g(to)h(the)g + (success)f(of)h(the)g(algorithm)f(as)g(a)g(whole)h(and)g(during)f(our)0 + 880 y(implemen)n(tation)28 b(and)f(testing,)h(sev)n(eral)d(bugs)i(ha)n + (v)n(e)g(b)r(een)h(link)n(ed)f(bac)n(k)g(to)g(this)h(pass)f(due)h(to)f + (its)h(complexit)n(y)-7 b(.)0 1096 y Fj(4.3.4)94 b Fh(DownSafety)0 + 1249 y Fr(In)22 b(order)e(for)h(PRE)h(to)f(insert)g(a)h(computation)f + (it)g(m)n(ust)h(b)r(e)g(do)n(wn)f(safe)g(or)f(fully)i(an)n(ticipated)f + (at)g(the)h(p)r(oin)n(t)g(of)f(insertion[1)o(].)0 1349 + y(Do)n(wn)33 b(safet)n(y)h(is)f(used)h(to)f(ensure)g(that)h(new)g + (exceptions)f(or)g(redundancy)g(are)g(not)g(in)n(tro)r(duced)h(b)n(y)f + (inserting)g(an)h(ex-)0 1448 y(pression.)42 b(Since)30 + b(insertions)f(are)g(only)g(done)h(at)f Fm(\010)h Fr(Op)r(erands,)f(it) + i(is)e(su\036cien)n(t)h(to)g(determine)g(do)n(wn)f(safet)n(y)g(only)g + (at)h Fm(\010)0 1548 y Fr(Occurrences.)39 b(Note)29 b(that)g(it)h(is)f + (only)f(safe)h(to)f(do)h(so)f(b)r(ecause)h(w)n(e)f(require)g(critical)h + (edges)f(to)h(b)r(e)g(brok)n(en.)40 b(Do)n(wnSafet)n(y)0 + 1648 y(is)28 b(done)g(in)h(t)n(w)n(o)f(steps:)38 b(Initialization)28 + b(and)h(Propagation.)37 b(In)29 b(addition)f(to)g(determining)h(Do)n + (wnSafet)n(y)-7 b(,)28 b(this)h(pass)e(also)0 1747 y(sets)g(the)h + (hasRealUse)f(\035ags)f(for)h Fm(\010)h Fr(Op)r(erand)f(Occurrences.) + 125 1847 y(In)j(order)e(for)i(a)g Fm(\010)g Fr(Occurrence)e(to)i(not)g + (b)r(e)h(do)n(wn)e(safe,)h(there)g(m)n(ust)g(exist)g(a)g(con)n(trol)f + (\035o)n(w)g(path)h(from)g(the)g Fm(\010)g Fr(suc)n(h)0 + 1946 y(that)23 b(the)h(expression)d(is)i(either)g(not)g(computed)g + (prior)e(to)i(an)g(exit)g(or)f(is)h(not)g(computed)g(prior)f(to)g(a)h + (rede\034nition)g(of)g(one)f(of)0 2046 y(its)27 b(op)r(erands[1)n(].)36 + b(Because)26 b(Rename)g(is)g(already)f(pro)r(cessing)g(the)h + (Occurrences)f(in)h(DT)h(preorder,)e(it)i(is)f(an)g(appropriate)0 + 2146 y(place)f(to)g(p)r(erform)f(the)i(initialization.)35 + b(While)26 b(the)f(pap)r(er)g(giv)n(es)f(excellen)n(t)h(details)g(on)f + (what)h(mo)r(di\034cations)g(to)g(mak)n(e)f(to)0 2245 + y(the)32 b(non-w)n(orklist)d(driv)n(en)h(rename)h(algorithm,)g(it)g(do) + r(es)g(not)g(giv)n(e)g(an)n(y)f(information)g(on)h(ho)n(w)g(to)g(mo)r + (dify)h(the)f(dela)n(y)n(ed)0 2345 y(rename)c(pass.)36 + b(Therefore,)26 b(it)i(to)r(ok)f(a)g(signi\034can)n(t)g(amoun)n(t)g(of) + h(time)g(to)f(come)g(up)h(with)g(the)g(correct)e(approac)n(h.)125 + 2445 y(All)i(do)n(wnsafet)n(y)f(\035ags)g(are)g(initialized)h(to)g + (true,)h(whic)n(h)f(is)g(an)g(optimistic)g(assumption.)38 + b(Do)n(wn)28 b(safet)n(y)f(can)h(only)g(b)r(e)0 2544 + y(set)j(to)h(false)f(if)h(w)n(e)f(see)g(an)g(Exit)h(Occurrence)e(b)r + (efore)h(a)g(Real)g(Occurrence,)g(or)f(b)r(efore)i(a)f + Fm(\010)g Fr(Op)r(erand)g(that)g(is)h(de\034ned)0 2644 + y(b)n(y)26 b(a)g(do)n(wn)f(safe)h Fm(\010)p Fr(.)36 b(The)27 + b(pap)r(er)e(suggests)g(that)i(whenev)n(er)e(Rename)h(assigns)e(a)i + (Real)g(Occurrence)e(a)i(new)g(R)n(CN,)h(sets)e(a)0 2743 + y Fm(\010)k Fr(Op)r(erand)f(to)g Fl(?)h Fr(or)f(encoun)n(ters)f(a)i + (program)d(exit,)j(it)h(c)n(hec)n(ks)d(the)i(top)g(of)g(the)g(stac)n(k) + f(to)g(see)g(if)i(it)f(is)g(a)f Fm(\010)h Fr(Occurrence.)0 + 2843 y(If)j(so,)h(it)f(will)g(reset)f(that)h Fm(\010)p + Fr('s)g(do)n(wnsafet)n(y)e(\035ag.)49 b(This)32 b(approac)n(h)e(seems)h + (reasonable,)g(except)h(in)g(dela)n(y)n(ed)f(Renaming)0 + 2943 y(Occurrences)26 b(are)h(only)h(pushed)g(on)n(to)g(the)g(stac)n(k) + f(if)i(they)f(are)f(assigned)g(a)h(new)g(redundancy)g(class)f(n)n(um)n + (b)r(er.)38 b(Ho)n(w)n(ev)n(er,)0 3042 y(there)c(are)f(cases)g(where)h + (a)f(Real)h(Occurrence)f(is)h(giv)n(en)f(the)h(same)g(R)n(CN)g(as)g(a)f + Fm(\010)i Fr(or)e(another)g(Real)h(Occurrence)e(and)0 + 3142 y(consequen)n(tly)h(it)h(is)g(not)f(pushed)h(on)n(to)f(the)h(stac) + n(k.)55 b(If)34 b(a)f(Real)h(Occurrence)e(is)i(not)f(pushed)h(on)n(to)f + (the)h(stac)n(k)f(and)h(the)0 3242 y(next)26 b(Occurrence)e(is)i(an)f + (Exit)i(Occurrence,)d(it)j(presen)n(ts)e(a)g(problem)g(during)h(do)n + (wn)f(safet)n(y)g(initialization.)36 b(It)26 b(will)g(mark)0 + 3341 y(the)j Fm(\010)g Fr(not)g(do)n(wn)f(safe)h(b)r(ecause)f(it)i(nev) + n(er)e(witnessed)g(the)i(Real)e(Occurrence)f(at)i(the)g(top)g(of)g(the) + g(stac)n(k.)40 b(This)29 b(is)g(also)f(a)0 3441 y(problem)j(for)g + (setting)g(hasRealUse)g(\035ags,)g(where)g Fm(\010)g + Fr(Op)r(erands)g(will)g(not)h(see)f(a)g(Real)g(Occurrence)f(on)h(the)h + (top)f(of)h(the)0 3540 y(stac)n(k)27 b(and)g(their)g(hasRealUse)g + (\035ags)f(will)i(b)r(e)g(incorrectly)e(set)i(to)f(false.)125 + 3640 y(It)32 b(is)h(not)f(su\036cien)n(t)h(to)f(ha)n(v)n(e)g(only)g + (the)h(stac)n(k)e(describ)r(ed)i(in)f(Rename1)g(and)h(still)f + (initialize)h(the)g(do)n(wnsafet)n(y)e(and)0 3740 y(hasRealUse)26 + b(\035ags)h(appropriately)-7 b(.)35 b(Therefore,)26 b(w)n(e)h(k)n(eep)h + (another)e(stac)n(k)h(that)h(k)n(eeps)e(trac)n(k)h(of)g(all)h(of)f(the) + h(Occurrences)0 3839 y(that)22 b(dominate)g(the)g(curren)n(t)f + (expression)f(and)i(that)g(ha)n(v)n(e)f(b)r(een)h(pro)r(cessed.)34 + b(When)23 b(determining)e(if)i(do)n(wn)e(safet)n(y)g(should)0 + 3939 y(b)r(e)g(reset)g(or)f(hasRealUse)g(should)g(b)r(e)i(set,)g(it)g + (lo)r(oks)e(at)h(the)g(top)g(of)g(this)g(second)f(stac)n(k.)34 + b(W)-7 b(e)21 b(a)n(v)n(oid)f(the)h(problem)g(of)g(missing)0 + 4039 y(a)27 b(Real)g(Occurrence)f(that)i(w)n(as)f(not)g(assigned)g(a)g + (new)g(R)n(CN.)125 4138 y(The)e(second)f(part)g(of)h(do)n(wnsafet)n(y)f + (is)h(to)g(propagate)e(a)i(non-do)n(wn)e(safe)i(v)-5 + b(alue)25 b(to)g(an)n(y)f Fm(\010)p Fr('s)h(that)g(ha)n(v)n(e)f(op)r + (erands)g(that)0 4238 y(use)j(the)h(non-do)n(wn)f(safe)g + Fm(\010)h Fr(as)e(their)i(represen)n(tativ)n(e)e(o)r(ccurrence.)35 + b(This)27 b(is)h(a)f(simple)h(w)n(alk)e(of)i(the)g(FR)n(G.)0 + 4454 y Fj(4.3.5)94 b Fh(Wil)5 b(lBeA)n(vail)0 4607 y + Fr(The)26 b Fq(Wil)t(lBeA)n(vail)37 b Fr(step)25 b(tells)h(us)g(if)g(a) + f(v)-5 b(alue)26 b(will)g(b)r(e)g(a)n(v)-5 b(ailable)24 + b(at)i(a)f Fm(\010)h Fr(o)r(ccurrence)e(follo)n(wing)g(insertions.)36 + b(If)26 b(the)g Fm(\010)g Fr(has)0 4706 y(its)k Fq(wil)t(l_b)l(e_avail) + 41 b Fr(predicate)29 b(set)g(but)h(a)g(v)-5 b(alue)29 + b(isn't)h(a)n(v)-5 b(ailable)29 b(there,)h(later)f(steps)g(will)h + (insert)f(an)h(o)r(ccurrence)e(of)i(the)0 4806 y(expression)25 + b(at)i(this)g(p)r(oin)n(t.)37 b(This,)27 b(com)n(bined)f(with)i(the)f + Fq(DownSafety)35 b Fr(step,)27 b(giv)n(es)f(us)g(the)i(optimal)e + (placemen)n(t)h(for)f(new)0 4906 y(expressions)g(in)i(the)g(\034nal)f + (CF)n(G.)125 5005 y(The)c(algorithm)f(starts)g(where)h + Fq(DownSafety)31 b Fr(ends.)36 b(It)23 b(calculates)g(if)g(a)g(v)-5 + b(alue)23 b(can)g(b)r(e)h(a)n(v)-5 b(ailable)22 b(at)h(a)g + Fm(\010)g Fr(and)g(whether)0 5105 y(or)35 b(not)h(it)g(can)g(b)r(e)g + (placed)g(\020later\021)41 b(in)c(the)f(CF)n(G.)g(The)g(algorithm)f + (recursiv)n(ely)f(visits)i(eac)n(h)f Fm(\010)h Fr(no)r(de)g(either)f + (clearing)0 5205 y(or)e(setting)i(the)g Fq(c)l(an_b)l(e_avail)44 + b Fr(and)34 b Fq(later)44 b Fr(\035ags.)56 b(The)34 b + Fq(wil)t(l_b)l(e_avail)46 b Fr(predicate)34 b(is)g(determined)g(b)n(y)g + (the)h(follo)n(wing)0 5304 y(equation:)1929 5589 y(6)p + eop end + %%Page: 7 7 + TeXDict begin 7 6 bop 1178 183 a Fo(w)r(il)r(l)r Fr(_)o + Fo(be)p Fr(_)o Fo(av)s(ail)24 b Fm(=)e Fo(can)p Fr(_)o + Fo(be)p Fr(_)o Fo(av)s(ail)47 b Fl(^)g(:)p Fo(l)r(ater)0 + 394 y Fj(4.3.6)94 b Fh(Finalize)0 547 y Fq(Finalize)30 + b Fr(is)21 b(resp)r(onsible)g(for)g(transforming)f(the)j(FR)n(G)f(in)n + (to)f(a)g(new)h(form)f(that)h(re\035ects)g(insertions)e(and)i(no)f + Fm(\010)h Fr(Op)r(erand)f(is)0 647 y Fl(?)p Fr(.)35 b(In)23 + b(addition)g(this)h(new)f(form)g(is)g(optimized)h(b)n(y)e(remo)n(ving)g + (an)n(y)g(extraneous)g Fm(\010)h Fr(Occurrences.)34 b(The)23 + b(pass)f(is)h(separated)0 746 y(in)n(to)k(t)n(w)n(o)g(parts:)36 + b Fq(Finalize1)41 b Fr(and)27 b Fq(Finalize2)p Fr(.)125 + 846 y Fq(Finalize1)37 b Fr(is)25 b(resp)r(onsible)f(for)g(determining)g + (whic)n(h)h(Real)f(Occurrences)f(should)h(b)r(e)h(reloaded)e(from)h(a)h + (temp)r(orary)e(or)0 945 y(computed.)37 b(It)27 b(uses)f(a)g(STL)h(map) + f(to)h(asso)r(ciate)e(redundancy)h(class)f(n)n(um)n(b)r(ers)h(to)h + (their)g(a)n(v)-5 b(ailable)25 b(de\034ning)h(o)r(ccurrence.)0 + 1045 y(Eac)n(h)g(Occurrence)f(is)h(pro)r(cessed)f(in)h(a)g(preorder)f + (dominator)g(tree)h(tra)n(v)n(ersal.)33 b(Up)r(on)27 + b(encoun)n(tering)e(a)h(Real)g(Occurrence)0 1145 y(the)36 + b(map)f(for)g(an)g(a)n(v)-5 b(ailable)34 b(de\034nition)h(is)h + (accessed)e(for)g(its)i(R)n(CN.)f(If)h(no)f(de\034nition)h(exists,)h + (or)d(the)i(de\034nition)f(do)r(es)0 1244 y(not)d(dominate)g(the)h + (Real)f(Occurrence,)g(it)g(will)h(b)r(ecome)f(its)g(R)n(CN's)h + (de\034ning)f(o)r(ccurrence)f(and)h(reset)f(its)i(reload)e(\035ag.)0 + 1344 y(Otherwise,)c(the)g(Real)g(Occurrence)f(will)i(set)f(its)g + (reload)f(\035ag)h(to)g(true)h(and)f(up)r(date)g(the)h(FR)n(G)g(b)n(y)f + (c)n(hanging)f(its)h(up)n(w)n(ard)0 1444 y(edge)e(to)g(p)r(oin)n(t)h + (to)f(the)g(a)n(v)-5 b(ailable)24 b(de\034nition.)37 + b(When)26 b Fq(Finalize1)38 b Fr(pro)r(cesses)24 b(a)h + Fm(\010)g Fr(Occurrence,)g(it)g(will)h(only)f(mak)n(e)f(this)i + Fm(\010)0 1543 y Fr(the)i(a)n(v)-5 b(ailable)26 b(de\034nition)i(for)f + (its)h(R)n(CN)g(if)g(it)g(satis\034es)e Fq(wil)t(l_b)l(e_avail)p + Fr(.)125 1643 y(Lastly)-7 b(,)26 b(when)g(pro)r(cessing)f + Fm(\010)h Fr(Op)r(erands)f Fq(Finalize1)39 b Fr(m)n(ust)27 + b(decide)f(whether)g(it)h(is)f(p)r(ossible)g(to)g(insert)g(an)g + (expression)0 1742 y(and)k(c)n(hange)f(its)i(represen)n(tativ)n(e)d(o)r + (ccurrence)h(to)i(the)f(Inserted)g(Occurrence.)44 b(In)31 + b(order)e(to)h(insert)g(an)g(expression,)g(t)n(w)n(o)0 + 1842 y(conditions)d(m)n(ust)h(hold[1)o(]:)101 1986 y(1.)42 + b(The)27 b Fm(\010)h Fr(that)g(it)g(b)r(elongs)f(to)g(m)n(ust)h + (satisfy)f Fq(wil)t(l_b)l(e_avail)101 2142 y Fr(2.)42 + b(The)31 b Fm(\010)g Fr(Op)r(erand)g(m)n(ust)g(b)r(e)h + Fl(?)p Fr(;)h(or)d(hasRealUse)g(\035ag)h(is)g(false)g(and)g(its)g + (represen)n(tativ)n(e)f(o)r(ccurrence)f(is)j(a)e Fm(\010)i + Fr(that)208 2241 y(do)r(es)27 b(not)g(satisfy)g Fq(wil)t(l_b)l(e_avail) + 125 2385 y Fr(If)34 b Fq(insert)41 b Fr(is)34 b(satis\034ed,)h(the)f + (curren)n(t)f(expression)f(at)h(the)h(place)g(the)g Fm(\010)g + Fr(Op)r(erand)f(o)r(ccurs)f(in)i(the)g(CF)n(G)g(should)g(b)r(e)0 + 2485 y(inserted.)k(While)29 b(this)f(step)h(seems)e(v)n(ery)g(straigh)n + (t-forw)n(ard,)e(no)j(details)g(are)f(pro)n(vided)g(in)i(the)f(pap)r + (er)g(ab)r(out)g(obtaining)0 2585 y(the)34 b(correct)d(expression)h(to) + h(insert.)54 b(Due)34 b(to)f(the)g(fact)h(that)f(w)n(e)g(implemen)n + (ted)h(the)f(w)n(orklist)f(driv)n(en)h(approac)n(h,)g(it)g(is)0 + 2684 y(ine\036cien)n(t)g(to)f(pass)f(o)n(v)n(er)g(the)i(program)d(to)i + (\034nd)h(the)g(correct)e(v)n(ersions)f(of)i(the)h(v)-5 + b(ariables)31 b(to)h(form)n(ulate)g(this)g(inserted)0 + 2784 y(expression.)h(Rather,)23 b(the)f(prop)r(er)f(place)h(to)g(p)r + (erform)f(this)h(analysis)f(is)h(in)g(the)g(Rename)g(pass.)34 + b(This)22 b(is)g(a)g(mo)r(di\034cation)f(to)0 2884 y(the)k(Rename)g + (algorithm)e(not)i(men)n(tioned)g(in)g(the)g(pap)r(er.)36 + b(When)25 b(pro)r(cessing)e(the)i Fm(\010)g Fr(Op)r(erand)f + (Occurrences,)g(Rename2)0 2983 y(is)k(a)n(w)n(are)d(of)j(the)g(curren)n + (t)f(v)n(ersions)f(of)h(v)-5 b(ariables)27 b(at)g(that)h(p)r(oin)n(t)g + (in)g(the)g(program.)35 b(It)28 b(is)g(trivial)f(to)h(create)e(the)i + (inserted)0 3083 y(instruction)h(at)g(that)h(p)r(oin)n(t,)f(in)h(the)g + (ev)n(en)n(t)e(that)i(it)f(is)h(needed)f(b)n(y)g Fq(Finalize)37 + b Fr(in)29 b(the)h(future.)42 b(It)30 b(is)f(a)g(signi\034can)n(tly)f + (more)0 3182 y(e\036cien)n(t)d(to)f(ha)n(v)n(e)f(this)i(inserted)f + (instruction)h(cac)n(hed,)f(v)n(ersus)f(obtaining)h(it)h(during)f(the)h + Fq(Finalize)32 b Fr(pass.)j(If)25 b(insert)g(is)f(not)0 + 3282 y(satis\034ed,)j(the)h Fm(\010)g Fr(Op)r(erand)e(will)i(up)r(date) + g(its)g(represen)n(tativ)n(e)e(o)r(ccurrence)g(to)h(p)r(oin)n(t)h(to)f + (the)h(a)n(v)-5 b(ailable)26 b(de\034nition.)125 3382 + y Fq(Finalize2)47 b Fr(marks)34 b(eac)n(h)g(Real)g(Occurrence)f(that)i + (is)g(not)f(reloaded)g(as)g(sa)n(v)n(ed,)h(and)f(remo)n(v)n(es)f + (extraneous)g Fm(\010)i Fr('s)f(to)0 3481 y(minimize)27 + b(the)h(FR)n(G.)f(While)g(not)g(crucial)f(to)h(the)g(success)f(of)h + (PRE,)h(lea)n(ving)e(extraneous)f Fm(\010)i Fr('s)g(requires)f(more)g + (space)g(in)0 3581 y(program)h(represen)n(tation)h(and)h(ma)n(y)g + (impact)g(the)h(e\036ciency)f(of)g(future)h(optimizations[1)o(].)42 + b(Ho)n(w)n(ev)n(er,)28 b(remo)n(ving)g(these)0 3681 y(extraneous)d + Fm(\010)j Fr('s)f(requires)e(that)i(the)h(o)r(ccurrences)d(in)j(its)f + (R)n(CN)g(refer)f(to)h(a)g(di\033eren)n(t)g(class)f(whic)n(h)h + (de\034nes)g(the)g(v)-5 b(alue)27 b(of)0 3780 y(the)h + Fm(\010)g Fr(Occurrence.)125 3880 y Fq(Finalize2)38 b + Fr(b)r(egins)24 b(b)n(y)h(setting)f(eac)n(h)g Fm(\010)h + Fr(in)g(the)g(FR)n(G)g(that)g(satis\034es)f Fq(wil)t(l_b)l(e_avail)36 + b Fr(to)25 b(b)r(e)g(extraneous.)34 b(Recall)25 b(that)0 + 3979 y(the)31 b Fq(save)37 b Fr(\035ags)29 b(for)g(Real)h(Occurrences)f + (w)n(ere)g(initialized)h(to)g(false.)44 b Fq(Finalize2)g + Fr(then)30 b(lo)r(oks)g(at)g(eac)n(h)f(Real)h(Occurrence)0 + 4079 y(that)i(has)f(its)h Fq(r)l(elo)l(ad)42 b Fr(\035ag)31 + b(set.)49 b(If)32 b(it)g(is)g(to)g(b)r(e)g(reloaded,)f(it)h(m)n(ust)g + (up)r(date)g(its)g(represen)n(tativ)n(e)e(o)r(ccurrence)g(b)n(y)i + (calling)0 4179 y(Set_sa)n(v)n(e\(\).)j(Set_sa)n(v)n(e\(\))25 + b(lo)r(oks)h(at)g(the)h(represen)n(tativ)n(e)d(o)r(ccurrence,)h(and)h + (if)h(it)g(is)f(a)g(a)g(Real)g(Occurrence)e(the)j(sa)n(v)n(e)e(\035ag)0 + 4278 y(for)34 b(that)g(Real)g(is)g(set)g(to)g(true.)57 + b(Otherwise,)35 b(if)g(it)f(is)h(a)e Fm(\010)i Fr(Occurrence)d(it)j + (will)f(recursiv)n(ely)f(call)g(Set_sa)n(v)n(e\(\))g(in)i(eac)n(h)0 + 4378 y(of)30 b(its)g Fm(\010)g Fr(Op)r(erand)g(Occurrences.)42 + b(Lastly)-7 b(,)30 b(if)h(the)g(represen)n(tativ)n(e)d(o)r(ccurrence)g + (is)i(a)g(Real)g(or)f(Inserted)h(Occurrence,)f(it)0 4478 + y(will)f(declare)f(eac)n(h)g Fm(\010)h Fr(in)g(its)g(iterated)f + (dominance)h(fron)n(tier)f(to)g(b)r(e)i(extraneous.)36 + b Fq(Finalize2)41 b Fr(then)28 b(needs)g(to)g(remo)n(v)n(e)e(the)0 + 4577 y(extraneous)g Fm(\010)i Fr('s)f(and)g(up)r(date)h(the)g(FR)n(G)g + (accordingly)-7 b(.)125 4677 y(The)21 b(algorithm)g(for)g + Fq(Finalize2)35 b Fr(did)22 b(not)f(w)n(ork)f(according)g(to)i(the)g + (pap)r(er.)34 b(When)22 b(remo)n(ving)e(extraneous)g + Fm(\010)i Fr('s)f(in\034nite)0 4776 y(lo)r(ops)26 b(w)n(ere)f(o)r + (ccurring.)35 b(This)26 b(w)n(as)f(due)i(to)f(the)h(pap)r(er)e(lea)n + (ving)g(out)i(the)f(detail)h(that)f(once)g(a)g Fm(\010)g + Fr(has)g(b)r(een)h(remo)n(v)n(ed)d(and)0 4876 y(its)k(FR)n(G)g(up)r + (dated,)g(it)g(should)f(not)h(b)r(e)f(pro)r(cessed)g(again.)0 + 5087 y Fj(4.3.7)94 b Fh(Co)-5 b(deMotion)0 5240 y Fr(An)24 + b(algorithm)e(for)h Fq(Co)l(deMotion)32 b Fr(w)n(asn't)23 + b(giv)n(en)g(explicitly)g(in)h(the)g(pap)r(er.)35 b(W)-7 + b(e)23 b(came)g(up)h(with)g(the)g(follo)n(wing)e(algorithm)0 + 5340 y(based)27 b(on)g(the)h(description)f(giv)n(en)g(in)h([1)o(].)1929 + 5589 y(7)p eop end + %%Page: 8 8 + TeXDict begin 8 7 bop 0 183 a Fk(for)42 b(f)h Fl(2)h + Fk(F)g(in)e(preorder)e(traversal)g(of)j(the)f(Dominator)e(Tree)i(do)131 + 282 y(if)g(f)i(is)e(a)h(real)f(occurrence)261 382 y(if)h(save\(f\))392 + 482 y(generate_save\(f\))261 581 y(else)f(if)h(reload\(f\))392 + 681 y(generate_reload\()o(f\))131 780 y(else)f(if)g(f)h(is)g(a)g + Fm(\010)261 880 y Fk(generate_ssa_phi\()o(f\))131 980 + y(else)f(if)g(f)h(is)g(a)g Fm(\010)h Fk(operand)261 1079 + y(generate_reload\(f)o(\))131 1179 y(else)e(if)g(f)h(is)g(an)g + (inserted)d(occurrence)261 1279 y(generate_save\(f\))0 + 1378 y(end)125 1561 y Fr(After)c(the)h Fq(Finalize)45 + b Fr(phase)36 b(is)g(\034nished,)j(w)n(e)d(ha)n(v)n(e)g(a)g(set)g(with) + h(Real)g(Occurrences,)g Fm(\010)f Fr(no)r(des,)j Fm(\010)d + Fr(op)r(erand,)i(and)0 1660 y(Inserted)27 b(Occurrences.)125 + 1760 y(F)-7 b(or)25 b(Real)g(Occurrences,)f(if)j(they)e(are)g(to)h(b)r + (e)g(\020sa)n(v)n(ed,\021)31 b(w)n(e)25 b(generate)g(a)g(sa)n(v)n(e)f + (of)i(that)g(expression)e(to)i(a)f(temp)r(orary)-7 b(.)35 + b(In)0 1860 y(LL)-9 b(VM,)20 b(this)h(in)n(v)n(olv)n(es)d(creating)i(a) + f Fk(cast)42 b Fr(of)21 b(the)f(Real)g(Occurrence's)f(instruction)h + (and)g(placing)g(it)g(in)h(the)g(CF)n(G)f(after)g(that)0 + 1959 y(instruction.)48 b(This)31 b(will)g(act)g(as)g(this)g + (instruction's)g(\020curren)n(t)f(temp)r(orary)g(v)n(ersion.\021)53 + b(If)31 b(the)h(Real)f(Occurrence)e(should)0 2059 y(b)r(e)g + (\020reloaded,\021)34 b(then)c(w)n(e)e(generate)g(a)g(reload)g(of)h + (the)g(instruction.)41 b(This)28 b(is)h(done)g(b)n(y)f(simply)h(taking) + f(the)i(o)r(ccurrence's)0 2159 y(de\034ning)e(instruction's)f(curren)n + (t)f(temp)r(orary)h(v)n(ersion)f(and)h(replacing)f(the)i(instruction)f + (with)i(that)e(curren)n(t)g(temp)r(orary)-7 b(.)125 2258 + y(F)g(or)26 b Fm(\010)h Fr(no)r(des,)g(w)n(e)f(notice)h(that)h(these)f + (are)f(the)h(places)f(where)h(t)n(w)n(o)f(or)g(more)g(expressions)f + (are)h(merged)g(in)i(the)f(CF)n(G.)0 2358 y(The)32 b(expressions)d + (coming)i(in)h(are)e(in)i(registers)e(\()p Fk(Value*)p + Fr(s)f(in)j(LL)-9 b(VM\).)31 b(W)-7 b(e)32 b(create)f(an)g(SSA)h + Fo(\036)g Fr(no)r(de)g(to)f(p)r(erform)g(this)0 2457 + y(merging.)125 2557 y(F)-7 b(or)29 b Fm(\010)h Fr(op)r(erands,)g(w)n(e) + f(w)n(an)n(t)h(to)g(reload)e(the)j(temp)r(orary)e(v)-5 + b(alue)30 b(of)g(its)g(de\034ning)g(instruction.)44 b(In)30 + b(our)f(implemen)n(ta-)0 2657 y(tion,)h(this)f(do)r(esn't)h(require)e + (an)n(y)g(mo)r(di\034cations)h(since)g(w)n(e)g(will)h(use)f(the)g + Fm(\010)h Fr(op)r(erand's)e(de\034ning)h(instruction's)g(curren)n(t)0 + 2756 y(temp)r(orary)d(instead)i(of)f(doing)g(an)g(actual)g(insertion)g + (of)h(co)r(de)f(at)h(this)f(p)r(oin)n(t.)125 2856 y(F)-7 + b(or)30 b(Inserted)g(Occurrences,)g(w)n(e)g(need)h(to)g(generate)e(a)h + (sa)n(v)n(e)g(of)g(the)i(instruction)e(in)n(to)h(a)f(temp)r(orary)f(v) + -5 b(ariable.)46 b(W)-7 b(e)0 2956 y(treat)27 b(this)h(in)g(same)f(w)n + (a)n(y)f(w)n(e)h(treat)g(a)h(Real)f(Occurrence)f(that)i(is)f(to)g(b)r + (e)h(sa)n(v)n(ed.)0 3188 y Fp(4.4)112 b(Limitations)35 + b(&)i(W)-9 b(eaknesses)0 3341 y Fr(After)30 b(m)n(uc)n(h)f(discussion,) + g(it)h(w)n(as)f(determined)h(that)f(the)h(SSAPRE)h(algorithm)e(should)g + (only)g(need)h(to)f(b)r(e)h(run)f(once)g(on)0 3441 y(the)k(co)r(de)f + (to)g(gain)g(the)g(full)h(b)r(ene\034ts)g(of)f(PRE.)i(Ho)n(w)n(ev)n + (er,)e(it)g(requires)f(that)i(the)g(o)r(ccurrence)d(sets)j(that)f(are)f + (collected)0 3540 y(for)d(eac)n(h)f(expression)g(t)n(yp)r(e)i(b)r(e)f + (top)r(ographically)f(sorted)g(and)h(run)g(in)h(order.)38 + b(That)28 b(is,)g(if)h(an)f(expression)f(in)i(set)f Fo(A)h + Fr(uses)0 3640 y(the)35 b(result)f(of)g(an)g(expression)f(in)h(set)h + Fo(B)t Fr(,)h(then)f(set)f Fo(B)39 b Fr(should)34 b(b)r(e)h(run)f + (through)f(the)i(algorithm)e(b)r(efore)h(set)g Fo(A)p + Fr(.)58 b(Our)0 3740 y(implemen)n(tation)28 b(do)r(esn't)f(k)n(eep)g + (this)h(top)r(ographical)e(ordering.)125 3839 y(Our)35 + b(algorithm)f(curren)n(tly)h(do)r(es)h(not)g(use)g(the)g(v)-5 + b(alue)36 b(n)n(um)n(b)r(ering)f(in)n(terface)g(to)h(\034nd)g + (expressions)e(that)j(pro)r(duce)0 3939 y(the)32 b(same)g(v)-5 + b(alue,)33 b(but)f(are)f(not)h(lexically)f(equiv)-5 b(alen)n(t.)50 + b(As)32 b(a)f(side)h(e\033ect)g(of)g(this,)h(w)n(e)f(are)f(unable)h(to) + g(tak)n(e)f(adv)-5 b(an)n(tage)0 4039 y(of)34 b(the)g + Fk(load-vn)d Fr(v)-5 b(alue)34 b(n)n(um)n(b)r(ering)f(pass,)i(whic)n(h) + f(w)n(ould)f(allo)n(w)g(our)g(algorithm)g(to)g(transparen)n(tly)f + (handle)i(partially)0 4138 y(redundan)n(t)26 b(loads)g(disam)n + (biguated)g(b)n(y)h(a)g(user-selectable)e(alias)h(analysis)f(implemen)n + (tation.)37 b(W)-7 b(e)27 b(consider)f(this)h(to)g(b)r(e)g(a)0 + 4238 y(straigh)n(t-forw)n(ard)h(extension)j(of)g(our)g(curren)n(t)f + (implemen)n(tation,)i(whic)n(h)f(will)h(b)r(e)g(easy)e(to)h(implemen)n + (t)h(once)f(the)h(other)0 4337 y(de\034ciencies)27 b(of)h(the)g + (underlying)f(algorithm)f(are)h(\034xed.)125 4437 y(Running)f(our)g + (pass)f(on)h(co)r(de)g(t)n(wice)g(results)g(in)g(co)r(de)h(whic)n(h)f + (is)g(no)g(longer)f(correct;)g(unfortunately)-7 b(,)27 + b(this)f(fact)h(seems)0 4537 y(to)g(b)r(e)h(from)g(a)f(laten)n(t)g(bug) + h(whic)n(h)f(w)n(ould)g(require)g(more)f(time)i(to)g(\034nd)g(than)g(w) + n(e)f(had.)0 4769 y Fp(4.5)112 b(Status)0 4922 y Fr(The)38 + b(implemen)n(tation)f(of)h(SSAPRE)h(is)e(almost)g(complete.)67 + b(A)n(t)38 b(the)g(time)g(of)g(this)f(rep)r(ort,)j(our)d(implemen)n + (tation)g(is)0 5022 y(successfully)24 b(remo)n(ving)g(partial)f + (redundancies)h(prop)r(erly)g(from)h(a)f(go)r(o)r(d)g(deal)h(of)g + (input)g(co)r(des,)g(although)f(there)h(are)f(still)0 + 5122 y(some)f(bugs)g(presen)n(t)g(whic)n(h)g(w)n(e)h(did)g(not)f(ha)n + (v)n(e)g(time)h(to)f(\034x.)36 b(In)23 b(particular,)g(w)n(e)h(ran)e + (in)n(to)i(some)f(falsi\034abilit)n(y)g(issues)g(with)0 + 5221 y(our)d(input)h(co)r(des,)h(in)f(the)g(sense)f(that)g(it)h(w)n(as) + f(di\036cult)h(to)g(ascertain)e(whether)h(or)g(not)h(the)g + Fo(\036)p Fr(-op)r(erand)f(deadness)f(in)n(v)-5 b(arian)n(t)0 + 5321 y(had)32 b(b)r(een)h(main)n(tained)f(b)n(y)h(preoptimization)e + (passes.)51 b(As)33 b(w)n(e)f(see)g(it,)i(there)f(are)e(four)h(primary) + g(actions)g(whic)n(h)g(m)n(ust)1929 5589 y(8)p eop end + %%Page: 9 9 + TeXDict begin 9 8 bop 0 83 a Fr(o)r(ccur)23 b(b)r(efore)g(our)f + (implemen)n(tation)i(is)f(robust)g(enough)g(to)g(b)r(e)h(fully)g(in)n + (tegrated)e(in)n(to)h(LL)-9 b(VM)24 b(as)e(a)h(drop-in)g(replacemen)n + (t)0 183 y(for)k(GCSE)h(and)g(LICM:)125 365 y Fl(\017)41 + b Fr(More)26 b(testing)i(to)f(exp)r(ose)g(laten)n(t)h(bugs)f(and)g + (\034x)h(the)g(existing)f(ones.)125 531 y Fl(\017)41 + b Fr(A)d(solution)g(to)g(the)h Fo(\036)p Fr(-op)r(erand)e(deadness)h + (in)n(v)-5 b(arian)n(t)37 b(that)i(is)f(compile-time)g(e\036cien)n(t)g + (and)g(correct.)68 b(This)38 b(is)208 631 y(primarily)32 + b(to)h(relax)f(the)i(stringen)n(t)f(requiremen)n(ts)f(imp)r(osed)h(b)n + (y)g(the)h(pro)n(vided)e(SSAPRE)j(algorithm)d([1].)54 + b(The)208 731 y(authors)26 b(of)i([1)o(])g(do)f(discuss)g(the)h(p)r + (ossibilit)n(y)f(of)h(relaxing)e(this)i(criteria,)e(but)i(do)g(not)f + (go)g(in)n(to)g(detail.)125 897 y Fl(\017)41 b Fr(Determine)21 + b(ho)n(w)g(v)-5 b(alue)21 b(n)n(um)n(b)r(ering)g(information)g + (\(particularly)f(for)h(load)g(instructions\))g(can)g(b)r(e)h(used)f + (to)g(increase)208 996 y(the)28 b(e\036cacy)e(of)i(PRE.)125 + 1162 y Fl(\017)41 b Fr(Implemen)n(t)36 b(a)f(top)r(ologically-ordered)e + (expression)h(visitation)h(mec)n(hanism)h(so)f(that)h(our)f(implemen)n + (tation)h(SS-)208 1262 y(APRE)29 b(can)e(b)r(e)h(more)e(aggressiv)n(e)f + (in)j(disco)n(v)n(ering)d(redundancies)i(in)h(the)f(input)i(co)r(de.)0 + 1536 y Fs(5)131 b(Issues)44 b(with)g(P)l(ap)t(er)0 1718 + y Fr(While)25 b(the)g(algorithm)f(presen)n(ted)g(in)h(this)g(pap)r(er)g + (tak)n(es)e(adv)-5 b(an)n(tage)24 b(of)g(the)i(sparseness)c(of)j(SSA)h + (and)e(can)h(p)r(erform)f(com-)0 1818 y(parable)e(to)g(LICM)h(and)f + (GCSE,)i(it)f(unfortunately)g(has)f(a)g(few)h(dra)n(wbac)n(ks.)33 + b(The)23 b(biggest)f(dra)n(wbac)n(k)e(is)j(the)g(requiremen)n(t)0 + 1918 y(that)29 b(liv)n(e)f(ranges)e(of)j(SSA)f(v)n(ersions)f(of)h(the)h + (same)f(v)-5 b(ariable)27 b(can)h(not)g(o)n(v)n(erlap.)37 + b(While)29 b(this)g(is)f(holds)g(true)g(immediately)0 + 2017 y(after)k(SSA)i(construction,)f(it)g(is)f(not)h(guaran)n(teed)e + (to)i(hold)f(true)h(after)f(sev)n(eral)f(optimizations)h(ha)n(v)n(e)g + (b)r(een)h(p)r(erformed)0 2117 y(on)f(a)f(giv)n(en)g(program.)48 + b(T)-7 b(o)32 b(assume)f(that)h(PRE)h(is)f(to)g(op)r(erate)f(in)h(a)g + (v)-5 b(acuum)32 b(isn't)g(v)-5 b(alid.)50 b(Most)32 + b(lik)n(ely)f(it)i(will)f(o)r(ccur)0 2216 y(near)25 b(the)h(end)g(of)f + (a)h(long)f(list)h(of)f(optimizations.)36 b(Therefore,)25 + b(it)h(is)g(our)e(b)r(elief)j(that)f(further)f(researc)n(h)f(is)i + (needed)f(on)h(this)0 2316 y(algorithm)g(to)i(a)n(v)n(oid)e(this)i + (requiremen)n(t.)125 2416 y(The)d(ma)5 b(jorit)n(y)24 + b(of)h(the)h(phases)e(of)i(the)f(SSAPRE)i(algorithm)d(w)n(ere)h(presen) + n(ted)f(in)i(a)f(fairly)f(straigh)n(tforw)n(ard)f(manner.)0 + 2515 y(Ho)n(w)n(ev)n(er,)34 b(there)g(w)n(ere)f(signi\034can)n(t,)i + (crucial)f(gaps)f(left)i(for)f(the)g(reader)f(to)h(infer)g(and)g(some)g + (implemen)n(tation)g(details)0 2615 y(missing)d(from)g(the)h + (algorithms)e(presen)n(ted)h(in)h(the)g(\034gures)f(but)h(stated)f(in)h + (a)f(few)h(lines)g(in)g(the)f(text.)50 b(In)31 b(particular)g(it)0 + 2715 y(seems)d(as)g(though)g(the)h(W)-7 b(orklist)28 + b(driv)n(en)f(section)h(w)n(as)g(not)g(detailed.)40 b(The)28 + b(status)g(of)h(particular)e(phases)g(with)i(resp)r(ect)0 + 2814 y(to)e(ho)n(w)g(useful)h(the)g(pap)r(er)f(w)n(as)g(is)g(as)g + (follo)n(ws:)125 2997 y Fl(\017)41 b Fr(Collect)27 b(Occurrences)e + (\026)j(No)g(algorithm)e(or)h(details)g(on)g(ho)n(w)g(to)h(do)f(this.) + 125 3163 y Fl(\017)41 b Fr(Rename)26 b(\026)h(No)g(details)f(on)h(what) + f(it)i(really)d(means)i(to)f(cop)n(y)g(a)h(real)f(o)r(ccurrence)f(\(in) + i(particular,)f(ho)n(w)g(to)h(set)g(the)208 3262 y(def)h(edge)f(prop)r + (erly)f(for)h(man)n(ufactured)g(real)g(o)r(ccurrences\).)125 + 3429 y Fl(\017)41 b Fr(Do)n(wn)27 b(Safet)n(y)g(\026)h(No)f(details)h + (on)f(ho)n(w)g(to)g(do)h(initialization)f(in)h(the)f(dela)n(y)n(ed)g + (renaming)f(algorithm)125 3595 y Fl(\017)41 b Fr(Finalize)26 + b(\026)g(W)-7 b(e)27 b(witness)f(an)g(in\034nite)h(lo)r(op)f(in)h + (set_replacemen)n(t)e(for)h(the)g(implemen)n(tation)h(giv)n(en)e(in)i + (the)g(pap)r(er.)208 3694 y(W)-7 b(e)30 b(ha)n(v)n(e)f(\034xed)i(the)f + (problem)g(and)g(b)r(eliev)n(e)g(that)h(w)n(e)f(are)f(correct,)g(but)i + (there)f(is)g(a)g(bit)h(of)f(uncertain)n(t)n(y)g(presen)n(t.)208 + 3794 y(F)-7 b(urthermore,)25 b(no)h(information)f(is)i(pro)n(vided)e + (regarding)f(the)i(con)n(ten)n(ts)g(of)g(the)h(inserted)f(o)r + (ccurrences.)35 b(In)26 b(partic-)208 3893 y(ular,)j(the)g(algorithm)f + (do)r(es)h(not)g(explicitly)h(state)f(ho)n(w)g(to)g(construct)f(the)i + (o)r(ccurrence)e(to)h(insert)g(at)g(a)g Fm(\010)p Fr(op)r(erand)208 + 3993 y(when)e(insert)h(is)f(satis\034ed.)0 4268 y Fs(6)131 + b(Exp)t(erimen)l(tal)45 b(Results)0 4449 y Fr(T)-7 b(able)23 + b(1)f(sho)n(ws)g(ho)n(w)g(SSAPRE)j(p)r(erforms)d(on)h(some)f(of)h(the)g + (b)r(enc)n(hmarks)f(that)i(w)n(ork)d(under)i(the)g(LL)-9 + b(VM)23 b(infrastructure.)0 4549 y(Due)30 b(to)g(some)f(problems)f + (with)j(the)f(Sparc)e(bac)n(k-end,)h(w)n(e)h(used)f(the)h + Fk(lli)43 b Fr(command)29 b(line)h(utilit)n(y)g(to)f(in)n(terpret)g(LL) + -9 b(VM)0 4649 y(b)n(yteco)r(de)28 b(and)h(coun)n(t)g(the)g(n)n(um)n(b) + r(er)g(of)f(dynamic)h(instructions.)40 b(In)29 b(almost)g(all)f(cases,) + g(w)n(e)h(see)f(a)h(mark)n(ed)e(reduction)i(in)0 4748 + y(the)h(n)n(um)n(b)r(er)g(of)g(dynamic)g(instructions)f(generated,)h + (whic)n(h)g(corresp)r(onds)e(directly)h(to)h(the)h(elimination)f(of)g + (redundan)n(t)0 4848 y(computations.)125 4948 y(The)f(\020Ra)n(w\021)35 + b(con\034g)29 b(denotes)h(application)e(of)i(PRE)h(to)e(ra)n(w,)g + (unoptimized)h(b)n(yteco)r(de,)g(and)f(\020Opt\021)36 + b(refers)29 b(to)g(appli-)0 5047 y(cation)f(of)g(PRE)h(after)f(man)n(y) + g(preoptimization)f(passes)1795 5017 y Fi(4)1831 5047 + y Fr(.)39 b(W)-7 b(e)29 b(consider)e(the)i(Opt)f(v)n(ersion)f(of)h + (Olden_p)r(erimeter)g(to)g(b)r(e)p 0 5120 1560 4 v 92 + 5173 a Fg(4)127 5197 y Ff(In)d(particular,)g(funcresolv)n(e,)g + (globaldce,)g(deadt)n(yp)r(eelim,)f(constan)n(tmerge,)i(v)n(eri\034er,) + g(deadinstelim,)d(raiseallo)r(cs,)h(indv)l(arsimplify)-6 + b(,)22 b(raise-)0 5275 y(p)r(oin)n(terrefs,)j(mem2reg,)d(simplifycfg,)f + (sccp,)j(instcom)n(bine,)f(aggressiv)n(edce,)i(simplifycfg)1929 + 5589 y Fr(9)p eop end + %%Page: 10 10 + TeXDict begin 10 9 bop 666 70 a Fr(Benc)n(hmark)452 b(Con\034g)99 + b(No)28 b(PRE)217 b(PRE)100 b(\045)28 b(Impro)n(v)n(emen)n(t)p + 616 103 2668 4 v 666 272 a(matT)-7 b(ransp)r(ose)353 + b(Ra)n(w)231 b(761157)138 b(591739)482 b(28.63)666 372 + y(sumarra)n(y)523 b(Ra)n(w)314 b(3848)222 b(3424)483 + b(12.38)666 472 y(Du\033sDevice)432 b(Ra)n(w)314 b(3750)222 + b(3554)524 b(5.51)666 571 y(pi)794 b(Ra)n(w)272 b(95446)180 + b(78008)483 b(22.35)666 671 y(sumarra)n(y2d)435 b(Ra)n(w)231 + b(512250)138 b(452464)482 b(13.21)666 770 y(sumarra)n(ymallo)r(c)285 + b(Ra)n(w)314 b(4697)222 b(4215)483 b(11.44)666 870 y(test_indv)-5 + b(ars)402 b(Ra)n(w)231 b(724987)138 b(583004)482 b(24.35)666 + 970 y(Olden_tsp)27 b(\(512\))253 b(Ra)n(w)189 b(9206950)96 + b(8889874)523 b(3.57)666 1069 y(Olden_treeadd)26 b(\(10\))134 + b(Ra)n(w)189 b(4508523)96 b(4295345)523 b(4.96)666 1169 + y(Olden_treeadd)26 b(\(10\))134 b(Opt)207 b(1986671)96 + b(1986671)565 b(0.0)666 1269 y(Olden_health)355 b(Ra)n(w)231 + b(215848)138 b(201590)523 b(7.07)666 1368 y(Olden_p)r(erimeter)27 + b(\(5\))99 b(Ra)n(w)189 b(2728844)96 b(2618785)523 b(4.20)666 + 1468 y(Olden_p)r(erimeter)27 b(\(5\))99 b(Opt)207 b(1248856)96 + b(1310623)496 b(-4.71)520 1729 y(T)-7 b(able)27 b(1:)36 + b(Dynamic)28 b(instruction)f(reduction)g(resulting)g(from)g + (application)g(of)h(SSAPRE)0 1994 y(an)f(outlier)378 + 1964 y Fi(5)416 1994 y Fr(,)g(and)h(presume)f(that)h(no)f(redundancies) + g(existed)g(in)h(the)g(Opt)f(v)n(ersion)f(Olden_treeadd.)125 + 2094 y(T)-7 b(able)28 b(2)g(compares)f(the)i(dynamic)f(instruction)h + (reduction)f(induced)h(b)n(y)f(PRE)i(vs.)40 b(application)27 + b(of)i(LL)-9 b(VM's)28 b(GCSE)0 2194 y(and)f(LICM)h(implemen)n(tation.) + 2740 2379 y(\045)g(Impro)n(v)n(emen)n(t)586 2479 y(Benc)n(hmark)417 + b(Con\034g)99 b(GCSE/LICM)216 b(PRE)101 b(\(PRE)29 b(vs)e(LICM\))p + 536 2512 2829 4 v 586 2681 a(Olden_tsp)g(\(512\))218 + b(Ra)n(w)371 b(7867153)96 b(8889874)509 b(-11.5)586 2781 + y(Olden_treeadd)26 b(\(10\))99 b(Ra)n(w)371 b(4170526)96 + b(4295345)509 b(-2.91)586 2881 y(Olden_treeadd)26 b(\(10\))99 + b(Opt)389 b(1973272)96 b(1986671)509 b(-0.67)586 2980 + y(Olden_health)320 b(Ra)n(w)412 b(172438)138 b(201590)468 + b(-14.46)586 3080 y(Olden_p)r(erimeter)197 b(Ra)n(w)371 + b(2378062)96 b(2618785)509 b(-9.19)586 3180 y(Olden_p)r(erimeter)197 + b(Opt)389 b(1189636)96 b(1310623)509 b(-9.23)676 3446 + y(T)-7 b(able)28 b(2:)36 b(Dynamic)28 b(instruction)f(reduction)g(in)h + (GCSE/LICM)g(vs.)36 b(SSAPRE)125 3650 y(Unfortunately)-7 + b(,)35 b(our)e(implemen)n(tation)h(of)f(SSAPRE)j(do)r(esn't)e(b)r(eat)f + (the)i(LL)-9 b(VM)33 b(implemen)n(tation)h(of)g(GCSE)g(and)0 + 3750 y(LICM.)26 b(W)-7 b(e)26 b(b)r(eliev)n(e)f(this)h(to)f(b)r(e)h(b)r + (ecause)g(w)n(e)f(are)g(not)g(using)g(v)-5 b(alue)26 + b(n)n(um)n(b)r(ering)f(information)g(to)g(disco)n(v)n(er)f(more)h + (redun-)0 3849 y(dancies)d(than)h(those)g(a)n(v)-5 b(ailable)21 + b(to)i(the)g(analysis)f(b)n(y)g(considering)g(only)g(lexically)g(iden)n + (ti\034ed)i(expressions.)33 b(F)-7 b(urthermore,)0 3949 + y(w)n(e)24 b(w)n(eren't)f(able)h(to)g(eliminate)h(redundan)n(t)e(loads) + g(b)r(ecause)h(v)-5 b(alue)24 b(n)n(um)n(b)r(ering)g(information)f + (that)i(simply)f(yields)g(equiv-)0 4048 y(alence)k(of)h(load)f + (instructions)g(is)h(insu\036cien)n(t)g(to)g(pro)n(v)n(e)e(a)h(load)g + (redundan)n(t)h(and)f(correctly)g(eliminate)h(the)g(redundancy)0 + 4148 y(in)34 b(some)f(cases.)54 b(F)-7 b(or)33 b(example,)i(if)f(w)n(e) + f(w)n(ere)g(to)g(emplo)n(y)g(\(load\))h(v)-5 b(alue-n)n(um)n(b)r(ering) + 32 b(analysis,)i(t)n(w)n(o)f(subsequen)n(t)g(loads)0 + 4248 y(preceded)25 b(b)n(y)h(a)f(related)g(store)g(in)h(the)h(b)r(o)r + (dy)f(of)f(a)h(lo)r(op)f(nest)h(ma)n(y)f(b)r(e)i(VN-equiv)-5 + b(alen)n(t)25 b(and)h(b)r(oth)g(b)r(e)g(pro)n(v)n(en)f(redundan)n(t)0 + 4347 y(b)n(y)31 b(our)f(implemen)n(tation,)i(since)f(it)h(w)n(ouldn't)f + (explicitly)g(lo)r(ok)f(for)h(preceding)f(related)g(stores)g(that)i + (ough)n(t)e(to)h(prev)n(en)n(t)0 4447 y(hoisting.)125 + 4547 y(It)37 b(is)g(our)g(b)r(elief)h(that)g(the)f(a)g(prop)r(er)g(w)n + (orklist-driv)n(en)d(implemen)n(tation,)40 b(wherein)d(the)h + (expression)e(equiv)-5 b(alence)0 4646 y(classes)30 b(are)h(visited)g + (in)h(the)g(prop)r(er)f(order)f(w)n(ould)h(set)h(SSAPRE)h(closer)d(to)i + (the)g(results)f(obtained)g(via)g(application)g(of)0 + 4746 y(GCSE)i(and)g(LICM.)g(A)n(dditionally)-7 b(,)33 + b(the)g(application)f(of)h(the)g Fk(instcombine)39 b + Fr(pass)32 b(after)g(SSAPRE)i(w)n(ould)f(b)r(e)g(useful,)0 + 4845 y(since)f(SSAPRE)i(in)n(tro)r(duces)d(a)h(lot)g(of)g(casts)g(whic) + n(h)g(are)f(able)h(to)g(b)r(e)g(folded)h(together)e(\(i.e.)51 + b(cop)n(y)31 b(propagation\).)49 b(W)-7 b(e)0 4945 y(sp)r(eculate)20 + b(that)f(this)h(could)g(b)r(e)g(wh)n(y)f(w)n(e)g(witness)h(an)f + (increase)f(in)i(the)g(dynamic)g(instruction)f(coun)n(t)g(of)h(Olden_p) + r(erimeter.)p 0 5017 1560 4 v 92 5071 a Fg(5)127 5094 + y Ff(W)-6 b(e)36 b(realize)h(that)f(PRE)f(should)h(nev)n(er)h(increase) + g(n)n(um)n(b)r(er)e(of)g(dynamic)g(instructions;)43 b(unfortunately)-6 + b(,)40 b(w)n(e)c(did)f(not)h(ha)n(v)n(e)h(time)d(to)0 + 5173 y(in)n(v)n(estigate)25 b(this)f(issue)1908 5589 + y Fr(10)p eop end + %%Page: 11 11 + TeXDict begin 11 10 bop 0 83 a Fs(7)131 b(Conclusion)0 + 265 y Fr(This)22 b(wraps)g(up)g(our)g(presen)n(tation)f(of)i(the)f + (SSAPRE)j(algorithm.)33 b(W)-7 b(e'v)n(e)23 b(completed)f(an)g(initial) + h(implemen)n(tation)f(of)h(the)0 364 y(algorithm)i(presen)n(ted)h(in)h + (the)g(pap)r(er.)36 b(Ev)n(en)n(though)26 b(it)h(has)f(some)g + (de\034ciencies,)g(w)n(e'v)n(e)g(learned)g(a)g(lot)g(from)g(the)h(pro)r + (cess)0 464 y(of)h(implemen)n(tation)f(and)g(ha)n(v)n(e)g(iden)n + (ti\034ed)h(sev)n(eral)e(problems)g(with)i(the)g(algorithm)f(as)g + (presen)n(ted)f(in)i(the)g(pap)r(er.)125 564 y(W)-7 b(e'v)n(e)21 + b(sho)n(wn)h(that)g(PRE)h(is)f(v)n(ery)f(go)r(o)r(d)g(at)h(reducing)g + (the)g(n)n(um)n(b)r(er)g(of)g(dynamic)g(instructions)f(executed)h(and)g + (b)r(eliev)n(e)0 663 y(PRE)29 b(will)f(b)r(e)f(an)h(imp)r(ortat)f(part) + g(of)h(an)f(SSA)h(based)f(optimizer)g(when)h(the)g(algorithm)e + (matures.)0 938 y Fs(References)0 1120 y Fr([1])41 b + Fb(Kenned)n(y,)35 b(R.,)g(Chan,)g(S.,)f(Liu,)g(S.,)h(Lo,)f(R.,)h(Tu,)g + (P.,)f(and)g(Cho)n(w,)h(F.)30 b Fr(1999.)f(P)n(artial)h(Redundancy)h + (Elim-)129 1219 y(ination)h(in)h(SSA)g(F)-7 b(orm.)32 + b(In)h Fq(A)n(CM)i(T)-6 b(r)l(ansactions)34 b(on)h(Pr)l(o)l(gr)l + (amming)g(L)l(anguages)f(and)h(Systems,)g(V)-6 b(ol.)35 + b(21,)i(No.)e(3)p Fr(.)129 1319 y(627-674.)0 1485 y([2])41 + b Fb(Morel,)f(E.)d(and)h(Renviose,)i(C.)35 b Fr(1979.)d(Global)i + (optimization)g(b)n(y)g(suppression)f(of)h(partial)f(redundancies.)h + (In)129 1585 y Fq(Communic)l(ations)c(of)h(the)f(A)n(CM)p + Fr(.)e(96-103.)0 1751 y([3])41 b Fb(Knoop,)31 b(J.,)f(R)n(\374thing,)h + (O.,)g(Steffen,)h(B.)27 b Fr(1992.)e(Lazy)i(Co)r(de)h(Motion.)f(In)h + Fq(A)n(CM)i(SIGPLAN)f('92)p Fr(.)g(224-234.)0 1917 y([4])41 + b Fb(Cormen,)d(T.,)f(Leiserson,)h(C.,)g(Rivest,)g(R,)f(Stein,)h(C.)32 + b Fr(2001.)f(In)n(tro)r(duction)h(to)h(Algorithms,)g(2nd)g(edition.)129 + 2016 y(MIT)28 b(Press)f(/)g(McGra)n(w-Hill)g(2001.)0 + 2182 y([5])41 b Fb(Cytr)n(on,)g(R.,)h(Ferrante,)g(J.,)g(R)n(osen,)f + (B.,)h(Wegman,)g(M.,)f(Zadeck,)g(F.)36 b Fr(1991.)e(E\036cien)n(tly)i + (Computing)129 2282 y(Static)28 b(Single)f(Assignmen)n(t)g(F)-7 + b(orm)27 b(and)g(the)g(Con)n(trol)f(Dep)r(endence)i(Graph.)f(In)h + Fq(A)n(CM)h(T)-6 b(r)l(ansactions)30 b(on)g(Pr)l(o)l(gr)l(am-)129 + 2382 y(ming)g(L)l(anguages)g(and)g(Systems)p Fr(.)d(V)-7 + b(ol)28 b(3,)f(4.)g(451-490.)1908 5589 y(11)p eop end + %%Page: 12 12 + TeXDict begin 12 11 bop 0 83 a Fs(APPENDIX)0 315 y(A)132 + b(Lazy)44 b(Co)t(de)f(Motion)h(Example)0 496 y Fr(W)-7 + b(e)29 b(to)r(ok)e(the)i(CF)n(G)f(from)g(the)h(Lazy)e(Co)r(de)h(Motion) + g(pap)r(er)f(\([3])i(Figure)e(1\))h(and)g(created)g(a)f(program)g(in)h + (LL)-9 b(VM)28 b(whic)n(h)0 596 y(has)f(the)i(same)e(CF)n(G)h(with)h + (computations)e(in)i(the)f(same)g(basic)f(blo)r(c)n(ks.)37 + b(Using)28 b(this,)h(w)n(e)e(can)h(determine)g(if)h(our)e(pass)g(is)0 + 696 y(placing)k(computations)g(in)h(the)g(optimal)g(places)f(predicted) + g(b)n(y)h([3)o(].)50 b(Though)31 b(our)g(pass)g(w)n(orks)f(on)h(all)h + (expressions)e(in)0 795 y(the)i(program,)e(for)h(the)h(sak)n(e)e(of)i + (brevit)n(y)e(w)n(e)h(will)h(fo)r(cus)g(only)f(on)g(the)h(\020core\021) + k(expressions)30 b(\026)h(i.e.,)i(those)e(of)h(the)f(form)0 + 895 y Fk(\045foo)42 b(=)h(mul)f(int)h(\045a,)f(\045b)p + Fr(.)0 1127 y Fp(A.1)112 b(Before)37 b(SSAPRE)f(P)m(ass)0 + 1281 y Fk(\045.LCA)41 b(=)j(internal)c(global)h([)i(13)g(x)g(sbyte)e(]) + i(c"B\045d:)e(A)j(=)f(\045d\\0A\\00")170 b(;)43 b(<[13)f(x)h(sbyte*]>)0 + 1380 y(\045.LCB)e(=)j(internal)c(global)h([)i(13)g(x)g(sbyte)e(])i + (c"B\045d:)e(B)j(=)f(\045d\\0A\\00")170 b(;)43 b(<[13)f(x)h(sbyte*]>)0 + 1480 y(\045.LCX)e(=)j(internal)c(global)h([)i(13)g(x)g(sbyte)e(])i + (c"B\045d:)e(X)j(=)f(\045d\\0A\\00")170 b(;)43 b(<[13)f(x)h(sbyte*]>)0 + 1579 y(\045.LCY)e(=)j(internal)c(global)h([)i(13)g(x)g(sbyte)e(])i + (c"B\045d:)e(Y)j(=)f(\045d\\0A\\00")170 b(;)43 b(<[13)f(x)h(sbyte*]>)0 + 1679 y(\045.LCZ)e(=)j(internal)c(global)h([)i(13)g(x)g(sbyte)e(])i + (c"B\045d:)e(Z)j(=)f(\045d\\0A\\00")170 b(;)43 b(<[13)f(x)h(sbyte*]>)0 + 1779 y(\045.LCSUM)e(=)i(internal)d(global)h([)i(17)g(x)g(sbyte)e(])j + (c"B\045d:)d(Y)i(Sum)f(=)h(\045d\\0A\\00")171 b(;)43 + b(<[17)f(x)h(sbyte*]>)0 1978 y(implementation)125 b(;)43 + b(Functions:)0 2177 y(declare)e(int)h(\045printf\(sbyte*,)37 + b(...\))0 2376 y(int)42 b(\045main\(int)e(\045argc,)h(sbyte**)g + (\045argv\))g({)0 2476 y(B1:)h(;)h(No)g(predecessors!)87 + 2576 y(\045B1cond)e(=)i(setge)e(int)i(\045argc,)e(2)87 + 2675 y(\045LCA)h(=)h(getelementptr)38 b([13)43 b(x)g(sbyte]*)d + (\045.LCA,)h(long)h(0,)h(long)f(0)87 2775 y(\045LCB)g(=)h + (getelementptr)38 b([13)43 b(x)g(sbyte]*)d(\045.LCB,)h(long)h(0,)h + (long)f(0)87 2875 y(\045LCX)g(=)h(getelementptr)38 b([13)43 + b(x)g(sbyte]*)d(\045.LCX,)h(long)h(0,)h(long)f(0)87 2974 + y(\045LCY)g(=)h(getelementptr)38 b([13)43 b(x)g(sbyte]*)d(\045.LCY,)h + (long)h(0,)h(long)f(0)87 3074 y(\045LCZ)g(=)h(getelementptr)38 + b([13)43 b(x)g(sbyte]*)d(\045.LCZ,)h(long)h(0,)h(long)f(0)87 + 3173 y(\045LCSUM)f(=)i(getelementptr)38 b([17)43 b(x)g(sbyte]*)d + (\045.LCSUM,)h(long)h(0,)g(long)g(0)87 3273 y(br)h(bool)f(\045B1cond,)e + (label)h(\045B2,)h(label)g(\045B4)0 3472 y(B2:)87 3572 + y(\045a0)g(=)i(cast)d(int)i(1)g(to)g(int)87 3672 y(\045b0)f(=)i(cast)d + (int)i(3)g(to)g(int)87 3771 y(br)g(label)e(\045B3)0 3971 + y(B3:)87 4070 y(\045x0)h(=)i(mul)e(int)g(\045a0,)g(\045b0)87 + 4170 y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCX,)h(int)g(3,)h(int)f(\045x0)g(\))87 4269 y(br)h(label)e(\045B5) + 0 4469 y(B4:)87 4568 y(\045a1)h(=)i(cast)d(int)i(1)g(to)g(int)87 + 4668 y(\045b1)f(=)i(cast)d(int)i(27)g(to)f(int)87 4768 + y(\045x1)g(=)i(cast)d(int)i(0)g(to)g(int)87 4867 y(br)g(label)e(\045B5) + 0 5066 y(B5:)87 5166 y(;;)i(Expect)e(Factor)g(node)h(here)g(for)g(expr) + g(in)h(B3)87 5266 y(\045a2)f(=)i(phi)e(int)g([)h(\045a0,)f(\045B3)h(],) + f([)h(\045a1,)f(\045B4)h(])1908 5589 y Fr(12)p eop end + %%Page: 13 13 + TeXDict begin 13 12 bop 87 83 a Fk(\045b2)42 b(=)i(phi)e(int)g([)h + (\045b0,)f(\045B3)h(],)f([)h(\045b1,)f(\045B4)h(])87 + 183 y(\045x2)f(=)i(phi)e(int)g([)h(\045x0,)f(\045B3)h(],)f([)h(\045x1,) + f(\045B4)h(])87 282 y(call)f(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f + (sbyte*)h(\045LCA,)h(int)g(5,)h(int)f(\045a2)g(\))87 + 382 y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCB,)h(int)g(5,)h(int)f(\045b2)g(\))87 482 y(call)g(int)g + (\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCX,)h(int)g(5,)h + (int)f(\045x2)g(\))87 581 y(\045B5cond)f(=)i(seteq)e(int)i(\045b2,)f(3) + 87 681 y(br)h(bool)f(\045B5cond,)e(label)h(\045B6,)h(label)g(\045B7)0 + 880 y(B6:)87 980 y(\045B6cond)f(=)i(seteq)e(int)i(\045argc,)e(3)87 + 1079 y(br)i(bool)f(\045B6cond,)e(label)h(\045B8,)h(label)g(\045B9)0 + 1279 y(B7:)87 1378 y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f + (sbyte*)h(\045LCA,)h(int)g(7,)h(int)f(\045a2)g(\))87 + 1478 y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCB,)h(int)g(7,)h(int)f(\045b2)g(\))87 1577 y(call)g(int)g + (\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCX,)h(int)g(7,)h + (int)f(\045x2)g(\))87 1677 y(br)h(label)e(\045B18)0 1876 + y(B8:)87 1976 y(\045y0)h(=)i(cast)d(int)i(0)g(to)g(int)87 + 2076 y(\045y_sum0)e(=)i(cast)f(int)g(0)h(to)g(int)87 + 2175 y(\045count0)e(=)i(cast)f(int)g(\045x2)g(to)h(int)87 + 2275 y(br)g(label)e(\045B11)0 2474 y(B10:)87 2574 y(\045y1)h(=)i(mul)e + (int)g(\045a2,)g(\045b2)173 b(;;)43 b(This)f(expression)d(is)k(inside)e + (of)i(a)g(loop)f(and)1220 2673 y(;;)h(is)g(invariant)c(to)k(that)f + (loop.)f(It)i(should)e(be)1220 2773 y(;;)i(moved)e(to)i(basic)e(block)h + (B8.)87 2873 y(\045y_sum1)f(=)i(add)f(int)h(\045y_sum2,)d(\045y1)87 + 2972 y(\045count1)h(=)i(sub)f(int)h(\045count2,)d(1)87 + 3072 y(br)j(label)e(\045B11)0 3271 y(B11:)87 3371 y(;;)i(Expect)e + (Factor)g(node)h(here)g(for)g(the)g(expr)g(in)h(B10)87 + 3470 y(\045y2)f(=)i(phi)e(int)g([)h(\045y0,)f(\045B8)h(],)f([)h + (\045y1,)f(\045B10)g(])87 3570 y(\045y_sum2)f(=)i(phi)f(int)h([)g + (\045y_sum0,)d(\045B8)i(],)h([)g(\045y_sum1,)d(\045B10)i(])87 + 3670 y(\045count2)f(=)i(phi)f(int)h([)g(\045count0,)d(\045B8)i(],)h([)g + (\045count1,)d(\045B10)i(])87 3769 y(\045B11cond)e(=)j(setge)f(int)g + (\045count2,)e(0)87 3869 y(br)j(bool)f(\045B11cond,)e(label)h(\045B10,) + g(label)h(\045B14)0 4068 y(B14:)87 4168 y(call)g(int)g(\(sbyte*,)f + (...\)*)g(\045printf\()f(sbyte*)h(\045LCSUM,)g(int)h(14,)g(int)h + (\045y_sum2)d(\))87 4267 y(br)j(label)e(\045B16)0 4467 + y(B9:)87 4566 y(br)i(label)e(\045B12)0 4765 y(B12:)87 + 4865 y(\045B12cond)f(=)j(seteq)f(int)g(\045argc,)f(4)87 + 4965 y(br)i(bool)f(\045B12cond,)e(label)h(\045B15,)g(label)h(\045B17)0 + 5164 y(B15:)87 5264 y(\045y3)g(=)i(mul)e(int)g(\045a2,)g(\045b2)173 + b(;;)43 b(This)f(expression)d(won't)j(be)g(moved)g(out)g(of)h(B15)1908 + 5589 y Fr(13)p eop end + %%Page: 14 14 + TeXDict begin 14 13 bop 1220 83 a Fk(;;)43 b(because)d(this)i(is)h(the) + f(earliest)f(position)f(for)1220 183 y(;;)j(it)g(with)e(respect)g(to)i + (those)e(exprs)h(and)g(their)1220 282 y(;;)h(uses)f(in)g(B15)h(and)f + (B16.)87 382 y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*) + h(\045LCY,)h(int)g(15,)g(int)h(\045y3)f(\))87 482 y(br)h(label)e + (\045B16)0 681 y(B16:)87 780 y(;;)i(Expect)e(Factor)g(node)h(here)g + (for)g(exprs)f(in)i(B10)f(and)h(B15)87 880 y(\045y4)f(=)i(phi)e(int)g + ([)h(\045y3,)f(\045B15)g(],)h([)g(\045y2,)f(\045B14)g(])87 + 980 y(\045z0)g(=)i(mul)e(int)g(\045a2,)g(\045b2)173 b(;;)43 + b(This)f(expression)d(will)j(be)h(converted)c(into)j(an)1220 + 1079 y(;;)h(assignment)c(because)i(there)g(are)i(evaluations)1220 + 1179 y(;;)g(of)g(this)e(expression)f(coming)h(in)i(from)e(B8)i(and)1220 + 1279 y(;;)g(B15)f(after)g(the)g(pass)g(is)h(run.)87 1378 + y(call)f(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCZ,)h + (int)g(16,)g(int)h(\045z0)f(\))87 1478 y(br)h(label)e(\045B18)0 + 1677 y(B17:)87 1777 y(\045x3)h(=)i(mul)e(int)g(\045a2,)g(\045b2)173 + b(;;)43 b(This)f(expression)d(will)j(remain)f(here)h(because)1220 + 1876 y(;;)h(there's)d(no)j(earlier)e(placement)f(for)i(this)1220 + 1976 y(;;)h(computation)c(that)j(is)g(optimal.)87 2076 + y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCX,)h + (int)g(17,)g(int)h(\045x3)f(\))87 2175 y(br)h(label)e(\045B18)0 + 2374 y(B18:)87 2474 y(;;)i(Expect)e(Factor)g(node)h(here)g(for)g(exprs) + f(in)i(B10,)f(B15,)g(B16,)g(B17)87 2574 y(ret)g(int)h(0)0 + 2673 y(})0 2906 y Fp(A.2)112 b(Exp)s(ected)37 b(Results)0 + 3059 y Fr(The)28 b(Lazy)f(Co)r(de)h(Motion)f(pap)r(er)h([3)o(])g + (concludes)f(that)i(the)f(ab)r(o)n(v)n(e)e(program)g(should)i(ha)n(v)n + (e)e(a)i(computation)f(of)h Fk(mul)42 b(int)0 3159 y(\045a,)g(\045b)h + Fr(in)25 b(basic)f(blo)r(c)n(ks)h(B3,)f(B8,)h(B15,)g(and)f(B17)g(with)h + (uses)g(of)g(those)f(computations)g(in)i(basic)e(blo)r(c)n(ks)g(B3,)h + (B10,)f(B15,)0 3258 y(B16,)29 b(and)g(B17)g(\([3])g(Figure)g(7\).)43 + b(As)29 b(sho)n(wn)g(in)h(the)g(next)f(section,)h(the)g(result)f(of)h + (running)f(the)h(SSAPRE)h(pass)d(on)i(the)0 3358 y(ab)r(o)n(v)n(e)c(co) + r(de)i(do)r(es)f(just)h(this.)0 3590 y Fp(A.3)112 b(After)36 + b(SSAPRE)h(P)m(ass)0 3743 y Fk(\045.LCA)k(=)j(internal)c(global)h([13)h + (x)h(sbyte])e(c"B\045d:)g(A)i(=)h(\045d\\0A\\00")39 b(;)44 + b(<[13)d(x)j(sbyte]*>)c([#uses=1])0 3843 y(\045.LCB)h(=)j(internal)c + (global)h([13)h(x)h(sbyte])e(c"B\045d:)g(B)i(=)h(\045d\\0A\\00")39 + b(;)44 b(<[13)d(x)j(sbyte]*>)c([#uses=1])0 3943 y(\045.LCX)h(=)j + (internal)c(global)h([13)h(x)h(sbyte])e(c"B\045d:)g(X)i(=)h + (\045d\\0A\\00")39 b(;)44 b(<[13)d(x)j(sbyte]*>)c([#uses=1])0 + 4042 y(\045.LCY)h(=)j(internal)c(global)h([13)h(x)h(sbyte])e(c"B\045d:) + g(Y)i(=)h(\045d\\0A\\00")39 b(;)44 b(<[13)d(x)j(sbyte]*>)c([#uses=1])0 + 4142 y(\045.LCZ)h(=)j(internal)c(global)h([13)h(x)h(sbyte])e(c"B\045d:) + g(Z)i(=)h(\045d\\0A\\00")39 b(;)44 b(<[13)d(x)j(sbyte]*>)c([#uses=1])0 + 4242 y(\045.LCSUM)h(=)i(internal)d(global)h([17)h(x)h(sbyte])e + (c"B\045d:)g(Y)j(Sum)e(=)h(\045d\\0A\\00")d(;)j(<[17)f(x)h(sbyte]*>)d + ([#uses=1])0 4441 y(implementation)125 b(;)43 b(Functions:)0 + 4640 y(declare)e(int)h(\045printf\(sbyte*,)37 b(...\))0 + 4839 y(int)42 b(\045main\(int)e(\045argc,)h(sbyte**)g(\045argv\))g({)0 + 4939 y(B1:)173 b(;)43 b(No)g(predecessors!)87 5039 y(\045B1cond)e(=)i + (setge)e(int)i(\045argc,)e(2)174 b(;)43 b()e([#uses=1])87 + 5138 y(\045LCA)h(=)h(getelementptr)38 b([13)43 b(x)g(sbyte]*)d + (\045.LCA,)h(long)h(0,)h(long)f(0)174 b(;)43 b()d([#uses=2])87 + 5238 y(\045LCB)i(=)h(getelementptr)38 b([13)43 b(x)g(sbyte]*)d + (\045.LCB,)h(long)h(0,)h(long)f(0)174 b(;)43 b()d([#uses=2])87 + 5337 y(\045LCX)i(=)h(getelementptr)38 b([13)43 b(x)g(sbyte]*)d + (\045.LCX,)h(long)h(0,)h(long)f(0)174 b(;)43 b()d([#uses=4]) + 1908 5589 y Fr(14)p eop end + %%Page: 15 15 + TeXDict begin 15 14 bop 87 83 a Fk(\045LCY)42 b(=)h(getelementptr)38 + b([13)43 b(x)g(sbyte]*)d(\045.LCY,)h(long)h(0,)h(long)f(0)174 + b(;)43 b()d([#uses=1])87 183 y(\045LCZ)i(=)h(getelementptr)38 + b([13)43 b(x)g(sbyte]*)d(\045.LCZ,)h(long)h(0,)h(long)f(0)174 + b(;)43 b()d([#uses=1])87 282 y(\045LCSUM)h(=)i(getelementptr)38 + b([17)43 b(x)g(sbyte]*)d(\045.LCSUM,)h(long)h(0,)g(long)g(0)174 + b(;)43 b()d([#uses=1])87 382 y(br)j(bool)f(\045B1cond,)e(label) + h(\045B2,)h(label)g(\045B4)0 581 y(B2:)173 b(;)43 b(preds)f(=)h(\045B1) + 87 681 y(\045a0)f(=)i(cast)d(int)i(1)g(to)g(int)173 b(;)43 + b()e([#uses=2])87 780 y(\045b0)h(=)i(cast)d(int)i(3)g(to)g(int)173 + b(;)43 b()e([#uses=2])87 880 y(br)i(label)e(\045B3)0 + 1079 y(B3:)173 b(;)43 b(preds)f(=)h(\045B2)87 1179 y(\045x0)f(=)i(mul)e + (int)g(\045a0,)g(\045b0)173 b(;)43 b()f([#uses=2])87 + 1279 y(call)g(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCX,)h(int)g(3,)h(int)f(\045x0)g(\))174 b(;)43 b(:0)e + ([#uses=0])87 1378 y(br)i(label)e(\045B5)0 1577 y(B4:)173 + b(;)43 b(preds)f(=)h(\045B1)87 1677 y(\045a1)f(=)i(cast)d(int)i(1)g(to) + g(int)173 b(;)43 b()e([#uses=1])87 1777 y(\045b1)h(=)i(cast)d(int) + i(27)g(to)f(int)130 b(;)43 b()e([#uses=1])87 1876 + y(\045x1)h(=)i(cast)d(int)i(0)g(to)g(int)173 b(;)43 b()e + ([#uses=1])87 1976 y(br)i(label)e(\045B5)0 2175 y(B5:)173 + b(;)43 b(preds)f(=)h(\045B4,)f(\045B3)87 2275 y(\045a2)g(=)i(phi)e(int) + g([)h(\045a0,)f(\045B3)h(],)f([)h(\045a1,)f(\045B4)h(])173 + b(;)44 b()d([#uses=5])87 2374 y(\045b2)h(=)i(phi)e(int)g([)h + (\045b0,)f(\045B3)h(],)f([)h(\045b1,)f(\045B4)h(])173 + b(;)44 b()d([#uses=6])87 2474 y(\045x2)h(=)i(phi)e(int)g([)h + (\045x0,)f(\045B3)h(],)f([)h(\045x1,)f(\045B4)h(])173 + b(;)44 b()d([#uses=3])87 2574 y(call)h(int)g(\(sbyte*,)f(...\)*)g + (\045printf\()f(sbyte*)h(\045LCA,)h(int)g(5,)h(int)f(\045a2)g(\))174 + b(;)43 b(:1)e([#uses=0])87 2673 y(call)h(int)g(\(sbyte*,)f(...\)*) + g(\045printf\()f(sbyte*)h(\045LCB,)h(int)g(5,)h(int)f(\045b2)g(\))174 + b(;)43 b(:2)e([#uses=0])87 2773 y(call)h(int)g(\(sbyte*,)f(...\)*) + g(\045printf\()f(sbyte*)h(\045LCX,)h(int)g(5,)h(int)f(\045x2)g(\))174 + b(;)43 b(:3)e([#uses=0])87 2873 y(\045B5cond)g(=)i(seteq)e(int)i + (\045b2,)f(3)173 b(;)44 b()d([#uses=1])87 2972 + y(br)i(bool)f(\045B5cond,)e(label)h(\045B6,)h(label)g(\045B7)0 + 3171 y(B6:)173 b(;)43 b(preds)f(=)h(\045B5)87 3271 y(\045B6cond)e(=)i + (seteq)e(int)i(\045argc,)e(3)174 b(;)43 b()e([#uses=1])87 + 3371 y(br)i(bool)f(\045B6cond,)e(label)h(\045B8,)h(label)g(\045B9)0 + 3570 y(B7:)173 b(;)43 b(preds)f(=)h(\045B5)87 3670 y(call)f(int)g + (\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCA,)h(int)g(7,)h + (int)f(\045a2)g(\))174 b(;)43 b(:4)e([#uses=0])87 + 3769 y(call)h(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCB,)h(int)g(7,)h(int)f(\045b2)g(\))174 b(;)43 b(:5)e + ([#uses=0])87 3869 y(call)h(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f + (sbyte*)h(\045LCX,)h(int)g(7,)h(int)f(\045x2)g(\))174 + b(;)43 b(:6)e([#uses=0])87 3968 y(br)i(label)e(\045B18)0 + 4168 y(B8:)173 b(;)43 b(preds)f(=)h(\045B6)87 4267 y(\045y0)f(=)i(cast) + d(int)i(0)g(to)g(int)478 b(;)43 b()e([#uses=2])87 + 4367 y(\045T_3)h(=)h(cast)f(int)g(\045y0)h(to)f(int)348 + b(;)43 b()e([#uses=1])87 4467 y(\045count0)g(=)i(cast)f(int)g + (\045x2)g(to)h(int)217 b(;)43 b()e([#uses=1])87 + 4566 y(\045y1_clone)f(=)j(mul)f(int)h(\045a2,)f(\045b2)260 + b(;)43 b()e([#uses=1])87 4666 y(\045T_0)h(=)h(cast)f(int)g + (\045y1_clone)e(to)j(int)86 b(;)43 b()e([#uses=3])87 + 4765 y(br)i(label)e(\045B11)0 4965 y(B10:)173 b(;)43 + b(preds)e(=)i(\045B11)87 5064 y(\045y_sum1)e(=)i(add)f(int)h + (\045y_sum2,)d(\045T_0)129 b(;)43 b()e([#uses=1])87 + 5164 y(\045count1)g(=)i(sub)f(int)h(\045count2,)d(1)261 + b(;)43 b()e([#uses=1])87 5264 y(br)i(label)e(\045B11)1908 + 5589 y Fr(15)p eop end + %%Page: 16 16 + TeXDict begin 16 15 bop 0 183 a Fk(B11:)173 b(;)43 b(preds)e(=)i + (\045B10,)f(\045B8)87 282 y(\045y2)g(=)i(phi)e(int)g([)h(\045y0,)f + (\045B8)h(],)f([)h(\045T_0,)f(\045B10)g(])522 b(;)43 + b()f([#uses=1])87 382 y(\045y_sum2)f(=)i(phi)f(int)h([)g(\045T_3,) + e(\045B8)h(],)h([)g(\045y_sum1,)d(\045B10)i(])174 b(;)43 + b()f([#uses=2])87 482 y(\045count2)f(=)i(phi)f(int)h([)g + (\045count0,)d(\045B8)i(],)h([)g(\045count1,)d(\045B10)i(])h(;)g() + f([#uses=2])87 581 y(\045B11cond)e(=)j(setge)f(int)g(\045count2,)e(0) + 174 b(;)43 b()e([#uses=1])87 681 y(br)i(bool)f(\045B11cond,)e + (label)h(\045B10,)g(label)h(\045B14)0 880 y(B14:)173 + b(;)43 b(preds)e(=)i(\045B11)87 980 y(call)f(int)g(\(sbyte*,)f(...\)*)g + (\045printf\()f(sbyte*)h(\045LCSUM,)g(int)h(14,)g(int)h(\045y_sum2)d + (\))174 b(;)43 b(:7)e([#uses=0])87 1079 y(br)i(label)e(\045B16)0 + 1279 y(B9:)173 b(;)43 b(preds)f(=)h(\045B6)87 1378 y(br)g(label)e + (\045B12)0 1577 y(B12:)173 b(;)43 b(preds)e(=)i(\045B9)87 + 1677 y(\045B12cond)d(=)j(seteq)f(int)g(\045argc,)f(4)174 + b(;)43 b()e([#uses=1])87 1777 y(br)i(bool)f(\045B12cond,)e(label) + h(\045B15,)g(label)h(\045B17)0 1976 y(B15:)173 b(;)43 + b(preds)e(=)i(\045B12)87 2076 y(\045y3)f(=)i(mul)e(int)g(\045a2,)g + (\045b2)347 b(;)44 b()d([#uses=3])87 2175 y(\045T_2)h(=)h(cast)f + (int)g(\045y3)h(to)f(int)173 b(;)44 b()d([#uses=1])87 + 2275 y(call)h(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCY,)h(int)g(15,)g(int)h(\045y3)f(\))174 b(;)43 + b(:8)d([#uses=0])87 2374 y(br)j(label)e(\045B16)0 + 2574 y(B16:)173 b(;)43 b(preds)e(=)i(\045B15,)f(\045B14)87 + 2673 y(\045y4)g(=)i(phi)e(int)g([)h(\045y3,)f(\045B15)g(],)h([)g + (\045y2,)f(\045B14)g(])174 b(;)43 b()e([#uses=0])87 + 2773 y(\045T_1)h(=)h(phi)f(int)h([)g(\045T_2,)e(\045B15)h(],)h([)g + (\045T_0,)f(\045B14)f(])j(;)f()e([#uses=1])87 2873 + y(call)h(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCZ,)h + (int)g(16,)g(int)h(\045T_1)e(\))174 b(;)43 b(:9)e([#uses=0])87 + 2972 y(br)i(label)e(\045B18)0 3171 y(B17:)173 b(;)43 + b(preds)e(=)i(\045B12)87 3271 y(\045x3)f(=)i(mul)e(int)g(\045a2,)g + (\045b2)173 b(;)43 b()f([#uses=1])87 3371 y(call)g(int)g + (\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h(\045LCX,)h(int)g(17,)g + (int)h(\045x3)f(\))174 b(;)43 b(:10)d([#uses=0])87 + 3470 y(br)j(label)e(\045B18)0 3670 y(B18:)173 b(;)43 + b(preds)e(=)i(\045B17,)f(\045B16,)f(\045B7)87 3769 y(ret)h(int)h(0)0 + 3869 y(})1908 5589 y Fr(16)p eop end + %%Page: 17 17 + TeXDict begin 17 16 bop 0 83 a Fs(B)132 b(Multiply)46 + b(Nested)d(Lo)t(ops)0 265 y Fr(In)27 b(one)f(pass)g(of)h(the)g + (algorithm,)f(SSAPRE)j(can)d(\020hoist\021)33 b(co)r(de)26 + b(whic)n(h)h(is)g(lo)r(op)f(in)n(v)-5 b(arian)n(t)26 + b(out)h(of)f(the)h(innermost)g(lo)r(op)f(of)0 364 y(a)h(lo)r(op)g(nest) + h(to)g(its)g(prop)r(er)e(place.)37 b(Our)27 b(example)g(is)g(a)h + (program)d(that)j(has)f(a)g(triply)h(nested)g(lo)r(op)f(whic)n(h)h(has) + f(t)n(w)n(o)g(lo)r(op)0 464 y(in)n(v)-5 b(arian)n(t)26 + b(instructions)h(in)h(it.)0 696 y Fp(B.1)112 b(Before)37 + b(SSAPRE)f(P)m(ass)0 850 y Fk(\045.LCASUM)k(=)j(internal)e(global)g([)i + (17)f(x)i(sbyte)d(])i(c"B\045d:)e(A)i(Sum)g(=)g(\045d\\0A\\00")170 + b(;)43 b(<[17)f(x)h(sbyte*]>)0 949 y(\045.LCBSUM)d(=)j(internal)e + (global)g([)i(17)f(x)i(sbyte)d(])i(c"B\045d:)e(B)i(Sum)g(=)g + (\045d\\0A\\00")170 b(;)43 b(<[17)f(x)h(sbyte*]>)0 1049 + y(\045.LCCSUM)d(=)j(internal)e(global)g([)i(17)f(x)i(sbyte)d(])i + (c"B\045d:)e(C)i(Sum)g(=)g(\045d\\0A\\00")170 b(;)43 + b(<[17)f(x)h(sbyte*]>)0 1248 y(implementation)125 b(;)43 + b(Functions:)0 1447 y(declare)e(int)h(\045printf\(sbyte*,)37 + b(...\))0 1647 y(int)42 b(\045main\(int)e(\045argc,)h(sbyte**)g + (\045argv\))g({)0 1746 y(B1:)h(;)h(No)g(predecessors!)87 + 1846 y(\045x)g(=)g(cast)f(int)g(27)h(to)g(float)87 1946 + y(\045y)g(=)g(cast)f(int)g(3)h(to)g(float)87 2045 y(\045r)g(=)g(cast)f + (int)g(927)h(to)f(float)87 2145 y(\045i0)g(=)i(cast)d(int)i(10)g(to)f + (int)87 2244 y(\045asum0)f(=)i(cast)f(int)h(0)g(to)f(int)87 + 2344 y(\045bsum0)f(=)i(cast)f(int)h(0)g(to)f(int)87 2444 + y(\045csum0)f(=)i(cast)f(int)h(0)g(to)f(int)87 2543 y(\045LCASUM)f(=)i + (getelementptr)38 b([17)k(x)h(sbyte]*)e(\045.LCASUM,)f(long)i(0,)g + (long)g(0)87 2643 y(\045LCBSUM)f(=)i(getelementptr)38 + b([17)k(x)h(sbyte]*)e(\045.LCBSUM,)f(long)i(0,)g(long)g(0)87 + 2743 y(\045LCCSUM)f(=)i(getelementptr)38 b([17)k(x)h(sbyte]*)e + (\045.LCCSUM,)f(long)i(0,)g(long)g(0)87 2842 y(br)h(label)e(\045B2)0 + 3041 y(B2:)87 3141 y(\045i2)h(=)i(phi)e(int)g([)h(\045i0,)f(\045B1)h + (],)f([)h(\045i1,)f(\045B2_end)f(])87 3241 y(\045asum2)g(=)i(phi)g(int) + f([)h(\045asum0,)e(\045B1)h(],)h([)g(\045asum1,)d(\045B2_end)h(])87 + 3340 y(\045bsum2)g(=)i(phi)g(int)f([)h(\045bsum0,)e(\045B1)h(],)h([)g + (\045bsum1,)d(\045B2_end)h(])87 3440 y(\045csum2)g(=)i(phi)g(int)f([)h + (\045csum0,)e(\045B1)h(],)h([)g(\045csum1,)d(\045B2_end)h(])87 + 3540 y(\045j0)h(=)i(cast)d(int)i(10)g(to)f(int)87 3639 + y(\045a)h(=)g(mul)f(int)h(\045i2,)f(10)87 3739 y(\045asum1)f(=)i(add)g + (int)f(\045asum2,)f(\045a)87 3838 y(br)i(label)e(\045B3)0 + 4038 y(B3:)87 4137 y(\045j2)h(=)i(phi)e(int)g([)h(\045j0,)f(\045B2)h + (],)f([)h(\045j1,)f(\045B3_end)f(])87 4237 y(\045bsum3)g(=)i(phi)g(int) + f([)h(\045bsum2,)e(\045B2)h(],)h([)g(\045bsum1,)d(\045B3_end)h(])87 + 4337 y(\045csum3)g(=)i(phi)g(int)f([)h(\045csum2,)e(\045B2)h(],)h([)g + (\045csum1,)d(\045B3_end)h(])87 4436 y(\045k0)h(=)i(cast)d(int)i(10)g + (to)f(int)87 4536 y(\045b)h(=)g(mul)f(int)h(\045j2,)f(10)87 + 4636 y(\045bsum1)f(=)i(add)g(int)f(\045bsum3,)f(\045b)87 + 4735 y(br)i(label)e(\045B4)0 4934 y(B4:)87 5034 y(\045k2)h(=)i(phi)e + (int)g([)h(\045k0,)f(\045B3)h(],)f([)h(\045k1,)f(\045B4)h(])87 + 5134 y(\045csum4)e(=)i(phi)g(int)f([)h(\045csum3,)e(\045B3)h(],)h([)g + (\045csum1,)d(\045B4)j(])87 5233 y(\045z)g(=)g(div)f(float)g(\045x,)g + (\045y)217 b(;;)43 b(Loop)f(invariant)d(computation:)g(This)j(should)f + (be)1220 5333 y(;;)i(moved)e(to)i(before)e(the)h(outer-most)e(loop.) + 1908 5589 y Fr(17)p eop end + %%Page: 18 18 + TeXDict begin 18 17 bop 1220 83 a Fk(;;)87 183 y(\045q)43 + b(=)g(mul)f(float)g(\045r,)g(\045z)217 b(;;)43 b(Loop)f(invariant)d + (computation:)g(This)j(should)1220 282 y(;;)h(also)f(be)g(moved)g(to)h + (before)e(the)h(outer-most)1220 382 y(;;)h(loop,)e(but)i(this)e + (doesn't)g(occur)h(because)e(we)1220 482 y(;;)j(do)g(not)f(keep)g(a)h + (topological)c(sort)j(of)g(the)1220 581 y(;;)h(occurrence)c(sets.)87 + 681 y(\045c)k(=)g(mul)f(int)h(\045k2,)f(10)87 780 y(\045csum1)f(=)i + (add)g(int)f(\045csum4,)f(\045c)87 880 y(\045k1)h(=)i(sub)e(int)g + (\045k2,)g(1)87 980 y(\045b4cond)f(=)i(setgt)e(int)i(\045k1,)f(0)87 + 1079 y(br)h(bool)f(\045b4cond,)e(label)h(\045B4,)h(label)g(\045B3_end)0 + 1279 y(B3_end:)87 1378 y(\045j1)g(=)i(sub)e(int)g(\045j2,)g(1)87 + 1478 y(\045b3cond)f(=)i(setgt)e(int)i(\045j1,)f(0)87 + 1577 y(br)h(bool)f(\045b3cond,)e(label)h(\045B3,)h(label)g(\045B2_end)0 + 1777 y(B2_end:)87 1876 y(\045i1)g(=)i(sub)e(int)g(\045i2,)g(1)87 + 1976 y(\045b2cond)f(=)i(setgt)e(int)i(\045i1,)f(0)87 + 2076 y(br)h(bool)f(\045b2cond,)e(label)h(\045B2,)h(label)g(\045B_exit)0 + 2275 y(B_exit:)87 2374 y(\045q2)g(=)i(mul)e(float)f(\045q,)i(\045q)87 + 2474 y(call)f(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCASUM,)f(int)j(8,)f(int)h(\045asum1)e(\))87 2574 + y(call)h(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCBSUM,)f(int)j(8,)f(int)h(\045bsum1)e(\))87 2673 + y(call)h(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCCSUM,)f(int)j(8,)f(int)h(\045csum1)e(\))87 2773 + y(ret)h(int)h(0)0 2873 y(})0 3105 y Fp(B.2)112 b(Exp)s(ected)37 + b(Results)0 3258 y Fr(W)-7 b(e)34 b(exp)r(ect)g(b)r(oth)g(lo)r(op)f(in) + n(v)-5 b(arian)n(t)33 b(instructions)g Fk(\045z)43 b(=)g(div)f(float)g + (\045x,)g(\045y)h Fr(and)33 b Fk(\045q)43 b(=)g(mul)g(float)e(\045r,)h + (\045z)h Fr(to)34 b(b)r(e)0 3358 y(placed)29 b(in)h(basic)f(blo)r(c)n + (k)g(B1.)42 b(Ho)n(w)n(ev)n(er,)28 b(as)h(men)n(tioned)g(in)h(the)g + (pap)r(er,)f(this)h(requires)e(an)i(ordering)d(on)j(the)g(o)r + (ccurrence)0 3457 y(sets)k(whic)n(h)g(our)g(implemen)n(tation)g(do)r + (esn't)h(enforce.)56 b(So,)36 b(as)e(sho)n(wn)f(in)i(the)g(next)f + (section,)i(only)e(one)g(instruction)g(is)0 3557 y(mo)n(v)n(ed)27 + b(to)g(basic)g(blo)r(c)n(k)g(B1.)0 3789 y Fp(B.3)112 + b(After)37 b(SSAPRE)f(P)m(ass)0 3943 y Fk(\045.LCASUM)k(=)j(internal)e + (global)g([17)h(x)h(sbyte])e(c"B\045d:)g(A)i(Sum)g(=)g(\045d\\0A\\00") + 170 b(;)43 b(<[17)f(x)h(sbyte]*>)e([#uses=1])0 4042 y(\045.LCBSUM)f(=)j + (internal)e(global)g([17)h(x)h(sbyte])e(c"B\045d:)g(B)i(Sum)g(=)g + (\045d\\0A\\00")170 b(;)43 b(<[17)f(x)h(sbyte]*>)e([#uses=1])0 + 4142 y(\045.LCCSUM)f(=)j(internal)e(global)g([17)h(x)h(sbyte])e + (c"B\045d:)g(C)i(Sum)g(=)g(\045d\\0A\\00")170 b(;)43 + b(<[17)f(x)h(sbyte]*>)e([#uses=1])0 4341 y(implementation)125 + b(;)43 b(Functions:)0 4540 y(declare)e(int)h(\045printf\(sbyte*,)37 + b(...\))0 4740 y(int)42 b(\045main\(int)e(\045argc,)h(sbyte**)g + (\045argv\))g({)0 4839 y(B1:)173 b(;)43 b(No)g(predecessors!)87 + 4939 y(\045x)g(=)g(cast)f(int)g(27)h(to)g(float)390 b(;)43 + b()d([#uses=1])87 5039 y(\045y)j(=)g(cast)f(int)g(3)h(to)g + (float)434 b(;)43 b()d([#uses=1])87 5138 y(\045r)j(=)g(cast)f + (int)g(927)h(to)f(float)347 b(;)43 b()d([#uses=1])87 + 5238 y(\045i0)i(=)i(cast)d(int)i(10)g(to)f(int)435 b(;)43 + b()e([#uses=2])87 5337 y(\045T_1)h(=)h(cast)f(int)g(\045i0)h(to)f + (int)348 b(;)43 b()e([#uses=2])1908 5589 y Fr(18)p + eop end + %%Page: 19 19 + TeXDict begin 19 18 bop 87 83 a Fk(\045asum0)41 b(=)i(cast)f(int)h(0)g + (to)f(int)348 b(;)43 b()e([#uses=2])87 183 y(\045T_2)h(=)h(cast)f + (int)g(\045asum0)f(to)i(int)217 b(;)43 b()e([#uses=2])87 + 282 y(\045LCASUM)g(=)i(getelementptr)38 b([17)k(x)h(sbyte]*)e + (\045.LCASUM,)f(long)i(0,)g(long)g(0)174 b(;)43 b()d([#uses=1]) + 87 382 y(\045LCBSUM)h(=)i(getelementptr)38 b([17)k(x)h(sbyte]*)e + (\045.LCBSUM,)f(long)i(0,)g(long)g(0)174 b(;)43 b()d([#uses=1]) + 87 482 y(\045LCCSUM)h(=)i(getelementptr)38 b([17)k(x)h(sbyte]*)e + (\045.LCCSUM,)f(long)i(0,)g(long)g(0)174 b(;)43 b()d([#uses=1]) + 87 581 y(\045z_clone_clone_c)o(lon)o(e)d(=)43 b(div)g(float)e(\045x,)h + (\045y)479 b(;)43 b()e([#uses=1])87 681 y(\045T_0)h(=)h(cast)f + (float)g(\045z_clone_clone_)o(cl)o(on)o(e)c(to)k(float)129 + b(;)43 b()e([#uses=1])87 780 y(br)i(label)e(\045B2)0 + 980 y(B2:)173 b(;)43 b(preds)f(=)h(\045B2_end.B2_crit)o(_ed)o(ge)o(,)37 + b(\045B1)87 1079 y(\045i2)42 b(=)i(phi)e(int)g([)h(\045i0,)f(\045B1)h + (],)f([)h(\045i1,)f(\045B2_end.B2_crit_e)o(dg)o(e)37 + b(])566 b(;)44 b()d([#uses=2])87 1179 y(\045asum2)g(=)i(phi)g(int) + f([)h(\045asum0,)e(\045B1)h(],)h([)g(\045asum1,)d(\045B2_end.B2_crit_e) + o(dg)o(e)e(])173 b(;)44 b()d([#uses=1])87 1279 y(\045bsum2)g(=)i + (phi)g(int)f([)h(\045T_2,)f(\045B1)g(],)h([)g(\045bsum1,)d + (\045B2_end.B2_crit_e)o(dg)o(e)d(])261 b(;)44 b()d([#uses=1])87 + 1378 y(\045csum2)g(=)i(phi)g(int)f([)h(\045T_2,)f(\045B1)g(],)h([)g + (\045csum1,)d(\045B2_end.B2_crit_e)o(dg)o(e)d(])261 b(;)44 + b()d([#uses=1])87 1478 y(\045a)i(=)g(mul)f(int)h(\045i2,)f(10)173 + b(;)43 b()f([#uses=1])87 1577 y(\045asum1)f(=)i(add)g(int)f + (\045asum2,)f(\045a)173 b(;)43 b()f([#uses=2])87 + 1677 y(br)h(label)e(\045B3)0 1876 y(B3:)173 b(;)43 b(preds)f(=)h + (\045B3_end.B3_crit)o(_ed)o(ge)o(,)37 b(\045B2)87 1976 + y(\045j2)42 b(=)i(phi)e(int)g([)h(\045T_1,)f(\045B2)g(],)h([)g(\045j1,) + f(\045B3_end.B3_crit_)o(ed)o(ge)37 b(])522 b(;)44 b()d([#uses=2]) + 87 2076 y(\045bsum3)g(=)i(phi)g(int)f([)h(\045bsum2,)e(\045B2)h(],)h([) + g(\045bsum1,)d(\045B3_end.B3_crit_e)o(dg)o(e)e(])173 + b(;)44 b()d([#uses=1])87 2175 y(\045csum3)g(=)i(phi)g(int)f([)h + (\045csum2,)e(\045B2)h(],)h([)g(\045csum1,)d(\045B3_end.B3_crit_e)o(dg) + o(e)e(])173 b(;)44 b()d([#uses=1])87 2275 y(\045b)i(=)g(mul)f(int) + h(\045j2,)f(10)434 b(;)44 b()d([#uses=1])87 2374 + y(\045bsum1)g(=)i(add)g(int)f(\045bsum3,)f(\045b)129 + b(;)44 b()d([#uses=3])87 2474 y(br)i(label)e(\045B4)0 + 2673 y(B4:)173 b(;)43 b(preds)f(=)h(\045B4.B4_crit_edg)o(e,)37 + b(\045B3)87 2773 y(\045k2)42 b(=)i(phi)e(int)g([)h(\045T_1,)f(\045B3)g + (],)h([)g(\045k1,)f(\045B4.B4_crit_edge)37 b(])522 b(;)43 + b()f([#uses=2])87 2873 y(\045csum4)f(=)i(phi)g(int)f([)h + (\045csum3,)e(\045B3)h(],)h([)g(\045csum1,)d(\045B4.B4_crit_edge)d(]) + 174 b(;)43 b()f([#uses=1])87 2972 y(\045q)h(=)g(mul)f(float)g + (\045r,)g(\045T_0)303 b(;)44 b()c([#uses=2])87 + 3072 y(\045c)j(=)g(mul)f(int)h(\045k2,)f(10)434 b(;)44 + b()d([#uses=1])87 3171 y(\045csum1)g(=)i(add)g(int)f(\045csum4,)f + (\045c)129 b(;)44 b()d([#uses=4])87 3271 y(\045k1)h(=)i(sub)e(int) + g(\045k2,)g(1)435 b(;)44 b()d([#uses=2])87 3371 + y(\045b4cond)g(=)i(setgt)e(int)i(\045k1,)f(0)173 b(;)44 + b()d([#uses=1])87 3470 y(br)i(bool)f(\045b4cond,)e(label)h + (\045B4.B4_crit_edge,)c(label)k(\045B3_end)0 3670 y(B4.B4_crit_edge:) + 168 b(;)43 b(preds)e(=)i(\045B4)87 3769 y(br)g(label)e(\045B4)0 + 3968 y(B3_end:)171 b(;)43 b(preds)f(=)h(\045B4)87 4068 + y(\045j1)f(=)i(sub)e(int)g(\045j2,)g(1)435 b(;)44 b()d([#uses=2]) + 87 4168 y(\045b3cond)g(=)i(setgt)e(int)i(\045j1,)f(0)173 + b(;)44 b()d([#uses=1])87 4267 y(br)i(bool)f(\045b3cond,)e(label)h + (\045B3_end.B3_crit_e)o(dg)o(e,)c(label)42 b(\045B2_end)0 + 4467 y(B3_end.B3_crit_e)o(dg)o(e:)168 b(;)43 b(preds)e(=)j(\045B3_end) + 87 4566 y(br)f(label)e(\045B3)0 4765 y(B2_end:)171 b(;)43 + b(preds)f(=)h(\045B3_end)87 4865 y(\045i1)f(=)i(sub)e(int)g(\045i2,)g + (1)435 b(;)44 b()d([#uses=2])87 4965 y(\045b2cond)g(=)i(setgt)e + (int)i(\045i1,)f(0)173 b(;)44 b()d([#uses=1])87 + 5064 y(br)i(bool)f(\045b2cond,)e(label)h(\045B2_end.B2_crit_e)o(dg)o + (e,)c(label)42 b(\045B_exit)0 5264 y(B2_end.B2_crit_e)o(dg)o(e:)168 + b(;)43 b(preds)e(=)j(\045B2_end)1908 5589 y Fr(19)p eop + end + %%Page: 20 20 + TeXDict begin 20 19 bop 87 83 a Fk(br)43 b(label)e(\045B2)0 + 282 y(B_exit:)171 b(;)43 b(preds)f(=)h(\045B2_end)87 + 382 y(\045q2)f(=)i(mul)e(float)f(\045q,)i(\045q)173 b(;)43 + b()e([#uses=0])87 482 y(call)h(int)g(\(sbyte*,)f(...\)*)g + (\045printf\()f(sbyte*)h(\045LCASUM,)f(int)j(8,)f(int)h(\045asum1)e(\)) + 174 b(;)43 b(:0)d([#uses=0])87 581 y(call)i(int)g(\(sbyte*,)f + (...\)*)g(\045printf\()f(sbyte*)h(\045LCBSUM,)f(int)j(8,)f(int)h + (\045bsum1)e(\))174 b(;)43 b(:1)d([#uses=0])87 681 + y(call)i(int)g(\(sbyte*,)f(...\)*)g(\045printf\()f(sbyte*)h + (\045LCCSUM,)f(int)j(8,)f(int)h(\045csum1)e(\))174 b(;)43 + b(:2)d([#uses=0])87 780 y(ret)i(int)h(0)0 880 y(})1908 + 5589 y Fr(20)p eop end + %%Page: 21 21 + TeXDict begin 21 20 bop 0 83 a Fs(C)131 b(The)44 b(Role)g(of)g + Fa(L)-7 b(ater)0 265 y Fr(In)35 b(the)g(pap)r(er,)h(they)f(discuss)g + (the)g(role)f(of)g(the)i Fq(later)44 b Fr(predicate)34 + b(on)g(a)h Fm(\010)g Fr(no)r(de.)58 b(In)35 b(essence,)h(a)e + Fm(\010)h Fr(no)r(de)g(can)g(satisfy)0 364 y Fq(down_safe)40 + b Fr(and)31 b Fq(c)l(an_b)l(e_avail)42 b Fr(but)33 b(if)f(it)h(also)e + (satis\034es)g Fq(later)p Fr(,)i(then)g(w)n(e)e(w)n(on't)h(use)g(that)g + Fm(\010)g Fr(to)g(insert)g(expressions.)0 464 y(Doing)e(so)g(w)n(ould)g + (not)g(eliminate)h(an)n(y)e(redundancies)h(and)g(w)n(ould)g + (unnecessarily)f(extend)i(the)g(liv)n(e)f(range)f(of)h(the)h(tem-)0 + 564 y(p)r(orary)26 b(v)-5 b(ariable.[1)n(])28 b(The)g(example)f(giv)n + (en)f(here)i(mo)r(dels)f(the)h(CF)n(G)g(giv)n(en)e(in)i(the)g(pap)r(er) + f(\([1])h(Fig.)36 b(9\).)0 796 y Fp(C.1)112 b(Before)37 + b(SSAPRE)g(P)m(ass)0 949 y Fk(implementation)125 b(;)43 + b(Functions:)0 1149 y(int)f(\045main\(int)e(\045argc,)h(sbyte**)g + (\045argv\))g({)0 1248 y(BBegin:)87 1348 y(\045a1)h(=)i(cast)d(int)i + (37)g(to)f(int)87 1447 y(\045b1)g(=)i(cast)d(int)i(27)g(to)f(int)87 + 1547 y(\045cond)g(=)h(setle)e(int)i(\045argc,)e(2)87 + 1647 y(br)i(bool)f(\045cond,)f(label)g(\045B1,)h(label)g(\045B0)0 + 1846 y(B0:)87 1946 y(\045bb0cond)e(=)j(setle)f(int)g(\045argc,)f(3)87 + 2045 y(br)i(bool)f(\045bb0cond,)e(label)h(\045B3,)h(label)f(\045B2)0 + 2244 y(B1:)87 2344 y(\045x0)h(=)i(add)e(int)g(\045a1,)g(\045b1)87 + 2444 y(br)h(label)e(\045B3)0 2643 y(B2:)87 2743 y(;;)i(If)g(later)e + (were)h(false)f(for)i(the)f(PHI)g(node)g(in)h(B5,)f(we)h(would)e + (expect)g(an)87 2842 y(;;)i(inserted)d(computation)f(of)k(a)g(+)g(b)g + (here.)87 2942 y(\045a2)f(=)i(cast)d(int)i(927)f(to)h(int)87 + 3041 y(br)g(label)e(\045B5)0 3241 y(B3:)87 3340 y(;;)i(Expect)e(PHI)h + (node)g(here)g(for)g(the)h(expr)e(in)i(B1)87 3440 y(\045bb3cond)d(=)j + (seteq)f(int)g(\045argc,)f(2)87 3540 y(br)i(bool)f(\045bb3cond,)e + (label)h(\045BExit,)g(label)g(\045B4)0 3739 y(B4:)87 + 3838 y(;;)i(If)g(later)e(were)h(false)f(for)i(the)f(PHI)g(node)g(in)h + (B5,)f(we)h(would)e(expect)g(an)87 3938 y(;;)i(inserted)d(computation)f + (of)k(a)g(+)g(b)g(here.)87 4038 y(br)g(label)e(\045B5)0 + 4237 y(B5:)87 4337 y(;;)i(Expect)e(PHI)h(node)g(here)g(for)g(the)h + (expr)e(in)i(B1)87 4436 y(\045a3)f(=)i(phi)e(int)g([)h(\045a1,)f + (\045B4)h(],)f([)h(\045a2,)f(\045B2)h(],)f([)h(\045a3,)f(\045B5)h(])87 + 4536 y(\045bb4cond)d(=)j(seteq)f(int)g(\045argc,)f(0)87 + 4636 y(br)i(bool)f(\045bb4cond,)e(label)h(\045B6,)h(label)f(\045B5)0 + 4835 y(B6:)87 4934 y(\045x1)h(=)i(add)e(int)g(\045a3,)g(\045b1)87 + 5034 y(br)h(label)e(\045BExit)0 5233 y(BExit:)87 5333 + y(ret)h(int)h(0)1908 5589 y Fr(21)p eop end + %%Page: 22 22 + TeXDict begin 22 21 bop 0 83 a Fk(})0 315 y Fp(C.2)112 + b(Exp)s(ected)37 b(Results)0 469 y Fr(W)-7 b(e)25 b(exp)r(ect)g(none)f + (of)g(the)h(the)g Fk(add)42 b(int)g(\045a,)h(\045b)f + Fr(expressions)23 b(to)h(b)r(e)h(mo)n(v)n(ed)e(since)i(the)g + Fm(\010)f Fr(in)h Fk(B3)42 b Fr(isn't)25 b Fq(down_safe)32 + b Fr(and)0 568 y(the)c Fm(\010)g Fr(in)f Fk(B5)43 b Fr(satis\034es)27 + b Fq(later)p Fr(.)37 b(As)28 b(sho)n(wn)f(in)g(the)h(next)g(section,)f + (that)h(is)g(what)f(o)r(ccurs.)0 801 y Fp(C.3)112 b(After)37 + b(SSAPRE)f(P)m(ass)0 954 y Fk(implementation)125 b(;)43 + b(Functions:)0 1153 y(int)f(\045main\(int)e(\045argc,)h(sbyte**)g + (\045argv\))g({)0 1253 y(BBegin:)171 b(;)43 b(No)g(predecessors!)87 + 1352 y(\045a1)f(=)i(cast)d(int)i(37)g(to)f(int)260 b(;)44 + b()d([#uses=2])87 1452 y(\045b1)h(=)i(cast)d(int)i(27)g(to)f(int) + 260 b(;)44 b()d([#uses=2])87 1552 y(\045cond)h(=)h(setle)e(int)i + (\045argc,)e(2)173 b(;)44 b()d([#uses=1])87 1651 + y(br)i(bool)f(\045cond,)f(label)g(\045B1,)h(label)g(\045B0)0 + 1851 y(B0:)173 b(;)43 b(preds)f(=)h(\045BBegin)87 1950 + y(\045bb0cond)d(=)j(setle)f(int)g(\045argc,)f(3)i(;)h()d + ([#uses=1])87 2050 y(br)i(bool)f(\045bb0cond,)e(label)h + (\045B0.B3_crit_edge)o(,)c(label)42 b(\045B2)0 2249 y(B0.B3_crit_edge:) + 168 b(;)43 b(preds)e(=)i(\045B0)87 2349 y(br)g(label)e(\045B3)0 + 2548 y(B1:)173 b(;)43 b(preds)f(=)h(\045BBegin)87 2648 + y(\045x0)f(=)i(add)e(int)g(\045a1,)g(\045b1)173 b(;)43 + b()f([#uses=0])87 2747 y(br)h(label)e(\045B3)0 2946 + y(B2:)173 b(;)43 b(preds)f(=)h(\045B0)87 3046 y(\045a2)f(=)i(cast)d + (int)i(927)f(to)h(int)739 b(;)43 b()f([#uses=1])87 + 3146 y(\045bb4cond_clone1)37 b(=)44 b(seteq)d(int)h(\045argc,)f(0)261 + b(;)43 b()f([#uses=1])87 3245 y(\045T_2)g(=)h(cast)f(bool)g + (\045bb4cond_clone1)37 b(to)43 b(bool)85 b(;)43 b()f([#uses=1])87 + 3345 y(br)h(label)e(\045B5)0 3544 y(B3:)173 b(;)43 b(preds)f(=)h + (\045B1,)f(\045B0.B3_crit_edg)o(e)87 3644 y(\045bb3cond)e(=)j(seteq)f + (int)g(\045argc,)f(2)174 b(;)43 b()e([#uses=1])87 + 3743 y(br)i(bool)f(\045bb3cond,)e(label)h(\045B3.BExit_crit_e)o(dg)o + (e,)c(label)42 b(\045B4)0 3943 y(B3.BExit_crit_ed)o(ge)o(:)168 + b(;)43 b(preds)f(=)h(\045B3)87 4042 y(br)g(label)e(\045BExit)0 + 4242 y(B4:)173 b(;)43 b(preds)f(=)h(\045B3)87 4341 y(\045bb4cond_clone) + 38 b(=)43 b(seteq)e(int)i(\045argc,)e(0)304 b(;)43 b()f + ([#uses=1])87 4441 y(\045T_0)g(=)h(cast)f(bool)g(\045bb4cond_clone)c + (to)k(bool)129 b(;)43 b()f([#uses=1])87 4540 y(br)h(label)e + (\045B5)0 4740 y(B5:)173 b(;)43 b(preds)f(=)h(\045B5.B5_crit_edg)o(e,) + 37 b(\045B4,)42 b(\045B2)87 4839 y(\045a3)g(=)i(phi)e(int)g([)h + (\045a1,)f(\045B4)h(],)f([)h(\045a2,)f(\045B2)h(],)f([)h(\045a3,)f + (\045B5.B5_crit_edge)37 b(])305 b(;)43 b()e([#uses=2])87 + 4939 y(\045T_1)h(=)h(phi)f(bool)g([)i(\045T_0,)d(\045B4)h(],)h([)g + (\045T_2,)f(\045B2)g(],)h([)g(\045T_1,)e(\045B5.B5_crit_edge)c(])87 + b(;)43 b()e([#uses=2])87 5039 y(br)i(bool)f(\045T_1,)f(label)h + (\045B6,)g(label)f(\045B5.B5_crit_edge)0 5238 y(B5.B5_crit_edge:)168 + b(;)43 b(preds)e(=)i(\045B5)87 5337 y(br)g(label)e(\045B5)1908 + 5589 y Fr(22)p eop end + %%Page: 23 23 + TeXDict begin 23 22 bop 0 183 a Fk(B6:)173 b(;)43 b(preds)f(=)h(\045B5) + 87 282 y(\045x1)f(=)i(add)e(int)g(\045a3,)g(\045b1)173 + b(;)43 b()f([#uses=0])87 382 y(br)h(label)e(\045BExit)0 + 581 y(BExit:)172 b(;)43 b(preds)e(=)j(\045B6,)d(\045B3.BExit_crit_ed)o + (ge)87 681 y(ret)h(int)h(0)0 780 y(})1908 5589 y Fr(23)p + eop end + %%Trailer + + userdict /end-hook known{end-hook}if + %%EOF From lattner at cs.uiuc.edu Mon Dec 15 14:47:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 14:47:01 2003 Subject: [llvm-commits] CVS: llvm-www/ProjectsWithLLVM/index.html Message-ID: <200312152046.OAA12559@zion.cs.uiuc.edu> Changes in directory llvm-www/ProjectsWithLLVM: index.html updated: 1.2 -> 1.3 --- Log message: Add entry for the SSAPRE project --- Diffs of the changes: (+16 -1) Index: llvm-www/ProjectsWithLLVM/index.html diff -u llvm-www/ProjectsWithLLVM/index.html:1.2 llvm-www/ProjectsWithLLVM/index.html:1.3 --- llvm-www/ProjectsWithLLVM/index.html:1.2 Fri Dec 12 17:14:02 2003 +++ llvm-www/ProjectsWithLLVM/index.html Mon Dec 15 14:46:42 2003 @@ -64,7 +64,22 @@
CS426: Advanced Compilers (Fall 2002)
-

+ +
+Jello: a retargetable Just-In-Time compiler for + LLVM bytecode
+Tanya Brethour, +Joel Stanley, Bill Wendling +
+ +

+"In this report we present implementation details, empirical performance data, and notable modifications to an algorithm for PRE based on [the 1999 TOPLAS SSAPRE paper]. In [the 1999 TOPLAS SSAPRE paper], a particular realization of PRE, known as SSAPRE, is described, which is more efficient than traditional PRE implementations because it relies on useful properties of Static Single-Assignment (SSA) form to perform dataflow analysis in a much more sparse manner than the traditional bit-vector-based approach. Our implementation is specific to a SSA-based compiler infrastructure know as LLVM (Low-Level Virtual Machine)." +

+ +

+Project report: PS, +PDF +

CS497CZ: Dynamic Translation and Optimization (Spring 2002)
From lattner at cs.uiuc.edu Mon Dec 15 14:56:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 14:56:01 2003 Subject: [llvm-commits] CVS: llvm-www/ProjectsWithLLVM/index.html Message-ID: <200312152055.OAA12820@zion.cs.uiuc.edu> Changes in directory llvm-www/ProjectsWithLLVM: index.html updated: 1.3 -> 1.4 --- Log message: Uhh, whoops. Fix the project title --- Diffs of the changes: (+1 -2) Index: llvm-www/ProjectsWithLLVM/index.html diff -u llvm-www/ProjectsWithLLVM/index.html:1.3 llvm-www/ProjectsWithLLVM/index.html:1.4 --- llvm-www/ProjectsWithLLVM/index.html:1.3 Mon Dec 15 14:46:42 2003 +++ llvm-www/ProjectsWithLLVM/index.html Mon Dec 15 14:55:29 2003 @@ -66,8 +66,7 @@
-Jello: a retargetable Just-In-Time compiler for - LLVM bytecode
+An LLVM Implementation of SSAPRE
Tanya Brethour, Joel Stanley, Bill Wendling
From criswell at cs.uiuc.edu Mon Dec 15 15:06:06 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Mon Dec 15 15:06:06 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/ReleaseNotes.html Message-ID: <200312152105.PAA25033@choi.cs.uiuc.edu> Changes in directory llvm/docs: ReleaseNotes.html updated: 1.82.2.3 -> 1.82.2.4 --- Log message: Grammatical and punctuation corrections. --- Diffs of the changes: (+35 -30) Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.82.2.3 llvm/docs/ReleaseNotes.html:1.82.2.4 --- llvm/docs/ReleaseNotes.html:1.82.2.3 Fri Dec 12 17:21:29 2003 +++ llvm/docs/ReleaseNotes.html Mon Dec 15 15:05:22 2003 @@ -40,10 +40,10 @@

This document contains the release notes for the LLVM compiler infrastructure, release 1.1. Here we describe the status of LLVM, including any -known problems, and bug fixes from the previous release. The most up-to-date +known problems and bug fixes from the previous release. The most up-to-date version of this document can be found on the LLVM 1.1 web site. If you are -not reading this on the LLVM web pages, you should probably go there, because +not reading this on the LLVM web pages, you should probably go there because this document may be updated after the release.

For more information about LLVM, including information about potentially more @@ -69,7 +69,7 @@

This is the second public release of the LLVM compiler infrastructure. This release is primarily a bugfix release, dramatically improving the C/C++ -front-end, and improving support for C++ in the LLVM core. This release also +front-end and improving support for C++ in the LLVM core. This release also includes a few new features, such as a simple profiler, support for Mac OS X, better interoperability with external source bases, a new example language front-end, and improvements in a few optimizations. The performance of several @@ -84,10 +84,10 @@

-The LLVM native code generators are very stable, but do not currently support +The LLVM native code generators are very stable but do not currently support unwinding (exception throwing or longjmping), which prevent them from working with programs like the 253.perlbmk in SPEC CPU2000. The C -backend and the rest of LLVM does support these programs however, so you can +backend and the rest of LLVM supports these programs, so you can still use LLVM with them. Support for unwinding will be added in a future release.

@@ -101,7 +101,7 @@
  1. A new -LLVM profiler, similar to gprof is available
  2. +LLVM profiler, similar to gprof, is available.
  3. LLVM and the C/C++ front-end now compile on Mac OS X! Mac OS X users can now explore the LLVM optimizer with the C backend and interpreter. Note that @@ -109,7 +109,7 @@
  4. LLVM has been moved -into an 'llvm' C++ namespace, for easier integration with third-party +into an 'llvm' C++ namespace for easier integration with third-party code. Note that due to lack of namespace support in GDB 5.x, you will probably want to upgrade to GDB 6 or better to debug LLVM code.
  5. @@ -119,7 +119,8 @@
    1. New directories can be added to the source tree, and the build will - automatically pick them up (i.e. no need to re-run configure). + automatically pick them up (i.e. no need to edit configure.ac and + re-run configure).
    2. @@ -131,7 +132,9 @@
    3. A front-end for "Stacker" (a simple Forth-like language) is now included in the main LLVM tree. - Additionally, Reid Spencer, the author, contributed a document describing his experiences writing Stacker, and the language itself. This document is invaluable for others writing front-ends targetting LLVM.
    4. + Additionally, Reid Spencer, the author, contributed a document + describing his experiences writing Stacker and the language itself. + This document is invaluable for others writing front-ends targetting LLVM.
    5. The configure script will now configure all projects placed in the llvm/projects directory.
    6. @@ -142,12 +145,12 @@
    7. The -licm pass can now sink instructions out the bottom of loops in addition to being able to hoist them out the top.
    8. -
    9. The -basicaa pass (the default alias analysis) has been upgraded -to be significantly more +
    10. The -basicaa pass (the default alias analysis pass) has been +upgraded to be significantly more precise.
    11. LLVM 1.1 implements a simple size optimization for LLVM bytecode files. - This means that the 1.1 files are smaller than 1.0, but that 1.0 won't + This means that the 1.1 files are smaller than 1.0, but LLVM 1.0 won't read 1.1 bytecode files.
    12. The gccld program produces a runner script that includes command-line options to load the necessary shared objects.
    13. @@ -187,12 +190,12 @@ more, giving the optimizer more freedom.
    14. The C front-end now generates - type-safe code in several cases that it did not before, which prevented - some important optimizations.
    15. + type-safe code in several cases that it did not before, allowing + optimization of code that could not be optimized previously.
    16. The LLVM build system has been taught to catch some common configuration problems that caused it to get - horribly confused before.
    17. + horribly confused.
    18. The LLVM header files are now -Wold-style-cast clean.
    19. @@ -209,8 +212,9 @@ generated N^2 amounts of duplicated cleanup code in some cases.
    20. The JIT used to generate code for - all functions pointed to by globals immediately, before the program - started execution, but now it waits until the first time they are called to + all functions pointed to by globals before the program + started execution. Now, it waits until the first time the functions are + called to compile them. This dramatically speeds up short runs of large C++ programs, which often have large numbers of functions pointed to by vtables.
    @@ -232,7 +236,7 @@
  6. llvm-as crashes when labels are used in phi nodes
  7. [build problem] Callgraph.cpp not pulled in from libipa.a
  8. Variables in scope of output setjmp -calls should be volatile (Note that this does not effect correctness on +calls should be volatile (Note that this does not affect correctness on many platforms, such as X86).
  9. [X86] Emission of global bool initializers broken
  10. [gccld] The -r (relinking) option does not work correctly
  11. @@ -307,7 +311,7 @@ interpreter (no native backend for the PowerPC is available yet). The core LLVM infrastructure uses "autoconf" for portability, so hopefully we work on more platforms than that. However, it is likely that we -missed something, and that minor porting is required to get LLVM to work on +missed something and that minor porting is required to get LLVM to work on new platforms. We welcome portability patches and error messages.

    @@ -323,7 +327,7 @@

    This section contains all known problems with the LLVM system, listed by component. As new problems are discovered, they will be added to these sections. If you run into a problem, please check the LLVM bug database, and submit a bug if +href="http://llvm.cs.uiuc.edu/bugs/">LLVM bug database and submit a bug if there isn't already one.

    @@ -418,11 +422,11 @@ the following extensions are known to not be supported:
    1. Local Labels: Labels local to a block.
    2. -
    3. Labels as Values: Getting pointers to labels, and computed gotos.
    4. +
    5. Labels as Values: Getting pointers to labels and computed gotos.
    6. Nested Functions: As in Algol and Pascal, lexical scoping of functions.
    7. Constructing Calls: Dispatching a call to another function.
    8. Extended Asm: Assembler instructions with C expressions as operands.
    9. -
    10. Constraints: Constraints for asm operands
    11. +
    12. Constraints: Constraints for asm operands.
    13. Asm Labels: Specifying the assembler name to use for a C symbol.
    14. Explicit Reg Vars: Defining variables residing in specified registers.
    15. Return Address: Getting the return or frame address of a function.
    16. @@ -435,7 +439,7 @@

      The following GCC extensions are partially supported. An ignored attribute means that the LLVM compiler ignores the presence of the attribute, but the code should still work. An unsupported attribute is one which is - ignored by the LLVM compiler, which will cause a different interpretation of + ignored by the LLVM compiler and will cause a different interpretation of the program.

        @@ -445,7 +449,7 @@
      1. Function Attributes: - Declaring that functions have no side effects, or that they can never + Declaring that functions have no side effects or that they can never return.
        Supported: format, format_arg, non_null, @@ -504,7 +508,8 @@
      2. Subscripting: Any array can be subscripted, even if not an lvalue.
      3. Pointer Arith: Arithmetic on void-pointers and function pointers.
      4. Initializers: Non-constant initializers.
      5. -
      6. Compound Literals: Compound literals give structures, unions or arrays as values.
      7. +
      8. Compound Literals: Compound literals give structures, unions, +or arrays as values.
      9. Designated Inits: Labeling elements of initializers.
      10. Cast to Union: Casting to union type from any member of the union.
      11. Case Ranges: `case 1 ... 9' and such.
      12. @@ -536,7 +541,7 @@
        -

        For this release, the C++ front-end is considered to be fully functional, but +

        For this release, the C++ front-end is considered to be fully functional but has not been tested as thoroughly as the C front-end. It has been tested and works for a number of non-trivial programs, but there may be lurking bugs. Please report any bugs or problems.

        @@ -552,7 +557,7 @@
        • The C++ front-end inherits all problems afflicting the C - front-end
        • + front-end.
        @@ -574,7 +579,7 @@
      13. Destructors for local objects are not always run when a longjmp is performed. In particular, destructors for objects in the longjmping function and in the setjmp receiver function may not be run. - Objects in intervening stack frames will be destroyed however (which is + Objects in intervening stack frames will be destroyed, however (which is better than most compilers).
      14. The LLVM C++ front-end follows the

        A wide variety of additional information is available on the LLVM web page, -including mailing lists publications describing algorithms and components +including mailing lists and publications describing algorithms and components implemented in LLVM. The web page also contains versions of the API documentation which is up-to-date with the CVS version of the source code. You can access versions of these documents specific to this release by going into @@ -685,7 +690,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/12 23:21:29 $ + Last modified: $Date: 2003/12/15 21:05:22 $ From brukman at cs.uiuc.edu Mon Dec 15 15:36:02 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Mon Dec 15 15:36:02 2003 Subject: [llvm-commits] CVS: llvm-www/ProjectsWithLLVM/index.html Message-ID: <200312152135.PAA17849@zion.cs.uiuc.edu> Changes in directory llvm-www/ProjectsWithLLVM: index.html updated: 1.4 -> 1.5 --- Log message: * Wrap text at 80 columns * Fix grammar "know as" => "known as" --- Diffs of the changes: (+9 -1) Index: llvm-www/ProjectsWithLLVM/index.html diff -u llvm-www/ProjectsWithLLVM/index.html:1.4 llvm-www/ProjectsWithLLVM/index.html:1.5 --- llvm-www/ProjectsWithLLVM/index.html:1.4 Mon Dec 15 14:55:29 2003 +++ llvm-www/ProjectsWithLLVM/index.html Mon Dec 15 15:34:53 2003 @@ -72,7 +72,15 @@

        -"In this report we present implementation details, empirical performance data, and notable modifications to an algorithm for PRE based on [the 1999 TOPLAS SSAPRE paper]. In [the 1999 TOPLAS SSAPRE paper], a particular realization of PRE, known as SSAPRE, is described, which is more efficient than traditional PRE implementations because it relies on useful properties of Static Single-Assignment (SSA) form to perform dataflow analysis in a much more sparse manner than the traditional bit-vector-based approach. Our implementation is specific to a SSA-based compiler infrastructure know as LLVM (Low-Level Virtual Machine)." +"In this report we present implementation details, empirical performance data, +and notable modifications to an algorithm for PRE based on [the 1999 TOPLAS +SSAPRE paper]. In [the 1999 TOPLAS SSAPRE paper], a particular realization of +PRE, known as SSAPRE, is described, which is more efficient than traditional PRE +implementations because it relies on useful properties of Static +Single-Assignment (SSA) form to perform dataflow analysis in a much more sparse +manner than the traditional bit-vector-based approach. Our implementation is +specific to a SSA-based compiler infrastructure known as LLVM (Low-Level Virtual +Machine)."

        From criswell at cs.uiuc.edu Mon Dec 15 16:14:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Mon Dec 15 16:14:02 2003 Subject: [llvm-commits] [release_11] CVS: llvm/configure Message-ID: <200312152212.QAA32507@choi.cs.uiuc.edu> Changes in directory llvm: configure updated: 1.61 -> 1.61.2.1 --- Log message: Updated version number to 1.1. Thanks, Chris! --- Diffs of the changes: (+9 -9) Index: llvm/configure diff -u llvm/configure:1.61 llvm/configure:1.61.2.1 --- llvm/configure:1.61 Fri Dec 12 14:15:23 2003 +++ llvm/configure Mon Dec 15 16:12:47 2003 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.57 for [LLVM] [1.0]. +# Generated by GNU Autoconf 2.57 for [LLVM] [1.1]. # # Report bugs to . # @@ -422,8 +422,8 @@ # Identity of this package. PACKAGE_NAME='[LLVM]' PACKAGE_TARNAME='--llvm--' -PACKAGE_VERSION='[1.0]' -PACKAGE_STRING='[LLVM] [1.0]' +PACKAGE_VERSION='[1.1]' +PACKAGE_STRING='[LLVM] [1.1]' PACKAGE_BUGREPORT='llvmbugs at cs.uiuc.edu' ac_subdirs_all="$ac_subdirs_all projects/${i}" @@ -954,7 +954,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures [LLVM] [1.0] to adapt to many kinds of systems. +\`configure' configures [LLVM] [1.1] to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1016,7 +1016,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of [LLVM] [1.0]:";; + short | recursive ) echo "Configuration of [LLVM] [1.1]:";; esac cat <<\_ACEOF @@ -1131,7 +1131,7 @@ test -n "$ac_init_help" && exit 0 if $ac_init_version; then cat <<\_ACEOF -[LLVM] configure [1.0] +[LLVM] configure [1.1] generated by GNU Autoconf 2.57 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 @@ -1146,7 +1146,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by [LLVM] $as_me [1.0], which was +It was created by [LLVM] $as_me [1.1], which was generated by GNU Autoconf 2.57. Invocation command line was $ $0 $@ @@ -23279,7 +23279,7 @@ } >&5 cat >&5 <<_CSEOF -This file was extended by [LLVM] $as_me [1.0], which was +This file was extended by [LLVM] $as_me [1.1], which was generated by GNU Autoconf 2.57. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -23342,7 +23342,7 @@ cat >>$CONFIG_STATUS <<_ACEOF ac_cs_version="\\ -[LLVM] config.status [1.0] +[LLVM] config.status [1.1] configured by $0, generated by GNU Autoconf 2.57, with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" From criswell at cs.uiuc.edu Mon Dec 15 16:14:05 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Mon Dec 15 16:14:05 2003 Subject: [llvm-commits] [release_11] CVS: llvm/autoconf/configure.ac Message-ID: <200312152213.QAA32514@choi.cs.uiuc.edu> Changes in directory llvm/autoconf: configure.ac updated: 1.61 -> 1.61.2.1 --- Log message: Updated version number to 1.1. Thanks, Chris! --- Diffs of the changes: (+1 -1) Index: llvm/autoconf/configure.ac diff -u llvm/autoconf/configure.ac:1.61 llvm/autoconf/configure.ac:1.61.2.1 --- llvm/autoconf/configure.ac:1.61 Fri Dec 12 14:09:33 2003 +++ llvm/autoconf/configure.ac Mon Dec 15 16:12:50 2003 @@ -15,7 +15,7 @@ dnl ************************************************************************** dnl * Initialize dnl ************************************************************************** -AC_INIT([[[LLVM]]],[[[1.0]]],[llvmbugs at cs.uiuc.edu]) +AC_INIT([[[LLVM]]],[[[1.1]]],[llvmbugs at cs.uiuc.edu]) dnl Place all of the extra autoconf files into the config subdirectory AC_CONFIG_AUX_DIR([autoconf]) From brukman at cs.uiuc.edu Mon Dec 15 16:24:01 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Mon Dec 15 16:24:01 2003 Subject: [llvm-commits] CVS: llvm-www/Documentation.html Message-ID: <200312152223.QAA32489@zion.cs.uiuc.edu> Changes in directory llvm-www: Documentation.html updated: 1.2 -> 1.3 --- Log message: * Deleted spurious whitespace, make HTML easier to read * Converted to
        * Closed
      15. tags --- Diffs of the changes: (+103 -121) Index: llvm-www/Documentation.html diff -u llvm-www/Documentation.html:1.2 llvm-www/Documentation.html:1.3 --- llvm-www/Documentation.html:1.2 Mon Nov 24 21:30:29 2003 +++ llvm-www/Documentation.html Mon Dec 15 16:23:41 2003 @@ -1,130 +1,112 @@
        LLVM Documentation
        - LLVM Design: +LLVM Design: - - - LLVM User Guides: - -
          -
        • - The LLVM Getting Started Guide - - - Discusses how to get up and running - quickly with the LLVM infrastructure. - Everything from unpacking and - compilation of the distribution to - execution of some tools.
        • - -
        • LLVM Command Guide - - A reference manual for the LLVM command line - utilities ("man" pages for LLVM tools).
        • - -
        • LLVM Project Guide - - How-to guide and templates for new - projects that use the LLVM infrastructure. - The templates (directory organization, Makefiles, - and test tree) allow the project code to be located - outside (or inside) the llvm/ tree, - while using LLVM header files and libraries.
        • - -
        • How to Submit A Bug - Report - Instructions for properly submitting information - about any bugs you run into in the LLVM system.
        • - -
        • LLVM Test Suite Guide - - A reference manual for using the LLVM test suite.
        • - -
        • How to build the C/C++ - front-end - Instructions for building the front-end - from source.
        • -
        - - Programming Documentation: - -
      16. - -
        LLVM Support
        - -

        +

      17. CVSWeb CVS Tree Browser
      18. + + + +
        + LLVM Support +
        +
        + + From brukman at cs.uiuc.edu Mon Dec 15 16:34:03 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Mon Dec 15 16:34:03 2003 Subject: [llvm-commits] CVS: llvm/runtime/GCCLibraries/libc/memory.c Message-ID: <200312152233.QAA10666@zion.cs.uiuc.edu> Changes in directory llvm/runtime/GCCLibraries/libc: memory.c updated: 1.2 -> 1.3 --- Log message: Make all memory functions have weak linkage so that they can be overridden with custom memory-management implementations (e.g., bash). --- Diffs of the changes: (+4 -3) Index: llvm/runtime/GCCLibraries/libc/memory.c diff -u llvm/runtime/GCCLibraries/libc/memory.c:1.2 llvm/runtime/GCCLibraries/libc/memory.c:1.3 --- llvm/runtime/GCCLibraries/libc/memory.c:1.2 Wed Jul 17 19:15:29 2002 +++ llvm/runtime/GCCLibraries/libc/memory.c Mon Dec 15 16:32:50 2003 @@ -6,9 +6,10 @@ #include -void *malloc(size_t); -void free(void *); -void *memset(void *, int, size_t); +void *malloc(size_t) __attribute__((weak)); +void free(void *) __attribute__((weak)); +void *memset(void *, int, size_t) __attribute__((weak)); +void *calloc(size_t nelem, size_t elsize) __attribute__((weak)); void *calloc(size_t nelem, size_t elsize) { void *Result = malloc(nelem*elsize); From brukman at cs.uiuc.edu Mon Dec 15 16:49:02 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Mon Dec 15 16:49:02 2003 Subject: [llvm-commits] CVS: llvm/docs/ReleaseNotes.html Message-ID: <200312152248.QAA15842@zion.cs.uiuc.edu> Changes in directory llvm/docs: ReleaseNotes.html updated: 1.85 -> 1.86 --- Log message: Added info about PR186: weak linkage on memory functions. --- Diffs of the changes: (+5 -3) Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.85 llvm/docs/ReleaseNotes.html:1.86 --- llvm/docs/ReleaseNotes.html:1.85 Sat Dec 13 23:03:43 2003 +++ llvm/docs/ReleaseNotes.html Mon Dec 15 16:48:12 2003 @@ -135,7 +135,8 @@

        Bugs in the LLVM Core:

          -
        1. [licm] LICM promotes volatile memory locations to registers
        2. +
        3. [licm] LICM promotes volatile memory +locations to registers
        @@ -143,7 +144,8 @@

        Bugs in the C/C++ front-end:

          -
        1. +
        2. Need weak linkage on memory +management functions in libc runtime to allow them to be overriden
        @@ -540,7 +542,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/14 05:03:43 $ + Last modified: $Date: 2003/12/15 22:48:12 $ From brukman at cs.uiuc.edu Mon Dec 15 16:59:03 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Mon Dec 15 16:59:03 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/ReleaseNotes.html Message-ID: <200312152257.QAA20837@zion.cs.uiuc.edu> Changes in directory llvm/docs: ReleaseNotes.html updated: 1.82.2.4 -> 1.82.2.5 --- Log message: * Unbroke our HTML-4.01 compliance! * Added note about PR186: present in 1.1, fixed in 1.2 --- Diffs of the changes: (+13 -5) Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.82.2.4 llvm/docs/ReleaseNotes.html:1.82.2.5 --- llvm/docs/ReleaseNotes.html:1.82.2.4 Mon Dec 15 15:05:22 2003 +++ llvm/docs/ReleaseNotes.html Mon Dec 15 16:57:49 2003 @@ -187,7 +187,7 @@
      19. The C++ front-end now compiles functions to use the linkonce linkage type - more, giving the optimizer more freedom.
      20. + more, giving the optimizer more freedom.
      21. The C front-end now generates type-safe code in several cases that it did not before, allowing @@ -377,9 +377,7 @@
        -
          -
        • C99 Variable sized arrays do not release stack memory when they go out of scope. Thus, the following program may run out of stack space:
          @@ -388,9 +386,19 @@
                 foo(X);
               }
           
        • -
        +
        + +
        + Bugs in 1.1 fixed in 1.2 +
        + @@ -690,7 +698,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/15 21:05:22 $ + Last modified: $Date: 2003/12/15 22:57:49 $ From criswell at cs.uiuc.edu Mon Dec 15 17:05:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Mon Dec 15 17:05:01 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/ReleaseNotes.html Message-ID: <200312152304.RAA25065@choi.cs.uiuc.edu> Changes in directory llvm/docs: ReleaseNotes.html updated: 1.82.2.5 -> 1.82.2.6 --- Log message: Added all known bugs that are relevant and relatively concrete. --- Diffs of the changes: (+44 -13) Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.82.2.5 llvm/docs/ReleaseNotes.html:1.82.2.6 --- llvm/docs/ReleaseNotes.html:1.82.2.5 Mon Dec 15 16:57:49 2003 +++ llvm/docs/ReleaseNotes.html Mon Dec 15 17:04:43 2003 @@ -362,6 +362,18 @@
      22. LLVM cannot handle structures with more than 256 elements.
      23. +
      24. +The gccld program + +does not link objects/archives in the order specified on the command line. + +
      25. + +
      26. + +Tail duplication does not update SSA form correctly. + +
      27. @@ -386,18 +398,27 @@ foo(X); } - - - -
        - Bugs in 1.1 fixed in 1.2 -
        - @@ -566,8 +587,13 @@
        • The C++ front-end inherits all problems afflicting the C front-end.
        • -
        +
      28. + +Code is generated for empty classes. + +
      29. + @@ -637,6 +663,11 @@ support the unwind instruction, so code that throws a C++ exception or calls the C longjmp function will abort. +
      30. + +The llc program can crash on legal code. + +
      31. @@ -698,7 +729,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/15 22:57:49 $ + Last modified: $Date: 2003/12/15 23:04:43 $ From criswell at cs.uiuc.edu Mon Dec 15 17:09:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Mon Dec 15 17:09:02 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/ReleaseNotes.html Message-ID: <200312152308.RAA25197@choi.cs.uiuc.edu> Changes in directory llvm/docs: ReleaseNotes.html updated: 1.82.2.6 -> 1.82.2.7 --- Log message: Fixed a minor spelling error. --- Diffs of the changes: (+2 -2) Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.82.2.6 llvm/docs/ReleaseNotes.html:1.82.2.7 --- llvm/docs/ReleaseNotes.html:1.82.2.6 Mon Dec 15 17:04:43 2003 +++ llvm/docs/ReleaseNotes.html Mon Dec 15 17:08:32 2003 @@ -272,7 +272,7 @@
      32. CFrontend crashes when compiling C99 compound expressions
      33. llvm-gcc infinite loops on "case MAXINT:"
      34. [C++] Catch blocks make unparsable labels
      35. -
      36. [C++] Initializing array with constructable objects fail
      37. +
      38. [C++] Initializing array with constructible objects fail
      39. llvm-gcc tries to add bools
      40. [c++] C++ Frontend lays out superclasses like anonymous bitfields!
      41. C front-end miscompiles unsigned enums whose LLVM types are signed
      42. @@ -729,7 +729,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/15 23:04:43 $ + Last modified: $Date: 2003/12/15 23:08:32 $ From lattner at cs.uiuc.edu Mon Dec 15 17:11:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 17:11:01 2003 Subject: [llvm-commits] CVS: llvm/tools/llc/Makefile Message-ID: <200312152310.RAA21165@zion.cs.uiuc.edu> Changes in directory llvm/tools/llc: Makefile updated: 1.43 -> 1.44 --- Log message: There is no reason to add -load support to LLC --- Diffs of the changes: (+1 -1) Index: llvm/tools/llc/Makefile diff -u llvm/tools/llc/Makefile:1.43 llvm/tools/llc/Makefile:1.44 --- llvm/tools/llc/Makefile:1.43 Mon Oct 20 17:27:26 2003 +++ llvm/tools/llc/Makefile Mon Dec 15 17:10:25 2003 @@ -24,7 +24,7 @@ bcreader \ bcwriter \ vmcore \ - support + support.a TOOLLINKOPTS = $(PLATFORMLIBDL) include $(LEVEL)/Makefile.common From lattner at cs.uiuc.edu Mon Dec 15 18:11:09 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Mon Dec 15 18:11:09 2003 Subject: [llvm-commits] CVS: llvm-www/status/index.html Message-ID: <200312160010.SAA23627@zion.cs.uiuc.edu> Changes in directory llvm-www/status: index.html updated: 1.36 -> 1.37 --- Log message: Add entry for llvm Do not wrap dates onto 3 lines --- Diffs of the changes: (+12 -2) Index: llvm-www/status/index.html diff -u llvm-www/status/index.html:1.36 llvm-www/status/index.html:1.37 --- llvm-www/status/index.html:1.36 Mon Dec 1 17:05:27 2003 +++ llvm-www/status/index.html Mon Dec 15 18:10:48 2003 @@ -37,6 +37,8 @@ Compilation / running results +
        + @@ -45,11 +47,19 @@ + + + + + + + - + @@ -444,7 +454,7 @@
        Misha Brukman
        The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/01 23:05:27 $ + Last modified: $Date: 2003/12/16 00:10:48 $ From criswell at cs.uiuc.edu Tue Dec 16 10:27:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 10:27:02 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/GettingStarted.html Message-ID: <200312161626.KAA27018@choi.cs.uiuc.edu> Changes in directory llvm/docs: GettingStarted.html updated: 1.46.2.1 -> 1.46.2.2 --- Log message: Updated for release 1.1. Added information on FreeBSD and MacOS X. --- Diffs of the changes: (+81 -26) Index: llvm/docs/GettingStarted.html diff -u llvm/docs/GettingStarted.html:1.46.2.1 llvm/docs/GettingStarted.html:1.46.2.2 --- llvm/docs/GettingStarted.html:1.46.2.1 Sat Dec 13 13:45:28 2003 +++ llvm/docs/GettingStarted.html Tue Dec 16 10:26:26 2003 @@ -182,24 +182,55 @@
      43. Linux on x86 (Pentium and above)
          -
        • Approximately 760 MB of Free Disk Space +
        • Approximately 918 MB of Free Disk Space
            -
          • Source code: 30 MB
          • -
          • Object code: 670 MB
          • -
          • GCC front end: 60 MB
          • +
          • Source code: 28 MB
          • +
          • Object code: 850 MB
          • +
          • GCC front end: 40 MB
        • -
      44. + + + +

      45. Solaris on SparcV9 (Ultrasparc)
          -
        • Approximately 1.24 GB of Free Disk Space +
        • Approximately 1.52 GB of Free Disk Space +
            +
          • Source code: 28 MB
          • +
          • Object code: 1470 MB
          • +
          • GCC front end: 50 MB
          • +
        • +
        +
      46. + +

        + +
      47. FreeBSD on x86 (Pentium and above) +
          +
        • Approximately 918 MB of Free Disk Space +
            +
          • Source code: 28 MB
          • +
          • Object code: 850 MB
          • +
          • GCC front end: 40 MB
          • +
        • +
        +
      48. + +

        + +
      49. MacOS X on PowerPC +
          +
        • No native code generation +
        • Approximately 1.20 GB of Free Disk Space
            -
          • Source code: 30 MB
          • -
          • Object code: 1000 MB
          • -
          • GCC front end: 210 MB
          • +
          • Source code: 28 MB
          • +
          • Object code: 1160 MB
          • +
          • GCC front end: 40 MB
        • -
      50. + +

        The LLVM suite may compile on other platforms, but it is not @@ -253,7 +284,6 @@ -

        The remainder of this guide is meant to get you up and running with LLVM and to give you some basic information about the LLVM environment. A complete guide to installation is provided in the @@ -348,22 +378,31 @@

        If you have the LLVM distribution, you will need to unpack it before you -can begin to compile it. LLVM is distributed as a set of three files. Each +can begin to compile it. LLVM is distributed as a set of two files: the LLVM +suite and the LLVM GCC front end compiled for your platform. Each file is a TAR archive that is compressed with the gzip program.

        -

        The three files are as follows: +

        The files are as follows:

        -
        llvm.tar.gz +
        llvm-1.1.tar.gz
        This is the source code to the LLVM suite.

        -

        cfrontend.sparc.tar.gz +
        cfrontend-1.1.sparc-sun-solaris2.8.tar.gz
        This is the binary release of the GCC front end for Solaris/Sparc.

        -

        cfrontend.x86.tar.gz +
        cfrontend-1.1.i686-redhat-linux-gnu.tar.gz
        This is the binary release of the GCC front end for Linux/x86. +

        + +

        cfrontend-1.1.i386-unknown-freebsd5.1.tar.gz +
        This is the binary release of the GCC front end for FreeBSD/x86. +

        + +

        cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz +
        This is the binary release of the GCC front end for MacOS X/PPC.
        @@ -391,6 +430,20 @@ directory and fully populate it with the LLVM source code, Makefiles, test directories, and local copies of documentation files.

        +

        +If you want to get a specific release (as opposed to the most recent revision), +you can specify a label. The following releases have the following label: +

          +
        • + Release 1.1: RELEASE_11 +
        • + +
        • + Release 1.0: RELEASE_1 +
        • +
        +

        +

        Note that the GCC front end is not included in the CVS repository. You should have downloaded the binary distribution for your platform.

        @@ -412,12 +465,12 @@
        1. cd where-you-want-the-front-end-to-live
        2. -
        3. gunzip --stdout cfrontend.platform.tar.gz | tar -xvf +
        4. gunzip --stdout cfrontend-version.platform.tar.gz | tar -xvf -
        -

        If you are on a Sparc/Solaris machine, you will need to fix the header -files:

        +

        If you are using Solaris/Sparc or MacOS X/PPC, you will need to fix the +header files:

        cd cfrontend/sparc
        ./fixheaders

        @@ -443,7 +496,8 @@

        Once checked out from the CVS repository, the LLVM suite source code must be configured via the configure script. This script sets variables in llvm/Makefile.config and llvm/include/Config/config.h. It -also populates OBJ_ROOT with the Makefiles needed to build LLVM.

        +also populates OBJ_ROOT with the Makefiles needed to begin building +LLVM.

        The following environment variables are used by the configure script to configure the build system:

        @@ -477,7 +531,7 @@
        --with-llvmgccdir=LLVMGCCDIR
        Path to the location where the LLVM C front end binaries and - associated libraries will be installed. This must be specified as an + associated libraries were installed. This must be specified as an absolute pathname.

        --enable-optimized @@ -488,7 +542,8 @@

        --enable-jit
        - Compile the Just In Time (JIT) functionality. This is not available + Compile the Just In Time (JIT) compiler functionality. This is not + available on all platforms. The default is dependent on platform, so it is best to explicitly enable it if you want it.

        @@ -521,10 +576,10 @@ LLVM_LIB_SEARCH_PATH environment variable in your startup scripts. This environment variable is used to locate "system" libraries like "-lc" and "-lm" when linking. This variable should be set to -the absolute path for the bytecode-libs subdirectory of the GCC front end -install, or LLVMGCCDIR/bytecode-libs. For example, one might set +the absolute path of the bytecode-libs subdirectory of the GCC front +end, or LLVMGCCDIR/bytecode-libs. For example, one might set LLVM_LIB_SEARCH_PATH to -/home/vadve/lattner/local/x86/llvm-gcc/bytecode-libs for the X86 +/home/vadve/lattner/local/x86/llvm-gcc/bytecode-libs for the x86 version of the GCC front end on our research machines.

        @@ -1091,7 +1146,7 @@
        Chris Lattner
        The LLVM Compiler Infrastructure
        - Last modified: $Date: 2003/12/13 19:45:28 $ + Last modified: $Date: 2003/12/16 16:26:26 $
        From criswell at cs.uiuc.edu Tue Dec 16 10:52:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 10:52:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.i686-redhat-linux-gnu.tar.gz cfrontend-1.1.sparc-sun-solaris2.8.tar.gz Message-ID: <200312161651.KAA27586@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.i686-redhat-linux-gnu.tar.gz updated: 1.1 -> 1.2 cfrontend-1.1.sparc-sun-solaris2.8.tar.gz updated: 1.1 -> 1.2 --- Log message: Checkin of newer, faster GCC frontend. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.i686-redhat-linux-gnu.tar.gz Index: llvm-www/releases/1.1/cfrontend-1.1.sparc-sun-solaris2.8.tar.gz From criswell at cs.uiuc.edu Tue Dec 16 10:54:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 10:54:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.source.tar.gz Message-ID: <200312161653.KAA27692@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.source.tar.gz updated: 1.1 -> 1.2 --- Log message: Source code for newer GCC frontend. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.source.tar.gz From criswell at cs.uiuc.edu Tue Dec 16 10:57:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 10:57:02 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/LLVMVsTheWorld.html Message-ID: <200312161656.KAA27805@choi.cs.uiuc.edu> Changes in directory llvm/docs: LLVMVsTheWorld.html (r1.5) removed --- Log message: Not ready for prime-time. --- Diffs of the changes: (+0 -0) From criswell at cs.uiuc.edu Tue Dec 16 11:32:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 11:32:01 2003 Subject: [llvm-commits] [release_11] CVS: llvm/docs/Stacker.html Message-ID: <200312161731.LAA28000@choi.cs.uiuc.edu> Changes in directory llvm/docs: Stacker.html updated: 1.5 -> 1.5.2.1 --- Log message: Fixed some punctuation and grammar. --- Diffs of the changes: (+73 -73) Index: llvm/docs/Stacker.html diff -u llvm/docs/Stacker.html:1.5 llvm/docs/Stacker.html:1.5.2.1 --- llvm/docs/Stacker.html:1.5 Sun Nov 30 23:12:09 2003 +++ llvm/docs/Stacker.html Tue Dec 16 11:31:42 2003 @@ -61,7 +61,7 @@ about LLVM through the experience of creating a simple programming language named Stacker. Stacker was invented specifically as a demonstration of LLVM. The emphasis in this document is not on describing the -intricacies of LLVM itself, but on how to use it to build your own +intricacies of LLVM itself but on how to use it to build your own compiler system.

        @@ -70,7 +70,7 @@

        Amongst other things, LLVM is a platform for compiler writers. Because of its exceptionally clean and small IR (intermediate representation), compiler writing with LLVM is much easier than with -other system. As proof, the author of Stacker wrote the entire +other systems. As proof, the author of Stacker wrote the entire compiler (language definition, lexer, parser, code generator, etc.) in about four days! That's important to know because it shows how quickly you can get a new @@ -78,11 +78,11 @@ language the author ever created using LLVM. The learning curve is included in that four days.

        The language described here, Stacker, is Forth-like. Programs -are simple collections of word definitions and the only thing definitions +are simple collections of word definitions, and the only thing definitions can do is manipulate a stack or generate I/O. Stacker is not a "real" -programming language; its very simple. Although it is computationally +programming language; it's very simple. Although it is computationally complete, you wouldn't use it for your next big project. However, -the fact that it is complete, its simple, and it doesn't have +the fact that it is complete, it's simple, and it doesn't have a C-like syntax make it useful for demonstration purposes. It shows that LLVM could be applied to a wide variety of languages.

        The basic notions behind stacker is very simple. There's a stack of @@ -96,11 +96,11 @@ : MAIN hello_world ;

        This has two "definitions" (Stacker manipulates words, not functions and words have definitions): MAIN and -hello_world. The MAIN definition is standard, it +hello_world. The MAIN definition is standard; it tells Stacker where to start. Here, MAIN is defined to simply invoke the word hello_world. The hello_world definition tells stacker to push the -"Hello, World!" string onto the stack, print it out +"Hello, World!" string on to the stack, print it out (>s), pop it off the stack (DROP), and finally print a carriage return (CR). Although hello_world uses the stack, its net effect is null. Well @@ -124,7 +124,7 @@

        Although I knew that LLVM uses a Single Static Assignment (SSA) format, it wasn't obvious to me how prevalent this idea was in LLVM until I really started using it. Reading the -Programmer's Manual and Language Reference +Programmer's Manual and Language Reference, I noted that most of the important LLVM IR (Intermediate Representation) C++ classes were derived from the Value class. The full power of that simple design only became fully understood once I started constructing executable @@ -200,7 +200,7 @@

        1. Create your blocks early. While writing your compiler, you will encounter several situations where you know apriori that you will - need several blocks. For example, if-then-else, switch, while and for + need several blocks. For example, if-then-else, switch, while, and for statements in C/C++ all need multiple blocks for expression in LVVM. The rule is, create them early.
        2. Terminate your blocks early. This just reduces the chances @@ -261,15 +261,15 @@ the instructions for the "then" and "else" parts. They would use the third part of the idiom almost exclusively (inserting new instructions before the terminator). Furthermore, they could even recurse back to handle_if -should they encounter another if/then/else statement and it will just work.

          +should they encounter another if/then/else statement, and it will just work.

          Note how cleanly this all works out. In particular, the push_back methods on the BasicBlock's instruction list. These are lists of type Instruction which also happen to be Values. To create -the "if" branch we merely instantiate a BranchInst that takes as +the "if" branch, we merely instantiate a BranchInst that takes as arguments the blocks to branch to and the condition to branch on. The blocks act like branch labels! This new BranchInst terminates the BasicBlock provided as an argument. To give the caller a way -to keep inserting after calling handle_if we create an "exit" block +to keep inserting after calling handle_if, we create an "exit" block which is returned to the caller. Note that the "exit" block is used as the terminator for both the "then" and the "else" blocks. This guarantees that no matter what else "handle_if" or "fill_in" does, they end up at the "exit" block. @@ -283,7 +283,7 @@ method on the various lists. This is so common that it is worth mentioning. The "push_back" inserts a value into an STL list, vector, array, etc. at the end. The method might have also been named "insert_tail" or "append". -Althought I've used STL quite frequently, my use of push_back wasn't very +Although I've used STL quite frequently, my use of push_back wasn't very high in other programs. In LLVM, you'll use it all the time.

          @@ -292,17 +292,17 @@

          It took a little getting used to and several rounds of postings to the LLVM -mail list to wrap my head around this instruction correctly. Even though I had +mailing list to wrap my head around this instruction correctly. Even though I had read the Language Reference and Programmer's Manual a couple times each, I still missed a few very key points:

            -
          • GetElementPtrInst gives you back a Value for the last thing indexed +
          • GetElementPtrInst gives you back a Value for the last thing indexed.
          • All global variables in LLVM are pointers.
          • Pointers must also be dereferenced with the GetElementPtrInst instruction.

          This means that when you look up an element in the global variable (assuming -its a struct or array), you must deference the pointer first! For many +it's a struct or array), you must deference the pointer first! For many things, this leads to the idiom:

          
          @@ -319,13 +319,13 @@
           variable and the address of its first element as the same. That tripped me up
           for a while until I realized that they really do differ .. by type.
           Remember that LLVM is a strongly typed language itself. Everything
          -has a type.  The "type" of the global variable is [24 x int]*. That is, its
          +has a type.  The "type" of the global variable is [24 x int]*. That is, it's
           a pointer to an array of 24 ints.  When you dereference that global variable with
           a single (0) index, you now have a "[24 x int]" type.  Although
           the pointer value of the dereferenced global and the address of the zero'th element
           in the array will be the same, they differ in their type. The zero'th element has
           type "int" while the pointer value has type "[24 x int]".

          -

          Get this one aspect of LLVM right in your head and you'll save yourself +

          Get this one aspect of LLVM right in your head, and you'll save yourself a lot of compiler writing headaches down the road.

          @@ -334,7 +334,7 @@

          Linkage types in LLVM can be a little confusing, especially if your compiler writing mind has affixed very hard concepts to particular words like "weak", "external", "global", "linkonce", etc. LLVM does not use the precise -definitions of say ELF or GCC even though they share common terms. To be fair, +definitions of, say, ELF or GCC, even though they share common terms. To be fair, the concepts are related and similar but not precisely the same. This can lead you to think you know what a linkage type represents but in fact it is slightly different. I recommend you read the @@ -342,10 +342,10 @@ carefully. Then, read it again.

          Here are some handy tips that I discovered along the way:

            -
          • Unitialized means external. That is, the symbol is declared in the current +
          • Uninitialized means external. That is, the symbol is declared in the current module and can be used by that module but it is not defined by that module.
          • Setting an initializer changes a global's linkage type from whatever it was - to a normal, defind global (not external). You'll need to call the setLinkage() + to a normal, defined global (not external). You'll need to call the setLinkage() method to reset it if you specify the initializer after the GlobalValue has been constructed. This is important for LinkOnce and Weak linkage types.
          • Appending linkage can be used to keep track of compilation information at @@ -362,7 +362,7 @@ functions in the LLVM IR that make things easier. Here's what I learned:

            • Constants are Values like anything else and can be operands of instructions
            • -
            • Integer constants, frequently needed can be created using the static "get" +
            • Integer constants, frequently needed, can be created using the static "get" methods of the ConstantInt, ConstantSInt, and ConstantUInt classes. The nice thing about these is that you can "get" any kind of integer quickly.
            • There's a special method on Constant class which allows you to get the null @@ -379,14 +379,14 @@ proceeding, a few words about the stack are in order. The stack is simply a global array of 32-bit integers or pointers. A global index keeps track of the location of the top of the stack. All of this is hidden from the -programmer but it needs to be noted because it is the foundation of the +programmer, but it needs to be noted because it is the foundation of the conceptual programming model for Stacker. When you write a definition, you are, essentially, saying how you want that definition to manipulate the global stack.

              Manipulating the stack can be quite hazardous. There is no distinction given and no checking for the various types of values that can be placed on the stack. Automatic coercion between types is performed. In many -cases this is useful. For example, a boolean value placed on the stack +cases, this is useful. For example, a boolean value placed on the stack can be interpreted as an integer with good results. However, using a word that interprets that boolean value as a pointer to a string to print out will almost always yield a crash. Stacker simply leaves it @@ -406,9 +406,9 @@

              So, your typical definition will have the form:

              : name ... ;

              The name is up to you but it must start with a letter and contain -only letters numbers and underscore. Names are case sensitive and must not be +only letters, numbers, and underscore. Names are case sensitive and must not be the same as the name of a built-in word. The ... is replaced by -the stack manipulting words that you wish define name as.

              +the stack manipulating words that you wish to define name as.

              Comments
              @@ -429,12 +429,12 @@
              Literals
              -

              There are three kinds of literal values in Stacker. Integer, Strings, +

              There are three kinds of literal values in Stacker: Integers, Strings, and Booleans. In each case, the stack operation is to simply push the - value onto the stack. So, for example:
              + value on to the stack. So, for example:
              42 " is the answer." TRUE
              - will push three values onto the stack: the integer 42, the - string " is the answer." and the boolean TRUE.

              + will push three values on to the stack: the integer 42, the + string " is the answer.", and the boolean TRUE.

              Words
              @@ -464,20 +464,20 @@

              The built-in words of the Stacker language are put in several groups depending on what they do. The groups are as follows:

                -
              1. LogicalThese words provide the logical operations for +
              2. Logical: These words provide the logical operations for comparing stack operands.
                The words are: < > <= >= = <> true false.
              3. -
              4. BitwiseThese words perform bitwise computations on +
              5. Bitwise: These words perform bitwise computations on their operands.
                The words are: << >> XOR AND NOT
              6. -
              7. ArithmeticThese words perform arithmetic computations on +
              8. Arithmetic: These words perform arithmetic computations on their operands.
                The words are: ABS NEG + - * / MOD */ ++ -- MIN MAX
              9. -
              10. StackThese words manipulate the stack directly by moving +
              11. Stack: These words manipulate the stack directly by moving its elements around.
                The words are: DROP DUP SWAP OVER ROT DUP2 DROP2 PICK TUCK
              12. -
              13. MemoryThese words allocate, free and manipulate memory +
              14. Memory: These words allocate, free, and manipulate memory areas outside the stack.
                The words are: MALLOC FREE GET PUT
              15. -
              16. ControlThese words alter the normal left to right flow +
              17. Control: These words alter the normal left to right flow of execution.
                The words are: IF ELSE ENDIF WHILE END RETURN EXIT RECURSE
              18. -
              19. I/O These words perform output on the standard output +
              20. I/O: These words perform output on the standard output and input on the standard input. No other I/O is possible in Stacker.
                The words are: SPACE TAB CR >s >d >c <s <d <c.
              @@ -554,12 +554,12 @@
        - + - + @@ -604,75 +604,75 @@ + on to the stack + on to the stack + on to the stack + on to the stack + of w1 by w2 is pushed back on to the stack + divided by w3. The result is pushed back on to the stack. + pushed back on to the stack. + pushed back on to the stack. + on to the stack. + on to the stack. @@ -703,13 +703,13 @@ - + - @@ -717,7 +717,7 @@ @@ -725,27 +725,27 @@ - @@ -822,7 +822,7 @@ + block is pushed on to the stack. @@ -911,7 +911,7 @@ + resulting string is pushed on to the stack. + resulting value is pushed on to the stack + " %c". The value is converted to an integer and pushed on to the stack. @@ -989,9 +989,9 @@

        The following fully documented program highlights many features of both the Stacker language and what is possible with LLVM. The program has two modes of operations. If you provide numeric arguments to the program, it checks to see -if those arguments are prime numbers, prints out the results. Without any -aruments, the program prints out any prime numbers it finds between 1 and one -million (there's a log of them!). The source code comments below tell the +if those arguments are prime numbers and prints out the results. Without any +arguments, the program prints out any prime numbers it finds between 1 and one +million (there's a lot of them!). The source code comments below tell the remainder of the story.

        @@ -1015,7 +1015,7 @@ : exit_loop FALSE; ################################################################################ -# This definition tryies an actual division of a candidate prime number. It +# This definition tries an actual division of a candidate prime number. It # determines whether the division loop on this candidate should continue or # not. # STACK<: @@ -1075,7 +1075,7 @@ # STACK<: # p - the prime number to check # STACK>: -# yn - boolean indiating if its a prime or not +# yn - boolean indicating if its a prime or not # p - the prime number checked ################################################################################ : try_harder @@ -1248,7 +1248,7 @@ under the LLVM "projects" directory. You will need to obtain the LLVM sources to find it (either via anonymous CVS or a tarball. See the Getting Started document).

        -

        Under the "projects" directory there is a directory named "stacker". That +

        Under the "projects" directory there is a directory named "Stacker". That directory contains everything, as follows:

        • lib - contains most of the source code @@ -1301,7 +1301,7 @@ definitions, the ROLL word is not implemented. This word was left out of Stacker on purpose so that it can be an exercise for the student. The exercise is to implement the ROLL functionality (in your own workspace) and build a test -program for it. If you can implement ROLL you understand Stacker and probably +program for it. If you can implement ROLL, you understand Stacker and probably a fair amount about LLVM since this is one of the more complicated Stacker operations. The work will almost be completely limited to the compiler. @@ -1326,7 +1326,7 @@ emitted currently is somewhat wasteful. It gets cleaned up a lot by existing passes but more could be done.
        • Add -O -O1 -O2 and -O3 optimization switches to the compiler driver to - allow LLVM optimization without using "opt"
        • + allow LLVM optimization without using "opt."
        • Make the compiler driver use the LLVM linking facilities (with IPO) before depending on GCC to do the final link.
        • Clean up parsing. It doesn't handle errors very well.
        • @@ -1346,6 +1346,6 @@ +
          Last modified: $Date: 2003/12/16 17:31:42 $ From criswell at cs.uiuc.edu Tue Dec 16 11:36:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 11:36:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/llvm-1.1.tar.gz Message-ID: <200312161735.LAA28131@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: llvm-1.1.tar.gz updated: 1.3 -> 1.4 --- Log message: Minor documentation and configure script updates. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/llvm-1.1.tar.gz From criswell at cs.uiuc.edu Tue Dec 16 11:42:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 11:42:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.sparc-sun-solaris2.8.tar.gz Message-ID: <200312161741.LAA28255@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.sparc-sun-solaris2.8.tar.gz updated: 1.2 -> 1.3 --- Log message: Removed Solaris header files again. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.sparc-sun-solaris2.8.tar.gz From criswell at cs.uiuc.edu Tue Dec 16 14:19:03 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 14:19:03 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz cfrontend-1.1.i386-unknown-freebsd5.1.tar.gz Message-ID: <200312162018.OAA21808@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz updated: 1.1 -> 1.2 cfrontend-1.1.i386-unknown-freebsd5.1.tar.gz updated: 1.1 -> 1.2 --- Log message: Updated to the newer and faster GCC frontend. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz Index: llvm-www/releases/1.1/cfrontend-1.1.i386-unknown-freebsd5.1.tar.gz From criswell at cs.uiuc.edu Tue Dec 16 14:37:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 14:37:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz Message-ID: <200312162036.OAA21953@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz updated: 1.2 -> 1.3 --- Log message: Updated README with information on how to fix the header files. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz From criswell at cs.uiuc.edu Tue Dec 16 15:05:04 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:05:04 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312162104.PAA22107@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.5 -> 1.6 --- Log message: Added the ability to set a cookie. --- Diffs of the changes: (+10 -2) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.5 llvm-www/releases/register.cgi:1.6 --- llvm-www/releases/register.cgi:1.5 Mon Dec 15 13:15:11 2003 +++ llvm-www/releases/register.cgi Tue Dec 16 15:04:27 2003 @@ -5,6 +5,7 @@ import smtplib import os import sys +import Cookie # List of email addresses that want to know when people download notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] @@ -159,7 +160,7 @@ print ('Status: 400 Bad Request') print ('') print ('

          ') - print ('Error in form:' + error) + print ('Error in form: ' + error) print ('

          ') sys.exit (0) @@ -174,7 +175,14 @@ Subscribe (form) # -# Everything so far has worked. Send the user to the download page. +# Create a cookie so that the user does not need to register again. +# +usercookie = Cookie.SimpleCookie() +usercookie['LLVM Download'] = 'Yes' +usercookie.output() + +# +# Send the user to the download page. # print ('Location: /releases/download.html') print ('') From criswell at cs.uiuc.edu Tue Dec 16 15:07:06 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:07:06 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312162106.PAA22218@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.6 -> 1.7 --- Log message: Remove new functionality until it is tested. --- Diffs of the changes: (+3 -3) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.6 llvm-www/releases/register.cgi:1.7 --- llvm-www/releases/register.cgi:1.6 Tue Dec 16 15:04:27 2003 +++ llvm-www/releases/register.cgi Tue Dec 16 15:06:04 2003 @@ -177,9 +177,9 @@ # # Create a cookie so that the user does not need to register again. # -usercookie = Cookie.SimpleCookie() -usercookie['LLVM Download'] = 'Yes' -usercookie.output() +#usercookie = Cookie.SimpleCookie() +#usercookie['LLVM Download'] = 'Yes' +#usercookie.output() # # Send the user to the download page. From criswell at cs.uiuc.edu Tue Dec 16 15:07:13 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:07:13 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi testregister.html Message-ID: <200312162107.PAA22333@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi added (r1.1) testregister.html added (r1.1) --- Log message: Test files for testing new functionality without breaking the old. --- Diffs of the changes: (+276 -0) Index: llvm-www/releases/testregister.cgi diff -c /dev/null llvm-www/releases/testregister.cgi:1.1 *** /dev/null Tue Dec 16 15:07:02 2003 --- llvm-www/releases/testregister.cgi Tue Dec 16 15:06:52 2003 *************** *** 0 **** --- 1,191 ---- + #!/usr/dcs/software/supported/bin/python + + import cgi + import urllib + import smtplib + import os + import sys + import Cookie + + # List of email addresses that want to know when people download + notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] + + # + # Function: Subscribe() + # + # Description: + # This function subscribes the specified user to the LLVM announce mailing + # list. + # + def Subscribe (form): + # Name of the LLVM subscription CGI script + scriptURL='http://mail.cs.uiuc.edu/mailman/subscribe/llvm-announce' + + # + # Extract from the form any information that we need + # + email = form.getfirst ('email', '') + pw1 = email + pw2 = email + announce = form.getfirst ('announce','yes') + + # + # Exit now if we do not need to subscribe. + # + if (announce != 'yes'): + return + + # + # Create a POST request with all of the information that the CGI + # script will require. + # + options = {'email': email, 'pw': pw1, 'pw-conf': pw2, 'digest': '0'} + + # + # Convert the POST options into a string that we can send to the + # subscription CGI script. + # + postdata = urllib.urlencode (options) + + # + # Subscribe the user. + # + urllib.urlopen (scriptURL, postdata) + + return + + # + # Function: ValidateForm () + # + # Description: + # Make sure that the input to the CGI script is valid. + # + def ValidateForm (form): + # + # Verify if the required fields have been supplied. + # + firstname = form.getfirst ('firstname', '') + lastname = form.getfirst ('lastname', '') + email = form.getfirst ('email', '') + announce = form.getfirst ('announce','yes') + + # + # Verify that the name and email fields have been filled in. + # + if (firstname == ''): + return 'First name is empty.' + + if (lastname == ''): + return 'Last name is empty.' + + if (email == ''): + return 'Email address is empty.' + + # + # Verify that the email address has an at sign and some periods. + # + length = len (email) - 1 + while (length != 0): + if (email[length] == '@'): + break + length=length - 1 + else: + return 'Email address has no at sign' + + length = len (email) - 1 + while (length != 0): + if (email[length] == '.'): + break + length=length - 1 + else: + return 'Email address has no periods' + + return '' + + # + # Function: LogForm () + # + # Description: + # Append a log record to the logfile that another users has registered to + # download LLVM. + # + def LogForm (form): + # + # Extract the information from the form that we want. + # + firstname = form.getfirst ('firstname', '') + lastname = form.getfirst ('lastname', '') + title = form.getfirst ('title','') + organization = form.getfirst ('organization', '') + email = form.getfirst ('email','') + plans = form.getfirst ('plans','') + if (plans == ''): + plans = 'No plans.' + + # + # Construct an email message describing the user who is downloading + # LLVM. + # + msg = 'Subject: [LLVM Download]\r\n\r\n' + msg = msg + 'Name: ' + firstname + ' ' + lastname + '\n' + msg = msg + 'Email: ' + email + '\n' + msg = msg + 'Title: ' + title + '\n' + msg = msg + 'Organization: ' + organization + '\n' + msg = msg + 'Plans with LLVM:\n' + plans + '\n' + + # + # Send email to notify that someone has downloaded LLVM yet again! + # + mailer = smtplib.SMTP ('localhost') + for receiver in notifylist: + header = 'From: ' + email + '\r\nTo: ' + receiver + '\r\n' + try: + mailer.sendmail (email, receiver, msg) + except: + pass + mailer.quit () + return + + # + # Parse the CGI input + # + form = cgi.FieldStorage () + + # + # Verify that everything in the form is correct. + # + error = ValidateForm (form) + if (error != ''): + print ('Content-type: text/html') + print ('Status: 400 Bad Request') + print ('') + print ('

          ') + print ('Error in form: ' + error) + print ('

          ') + sys.exit (0) + + # + # Log the information provided by the form. + # + LogForm (form) + + # + # Subscribe the user the LLVM Announcements list (if they so desire) + # + Subscribe (form) + + # + # Create a cookie so that the user does not need to register again. + # + usercookie = Cookie.SimpleCookie() + usercookie['LLVM Download'] = 'Yes' + usercookie.output() + + # + # Send the user to the download page. + # + print ('Location: /releases/download.html') + print ('') + + sys.exit (0) + Index: llvm-www/releases/testregister.html diff -c /dev/null llvm-www/releases/testregister.html:1.1 *** /dev/null Tue Dec 16 15:07:02 2003 --- llvm-www/releases/testregister.html Tue Dec 16 15:06:52 2003 *************** *** 0 **** --- 1,85 ---- + + + LLVM Registration Page + + + + +
          + LLVM Registration Page +
          + +
          + +
          + Welcome to the LLVM registration page! +

          + We'd like to collect some information about people and organizations who are + interested in LLVM. Please complete the following form below to download a copy + of the LLVM software. +
          + +
        ProgramStatus Notes
        llvm1.115 Dec 2003WORKSJust did some simple touch testing after 'make tools'. Things seem to work, but I didn't try running the testsuite or anything. +
        hbd 0.2.326 Nov 200326 Nov 2003 WORKS Did not try the install target.
        FALSE FALSE -- bThe boolean value FALSE (0) is pushed onto the stack.The boolean value FALSE (0) is pushed on to the stack.
        TRUE TRUE -- bThe boolean value TRUE (-1) is pushed onto the stack.The boolean value TRUE (-1) is pushed on to the stack.
        BITWISE OPERATIONS
        WordNameOperationDescription
        ABS w -- |w| One value s popped off the stack; its absolute value is computed - and then pushed onto the stack. If w1 is -1 then w2 is 1. If w1 is + and then pushed on to the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is also 1.
        NEG NEG w -- -w One value is popped off the stack which is negated and then - pushed back onto the stack. If w1 is -1 then w2 is 1. If w1 is + pushed back on to the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is -1.
        + ADD w1 w2 -- w2+w1 Two values are popped off the stack. Their sum is pushed back - onto the stack
        - SUB w1 w2 -- w2-w1 Two values are popped off the stack. Their difference is pushed back - onto the stack
        * MUL w1 w2 -- w2*w1 Two values are popped off the stack. Their product is pushed back - onto the stack
        / DIV w1 w2 -- w2/w1 Two values are popped off the stack. Their quotient is pushed back - onto the stack
        MOD MOD w1 w2 -- w2%w1 Two values are popped off the stack. Their remainder after division - of w1 by w2 is pushed back onto the stack
        */ STAR_SLAH w1 w2 w3 -- (w3*w2)/w1 Three values are popped off the stack. The product of w1 and w2 is - divided by w3. The result is pushed back onto the stack.
        ++ INCR w -- w+1 One value is popped off the stack. It is incremented by one and then - pushed back onto the stack.
        -- DECR w -- w-1 One value is popped off the stack. It is decremented by one and then - pushed back onto the stack.
        MIN MIN w1 w2 -- (w2<w1?w2:w1) Two values are popped off the stack. The larger one is pushed back - onto the stack.
        MAX MAX w1 w2 -- (w2>w1?w2:w1) Two values are popped off the stack. The larger value is pushed back - onto the stack.
        STACK MANIPULATION OPERATIONS
        WordNameOperationDescription
        DUP DUP w1 -- w1 w1One value is popped off the stack. That value is then pushed onto - the stack twice to duplicate the top stack vaue.One value is popped off the stack. That value is then pushed on to + the stack twice to duplicate the top stack value.
        DUP2 DUP2 w1 w2 -- w1 w2 w1 w2The top two values on the stack are duplicated. That is, two vaues + The top two values on the stack are duplicated. That is, two values are popped off the stack. They are alternately pushed back on the stack twice each.
        SWAP w1 w2 -- w2 w1 The top two stack items are reversed in their order. That is, two - values are popped off the stack and pushed back onto the stack in + values are popped off the stack and pushed back on to the stack in the opposite order they were popped.
        SWAP2w1 w2 w3 w4 -- w3 w4 w2 w1 The top four stack items are swapped in pairs. That is, two values are popped and retained. Then, two more values are popped and retained. - The values are pushed back onto the stack in the reverse order but + The values are pushed back on to the stack in the reverse order but in pairs.

        OVER OVER w1 w2-- w1 w2 w1 Two values are popped from the stack. They are pushed back - onto the stack in the order w1 w2 w1. This seems to cause the + on to the stack in the order w1 w2 w1. This seems to cause the top stack element to be duplicated "over" the next value.
        OVER2 OVER2 w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2The third and fourth values on the stack are replicated onto the + The third and fourth values on the stack are replicated on to the top of the stack
        ROT ROT w1 w2 w3 -- w2 w3 w1 The top three values are rotated. That is, three value are popped - off the stack. They are pushed back onto the stack in the order + off the stack. They are pushed back on to the stack in the order w1 w3 w2.
        ROT2One value is popped off the stack. The value is used as the size of a memory block to allocate. The size is in bytes, not words. The memory allocation is completed and the address of the memory - block is pushed onto the stack.
        FREE FREEThe boolean value on the top of the stack is examined. If it is non-zero then the "words..." between WHILE and END are executed. Execution then begins again at the WHILE where another boolean is popped off the stack. To prevent this operation from eating up the entire - stack, you should push onto the stack (just before the END) a boolean value that indicates + stack, you should push on to the stack (just before the END) a boolean value that indicates whether to terminate. Note that since booleans and integers can be coerced you can use the following "for loop" idiom:
        (push count) WHILE (words...) -- END
        @@ -960,19 +960,19 @@
        IN_STR -- s A string is read from the input via the scanf(3) format string " %as". The - resulting string is pushed onto the stack.
        <d IN_STR -- w An integer is read from the input via the scanf(3) format string " %d". The - resulting value is pushed onto the stack
        <c IN_CHR -- w A single character is read from the input via the scanf(3) format string - " %c". The value is converted to an integer and pushed onto the stack.
        DUMP DUMP
        + +
        Information
        + +
        + +
        + + + + + + + + + + + + + + + + + + + + + + +
        First Name (required):
        Last Name (required):
        Email Address (required):
        Organizational Affiliation:
        Position/Title:
        + +

        + The LLVM Announcements List is a low volume mailing list that provides LLVM + users with important information on new LLVM releases. If you would like to + subscribe to this list, please select "yes" and respond to the confirmation + email that you will receive (your email address will be your password): +

        + + Subscribe to + LLVM + Announcements List (default is yes): +
        + Yes
        + No
        + +

        + We would be interested to know how you plan to use LLVM. +
        + This information is strictly optional and will be kept completely confidential:
        + +

        + + Finally, click "Download" to go to the download page:
        + + + +
        + +
        + + + + + From criswell at cs.uiuc.edu Tue Dec 16 15:10:05 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:10:05 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312162109.PAA22445@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.1 -> 1.2 --- Log message: Don't bother logging when we're just testing. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.1 llvm-www/releases/testregister.cgi:1.2 --- llvm-www/releases/testregister.cgi:1.1 Tue Dec 16 15:06:52 2003 +++ llvm-www/releases/testregister.cgi Tue Dec 16 15:08:56 2003 @@ -167,7 +167,7 @@ # # Log the information provided by the form. # -LogForm (form) +#LogForm (form) # # Subscribe the user the LLVM Announcements list (if they so desire) From criswell at cs.uiuc.edu Tue Dec 16 15:12:05 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:12:05 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312162112.PAA22567@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.2 -> 1.3 --- Log message: Working cookie support that doesn't do anything. --- Diffs of the changes: (+6 -5) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.2 llvm-www/releases/testregister.cgi:1.3 --- llvm-www/releases/testregister.cgi:1.2 Tue Dec 16 15:08:56 2003 +++ llvm-www/releases/testregister.cgi Tue Dec 16 15:11:53 2003 @@ -154,7 +154,8 @@ # # Verify that everything in the form is correct. # -error = ValidateForm (form) +#error = ValidateForm (form) +error = '' if (error != ''): print ('Content-type: text/html') print ('Status: 400 Bad Request') @@ -172,14 +173,14 @@ # # Subscribe the user the LLVM Announcements list (if they so desire) # -Subscribe (form) +#Subscribe (form) # # Create a cookie so that the user does not need to register again. # -usercookie = Cookie.SimpleCookie() -usercookie['LLVM Download'] = 'Yes' -usercookie.output() +usercookie = Cookie.SmartCookie() +usercookie["LLVM"] = "Yes" +print usercookie # # Send the user to the download page. From criswell at cs.uiuc.edu Tue Dec 16 15:40:04 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:40:04 2003 Subject: [llvm-commits] CVS: llvm-www/releases/checkreg.cgi Message-ID: <200312162139.PAA22753@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: checkreg.cgi added (r1.1) --- Log message: Script to check for previous registration. --- Diffs of the changes: (+27 -0) Index: llvm-www/releases/checkreg.cgi diff -c /dev/null llvm-www/releases/checkreg.cgi:1.1 *** /dev/null Tue Dec 16 15:39:06 2003 --- llvm-www/releases/checkreg.cgi Tue Dec 16 15:38:56 2003 *************** *** 0 **** --- 1,27 ---- + #!/usr/dcs/software/supported/bin/python + + import cgi + import urllib + import smtplib + import os + import sys + import Cookie + + # + # Create a cookie so that the user does not need to register again. + # + usercookie = Cookie.SmartCookie() + usercookie.load (environ['HTTP_COOKIE']) + + # + # Send the user to the download page. + # + if (usercookie['LLVM'] == 'Yes'): + print ('Location: /releases/download.html') + else: + print ('Location: /releases/register.html') + + print ('') + + sys.exit (0) + From criswell at cs.uiuc.edu Tue Dec 16 15:42:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:42:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/checkreg.cgi Message-ID: <200312162141.PAA22907@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: checkreg.cgi updated: 1.1 -> 1.2 --- Log message: Fixed some name resolution problems. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/checkreg.cgi diff -u llvm-www/releases/checkreg.cgi:1.1 llvm-www/releases/checkreg.cgi:1.2 --- llvm-www/releases/checkreg.cgi:1.1 Tue Dec 16 15:38:56 2003 +++ llvm-www/releases/checkreg.cgi Tue Dec 16 15:41:08 2003 @@ -11,7 +11,7 @@ # Create a cookie so that the user does not need to register again. # usercookie = Cookie.SmartCookie() -usercookie.load (environ['HTTP_COOKIE']) +usercookie.load (os.environ['HTTP_COOKIE']) # # Send the user to the download page. From criswell at cs.uiuc.edu Tue Dec 16 15:50:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:50:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/checkreg.cgi Message-ID: <200312162149.PAA22952@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: checkreg.cgi updated: 1.2 -> 1.3 --- Log message: Added code to check for the existance of cookie information. --- Diffs of the changes: (+7 -2) Index: llvm-www/releases/checkreg.cgi diff -u llvm-www/releases/checkreg.cgi:1.2 llvm-www/releases/checkreg.cgi:1.3 --- llvm-www/releases/checkreg.cgi:1.2 Tue Dec 16 15:41:08 2003 +++ llvm-www/releases/checkreg.cgi Tue Dec 16 15:49:13 2003 @@ -10,8 +10,13 @@ # # Create a cookie so that the user does not need to register again. # -usercookie = Cookie.SmartCookie() -usercookie.load (os.environ['HTTP_COOKIE']) +if (os.environ.has_key ('HTTP_COOKIE')): + usercookie = Cookie.SmartCookie() + usercookie.load (os.environ['HTTP_COOKIE']) +else: + print ('Location: /releases/register.html') + print ('') + sys.exit (0) # # Send the user to the download page. From criswell at cs.uiuc.edu Tue Dec 16 15:54:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 15:54:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/checkreg.cgi Message-ID: <200312162153.PAA23156@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: checkreg.cgi updated: 1.3 -> 1.4 --- Log message: Move the output into the actual stuff that the browser prints. This should make it a little easier to debug. --- Diffs of the changes: (+3 -2) Index: llvm-www/releases/checkreg.cgi diff -u llvm-www/releases/checkreg.cgi:1.3 llvm-www/releases/checkreg.cgi:1.4 --- llvm-www/releases/checkreg.cgi:1.3 Tue Dec 16 15:49:13 2003 +++ llvm-www/releases/checkreg.cgi Tue Dec 16 15:52:53 2003 @@ -1,12 +1,13 @@ #!/usr/dcs/software/supported/bin/python import cgi -import urllib -import smtplib import os import sys import Cookie +print ('Content-type: text/plain') +print ('') +print ('') # # Create a cookie so that the user does not need to register again. # From gaeke at cs.uiuc.edu Tue Dec 16 15:56:01 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Tue Dec 16 15:56:01 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/Transforms/IPO.h Message-ID: <200312162155.PAA18325@zion.cs.uiuc.edu> Changes in directory llvm/include/llvm/Transforms: IPO.h updated: 1.25 -> 1.26 --- Log message: Fix typo in comment. --- Diffs of the changes: (+1 -1) Index: llvm/include/llvm/Transforms/IPO.h diff -u llvm/include/llvm/Transforms/IPO.h:1.25 llvm/include/llvm/Transforms/IPO.h:1.26 --- llvm/include/llvm/Transforms/IPO.h:1.25 Tue Nov 11 16:41:31 2003 +++ llvm/include/llvm/Transforms/IPO.h Tue Dec 16 15:55:45 2003 @@ -104,7 +104,7 @@ Pass *createDeadArgEliminationPass(); // DeadArgHacking pass - Same as DAE, but delete arguments of external functions -// as well. This is definately not safe, and should only be used by bugpoint. +// as well. This is definitely not safe, and should only be used by bugpoint. Pass *createDeadArgHackingPass(); //===----------------------------------------------------------------------===// From lattner at cs.uiuc.edu Tue Dec 16 16:35:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Tue Dec 16 16:35:02 2003 Subject: [llvm-commits] CVS: llvm/docs/FAQ.html Message-ID: <200312162234.QAA19112@zion.cs.uiuc.edu> Changes in directory llvm/docs: FAQ.html updated: 1.15 -> 1.16 --- Log message: Add a faq entry for the demo page --- Diffs of the changes: (+24 -6) Index: llvm/docs/FAQ.html diff -u llvm/docs/FAQ.html:1.15 llvm/docs/FAQ.html:1.16 --- llvm/docs/FAQ.html:1.15 Mon Dec 8 00:22:05 2003 +++ llvm/docs/FAQ.html Tue Dec 16 16:33:55 2003 @@ -70,6 +70,7 @@
        1. What is this __main() call that gets inserted into main()?
        2. +
        3. Where did all of my code go??
      @@ -406,11 +407,9 @@ Questions about code generated by the GCC front-end -
      -

      +

      What is this __main() call that gets inserted into main()? -

      -
      +

      @@ -426,10 +425,29 @@ llvm/runtime/GCCLibraries/crtend/ directory in the source-base, and is linked in automatically when you link the program.

      -
      + + +

      +Where did all of my code go?? +

      +
      +

      +If you are using the LLVM demo page, you may often wonder what happened to all +of the code that you typed in. Remember that the demo script is running the +code through the LLVM optimizers, so if you code doesn't actually do anything +useful, it might all be deleted. +

      + +

      +To prevent this, make sure that the code is actually needed. For example, if +you are computing some expression, return the value from the function instead of +leaving it in a local variable. If you really want to constrain the optimizer, +you can read from and assign to volatile global variables. +

      +
      @@ -438,7 +456,7 @@ From brukman at cs.uiuc.edu Tue Dec 16 16:58:02 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Tue Dec 16 16:58:02 2003 Subject: [llvm-commits] CVS: llvm/runtime/GCCLibraries/libc/memory.c Message-ID: <200312162257.QAA19398@zion.cs.uiuc.edu> Changes in directory llvm/runtime/GCCLibraries/libc: memory.c updated: 1.3 -> 1.4 --- Log message: Disable __attribute__((weak)) on Mac OS X and other lame platforms. --- Diffs of the changes: (+20 -5) Index: llvm/runtime/GCCLibraries/libc/memory.c diff -u llvm/runtime/GCCLibraries/libc/memory.c:1.3 llvm/runtime/GCCLibraries/libc/memory.c:1.4 --- llvm/runtime/GCCLibraries/libc/memory.c:1.3 Mon Dec 15 16:32:50 2003 +++ llvm/runtime/GCCLibraries/libc/memory.c Tue Dec 16 16:57:30 2003 @@ -2,14 +2,29 @@ // // A lot of this code is ripped gratuitously from glibc and libiberty. // -//===----------------------------------------------------------------------===// +//===---------------------------------------------------------------------===// #include -void *malloc(size_t) __attribute__((weak)); -void free(void *) __attribute__((weak)); -void *memset(void *, int, size_t) __attribute__((weak)); -void *calloc(size_t nelem, size_t elsize) __attribute__((weak)); +// If we're not being compiled with GCC, turn off attributes. Question is how +// to handle overriding of memory allocation functions in that case. +#ifndef __GNUC__ +#define __attribute__(X) +#endif + +// For now, turn off the weak linkage attribute on Mac OS X. +#if defined(__GNUC__) && defined(__APPLE_CC__) +#define __ATTRIBUTE_WEAK__ +#elif defined(__GNUC__) +#define __ATTRIBUTE_WEAK__ __attribute__((weak)) +#else +#define __ATTRIBUTE_WEAK__ +#endif + +void *malloc(size_t) __ATTRIBUTE_WEAK__; +void free(void *) __ATTRIBUTE_WEAK__; +void *memset(void *, int, size_t) __ATTRIBUTE_WEAK__; +void *calloc(size_t nelem, size_t elsize) __ATTRIBUTE_WEAK__; void *calloc(size_t nelem, size_t elsize) { void *Result = malloc(nelem*elsize); From gaeke at cs.uiuc.edu Tue Dec 16 17:15:02 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Tue Dec 16 17:15:02 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/MultiSource/Applications/siod/slibu.c Message-ID: <200312162314.RAA12710@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Applications/siod: slibu.c updated: 1.1 -> 1.2 --- Log message: Take out reference to putpwent(). Provide a reasonable default definition for PATH_MAX. --- Diffs of the changes: (+5 -11) Index: llvm/test/Programs/MultiSource/Applications/siod/slibu.c diff -u llvm/test/Programs/MultiSource/Applications/siod/slibu.c:1.1 llvm/test/Programs/MultiSource/Applications/siod/slibu.c:1.2 --- llvm/test/Programs/MultiSource/Applications/siod/slibu.c:1.1 Fri Oct 17 13:48:45 2003 +++ llvm/test/Programs/MultiSource/Applications/siod/slibu.c Tue Dec 16 17:14:10 2003 @@ -70,6 +70,10 @@ #include #endif +#ifndef PATH_MAX +#define PATH_MAX 1024 +#endif + #if defined(hpux) #define PATH_MAX MAXPATHLEN #endif @@ -100,7 +104,7 @@ static void init_slibu_version(void) {setvar(cintern("*slibu-version*"), - cintern("$Id: slibu.c,v 1.1 2003/10/17 18:48:45 gaeke Exp $"), + cintern("$Id: slibu.c,v 1.2 2003/12/16 23:14:10 gaeke Exp $"), NIL);} @@ -287,15 +291,6 @@ return(NIL);} #endif -LISP lputpwent(LISP alist,LISP file) -{int iflag = no_interrupt(1); - int status; - struct passwd p; - lencode_pwent(alist,&p); - status = putpwent(&p,get_c_file(file,NULL)); - no_interrupt(iflag); - return(NIL);} - LISP laccess_problem(LISP lfname,LISP lacc) {char *fname = get_c_string(lfname); char *acc = get_c_string(lacc),*p; @@ -2171,7 +2166,6 @@ #if defined(__osf__) init_subr_1("setpwfile",lsetpwfile); #endif - init_subr_2("putpwent",lputpwent); init_subr_2("access-problem?",laccess_problem); init_subr_3("utime",lutime); init_subr_2("fchmod",lfchmod); From criswell at cs.uiuc.edu Tue Dec 16 17:30:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Tue Dec 16 17:30:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz Message-ID: <200312162329.RAA23399@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz updated: 1.3 -> 1.4 --- Log message: Renamed util to utils so that the fixheaders script will work. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz From gaeke at cs.uiuc.edu Tue Dec 16 18:07:01 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Tue Dec 16 18:07:01 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/MultiSource/Applications/siod/Makefile Message-ID: <200312170006.SAA32629@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Applications/siod: Makefile updated: 1.1 -> 1.2 --- Log message: Make sure 'unix' is always defined --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/MultiSource/Applications/siod/Makefile diff -u llvm/test/Programs/MultiSource/Applications/siod/Makefile:1.1 llvm/test/Programs/MultiSource/Applications/siod/Makefile:1.2 --- llvm/test/Programs/MultiSource/Applications/siod/Makefile:1.1 Fri Oct 17 13:48:45 2003 +++ llvm/test/Programs/MultiSource/Applications/siod/Makefile Tue Dec 16 18:06:07 2003 @@ -1,7 +1,7 @@ LEVEL = ../../../../.. PROG = siod -CPPFLAGS = -D__USE_MISC -D__USE_GNU -D__USE_SVID -D__USE_XOPEN_EXTENDED -D__USE_XOPEN +CPPFLAGS = -D__USE_MISC -D__USE_GNU -D__USE_SVID -D__USE_XOPEN_EXTENDED -D__USE_XOPEN -Dunix LDFLAGS = -lm -ldl -lcrypt RUN_OPTIONS = $(BUILD_SRC_DIR)/test.scm From gaeke at cs.uiuc.edu Tue Dec 16 18:10:06 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Tue Dec 16 18:10:06 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/MultiSource/Applications/siod/slibu.c Message-ID: <200312170010.SAA00487@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Applications/siod: slibu.c updated: 1.2 -> 1.3 --- Log message: Take out lchown() --- Diffs of the changes: (+1 -15) Index: llvm/test/Programs/MultiSource/Applications/siod/slibu.c diff -u llvm/test/Programs/MultiSource/Applications/siod/slibu.c:1.2 llvm/test/Programs/MultiSource/Applications/siod/slibu.c:1.3 --- llvm/test/Programs/MultiSource/Applications/siod/slibu.c:1.2 Tue Dec 16 17:14:10 2003 +++ llvm/test/Programs/MultiSource/Applications/siod/slibu.c Tue Dec 16 18:09:51 2003 @@ -104,7 +104,7 @@ static void init_slibu_version(void) {setvar(cintern("*slibu-version*"), - cintern("$Id: slibu.c,v 1.2 2003/12/16 23:14:10 gaeke Exp $"), + cintern("$Id: slibu.c,v 1.3 2003/12/17 00:09:51 gaeke Exp $"), NIL);} @@ -1448,17 +1448,6 @@ #endif -#if defined(unix) && !defined(linux) -LISP l_lchown(LISP path,LISP uid,LISP gid) -{long iflag; - iflag = no_interrupt(1); - if (lchown(get_c_string(path),get_c_long(uid),get_c_long(gid))) - err("lchown",cons(path,llast_c_errmsg(-1))); - no_interrupt(iflag); - return(NIL);} -#endif - - #ifdef unix LISP popen_l(LISP name,LISP how) @@ -2242,9 +2231,6 @@ #endif #ifndef WIN32 init_subr_3("chown",l_chown); -#endif -#if defined(unix) && !defined(linux) - init_subr_3("lchown",l_lchown); #endif init_subr_1("http-date",http_date); #if defined(__osf__) From gaeke at cs.uiuc.edu Tue Dec 16 18:19:01 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Tue Dec 16 18:19:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Bytecode/Reader/ArchiveReader.cpp Message-ID: <200312170018.SAA01319@zion.cs.uiuc.edu> Changes in directory llvm/lib/Bytecode/Reader: ArchiveReader.cpp updated: 1.10 -> 1.11 --- Log message: Make getObjectType() smarter about ranlibbed Mac OS X archives. --- Diffs of the changes: (+2 -0) Index: llvm/lib/Bytecode/Reader/ArchiveReader.cpp diff -u llvm/lib/Bytecode/Reader/ArchiveReader.cpp:1.10 llvm/lib/Bytecode/Reader/ArchiveReader.cpp:1.11 --- llvm/lib/Bytecode/Reader/ArchiveReader.cpp:1.10 Wed Dec 10 18:38:04 2003 +++ llvm/lib/Bytecode/Reader/ArchiveReader.cpp Tue Dec 16 18:18:18 2003 @@ -53,6 +53,8 @@ // Check for sections with special names... if (!memcmp(H->name, "__.SYMDEF ", 16)) return ArchiveSymbolTable; + if (!memcmp(H->name, "__.SYMDEF SORTED", 16)) + return ArchiveSymbolTable; if (!memcmp(H->name, "// ", 16)) return SVR4LongFilename; From criswell at cs.uiuc.edu Wed Dec 17 12:16:09 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 12:16:09 2003 Subject: [llvm-commits] CVS: llvm/CREDITS.TXT Message-ID: <200312171815.MAA25447@choi.cs.uiuc.edu> Changes in directory llvm: CREDITS.TXT updated: 1.7 -> 1.8 --- Log message: Added Stacker to Reid Spencer's list of contributions. --- Diffs of the changes: (+1 -1) Index: llvm/CREDITS.TXT diff -u llvm/CREDITS.TXT:1.7 llvm/CREDITS.TXT:1.8 --- llvm/CREDITS.TXT:1.7 Thu Nov 13 23:37:10 2003 +++ llvm/CREDITS.TXT Wed Dec 17 12:15:04 2003 @@ -56,7 +56,7 @@ N: Reid Spencer E: rspencer at x10sys.com W: http://extprosys.sourceforge.net/ -D: Complete 'llvm' namespacification, bug fixes and improvements +D: Complete 'llvm' namespacification, Stacker, bug fixes, and improvements N: Bill Wendling E: wendling at isanbard.org From brukman at cs.uiuc.edu Wed Dec 17 12:48:02 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 12:48:02 2003 Subject: [llvm-commits] CVS: llvm/docs/AliasAnalysis.html Message-ID: <200312171846.MAA24568@zion.cs.uiuc.edu> Changes in directory llvm/docs: AliasAnalysis.html updated: 1.12 -> 1.13 --- Log message: Since we are now in the 'llvm' namespace, the mangled C++ name of structs and hence the links, all change. --- Diffs of the changes: (+2 -2) Index: llvm/docs/AliasAnalysis.html diff -u llvm/docs/AliasAnalysis.html:1.12 llvm/docs/AliasAnalysis.html:1.13 --- llvm/docs/AliasAnalysis.html:1.12 Fri Nov 21 19:26:21 2003 +++ llvm/docs/AliasAnalysis.html Wed Dec 17 12:46:49 2003 @@ -199,7 +199,7 @@ straight-forward. There are already several implementations that you can use for examples, and the following information should help fill in any details. For a minimal example, take a look at the no-aa implementation.

      +href="/doxygen/structllvm_1_1NoAA.html">no-aa implementation.

      @@ -486,7 +486,7 @@ Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/11/22 01:26:21 $ + Last modified: $Date: 2003/12/17 18:46:49 $ From criswell at cs.uiuc.edu Wed Dec 17 14:16:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:16:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/cfrontend-1.1.sparc-sun-solaris2.8.tar.gz Message-ID: <200312172015.OAA25424@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: cfrontend-1.1.sparc-sun-solaris2.8.tar.gz updated: 1.3 -> 1.4 --- Log message: New fixheaders script that fixes more headers. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/cfrontend-1.1.sparc-sun-solaris2.8.tar.gz From criswell at cs.uiuc.edu Wed Dec 17 14:36:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:36:02 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Programs/External/Makefile Message-ID: <200312172035.OAA29661@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/External: Makefile updated: 1.3 -> 1.3.4.1 --- Log message: Hard coded subdirectories to build to ensure that they build. --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/External/Makefile diff -u llvm/test/Programs/External/Makefile:1.3 llvm/test/Programs/External/Makefile:1.3.4.1 --- llvm/test/Programs/External/Makefile:1.3 Tue Aug 19 16:30:28 2003 +++ llvm/test/Programs/External/Makefile Wed Dec 17 14:35:03 2003 @@ -8,7 +8,7 @@ # # Create the list of directories to compile # -DIRS := $(sort $(filter-out CVS/, $(wildcard */))) +DIRS := SPEC ifndef USE_SPEC DIRS := $(filter-out SPEC/, $(DIRS)) endif From criswell at cs.uiuc.edu Wed Dec 17 14:36:06 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:36:06 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Programs/External/SPEC/Makefile Message-ID: <200312172035.OAA29687@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/External/SPEC: Makefile updated: 1.4 -> 1.4.4.1 --- Log message: Hard coded subdirectories to build to ensure that they build. --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/External/SPEC/Makefile diff -u llvm/test/Programs/External/SPEC/Makefile:1.4 llvm/test/Programs/External/SPEC/Makefile:1.4.4.1 --- llvm/test/Programs/External/SPEC/Makefile:1.4 Tue Aug 19 16:30:30 2003 +++ llvm/test/Programs/External/SPEC/Makefile Wed Dec 17 14:35:06 2003 @@ -1,3 +1,3 @@ LEVEL = ../../../.. -DIRS := $(sort $(filter-out CVS/, $(wildcard */))) +DIRS := CFP2000 CINT2000 include ${LEVEL}/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Wed Dec 17 14:36:10 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:36:10 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile Message-ID: <200312172035.OAA29694@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/FreeBench: Makefile updated: 1.1 -> 1.1.4.1 --- Log message: Hard coded subdirectories to build to ensure that they build. --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile:1.1 llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile:1.1.4.1 --- llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile:1.1 Sat Oct 11 16:18:41 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile Wed Dec 17 14:35:07 2003 @@ -1,6 +1,6 @@ # MultiSource/Olden Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := distray mason pcompress2 analyzer fourinarow neural pifft include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Wed Dec 17 14:36:14 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:36:14 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile Message-ID: <200312172035.OAA29701@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/McCat: Makefile updated: 1.3 -> 1.3.4.1 --- Log message: Hard coded subdirectories to build to ensure that they build. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile:1.3 llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile:1.3.4.1 --- llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile:1.3 Fri Sep 12 11:01:59 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile Wed Dec 17 14:35:08 2003 @@ -1,6 +1,7 @@ # MultiSource/McCat Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := 01-qbsort 04-bisect 08-main 12-IOtest 17-bintr 03-testtrie 05-eks 09-vor 15-trie 18-imp + include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Wed Dec 17 14:36:18 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:36:18 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile Message-ID: <200312172035.OAA29708@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/Olden: Makefile updated: 1.3 -> 1.3.4.1 --- Log message: Hard coded subdirectories to build to ensure that they build. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile:1.3 llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile:1.3.4.1 --- llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile:1.3 Fri Sep 12 11:02:21 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile Wed Dec 17 14:35:09 2003 @@ -1,6 +1,7 @@ # MultiSource/Olden Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := bh em3d mst power tsp bisort health perimeter treeadd voronoi + include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Wed Dec 17 14:36:22 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:36:22 2003 Subject: [llvm-commits] [release_11] CVS: llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile Message-ID: <200312172035.OAA29715@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/Ptrdist: Makefile updated: 1.3 -> 1.3.4.1 --- Log message: Hard coded subdirectories to build to ensure that they build. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile:1.3 llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile:1.3.4.1 --- llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile:1.3 Fri Sep 12 11:02:35 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile Wed Dec 17 14:35:10 2003 @@ -1,6 +1,7 @@ # MultiSource/Ptrdist Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := anagram bc ft ks yacr2 + include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Wed Dec 17 14:38:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 14:38:01 2003 Subject: [llvm-commits] [release_11] CVS: llvm/CREDITS.TXT Message-ID: <200312172037.OAA29754@choi.cs.uiuc.edu> Changes in directory llvm: CREDITS.TXT updated: 1.7 -> 1.7.2.1 --- Log message: Added Stacker Reid Spencer's contributions. --- Diffs of the changes: (+1 -1) Index: llvm/CREDITS.TXT diff -u llvm/CREDITS.TXT:1.7 llvm/CREDITS.TXT:1.7.2.1 --- llvm/CREDITS.TXT:1.7 Thu Nov 13 23:37:10 2003 +++ llvm/CREDITS.TXT Wed Dec 17 14:37:38 2003 @@ -56,7 +56,7 @@ N: Reid Spencer E: rspencer at x10sys.com W: http://extprosys.sourceforge.net/ -D: Complete 'llvm' namespacification, bug fixes and improvements +D: Complete 'llvm' namespacification, Stacker, bug fixes, and improvements N: Bill Wendling E: wendling at isanbard.org From criswell at cs.uiuc.edu Wed Dec 17 15:05:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 15:05:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/announcement.txt Message-ID: <200312172104.PAA21837@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: announcement.txt updated: 1.3 -> 1.4 --- Log message: Fixed a little punctuation and grammar. --- Diffs of the changes: (+2 -2) Index: llvm-www/releases/1.1/announcement.txt diff -u llvm-www/releases/1.1/announcement.txt:1.3 llvm-www/releases/1.1/announcement.txt:1.4 --- llvm-www/releases/1.1/announcement.txt:1.3 Sun Dec 14 10:27:54 2003 +++ llvm-www/releases/1.1/announcement.txt Wed Dec 17 15:04:43 2003 @@ -11,7 +11,7 @@ and "idle-time" optimization of programs from arbitrary programming languages. LLVM is written in C++ and has been developed over the past 3 years at the University of Illinois. It currently supports compilation of - C and C++ programs, using front-ends derived from GCC 3.4. New front-ends + C and C++ programs using front-ends derived from GCC 3.4. New front-ends are being written for Java bytecode and CAML. The LLVM infrastructure is publicly available under a non-restrictive open @@ -30,7 +30,7 @@ A full list of new features and bug-fixes are listed in the Release Notes: http://llvm.cs.uiuc.edu/releases/1.1/docs/ReleaseNotes.html#whatsnew - For an easier to read set of changes, please see the status updates, see: + For an easier to read set of changes, please see the status updates: http://mail.cs.uiuc.edu/pipermail/llvm-announce/2003-November/000003.html ***** Second 1.1 status update ***** From criswell at cs.uiuc.edu Wed Dec 17 15:23:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 15:23:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/llvm-1.1.tar.gz Message-ID: <200312172122.PAA27193@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: llvm-1.1.tar.gz updated: 1.4 -> 1.5 --- Log message: Fixed some test suite Makefiles to ensure that they always run the tests. Updated the CREDITS file since we've added Stacker while I was at it. --- Diffs of the changes: (+0 -0) Index: llvm-www/releases/1.1/llvm-1.1.tar.gz From brukman at cs.uiuc.edu Wed Dec 17 16:05:02 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 16:05:02 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/Sparc/SparcFrameInfo.cpp SparcFrameInfo.h SparcInstrInfo.h SparcRegInfo.h SparcTargetMachine.h SparcInstrInfo.cpp SparcInstrSelection.cpp SparcInternals.h SparcRegClassInfo.cpp SparcRegInfo.cpp SparcTargetMachine.cpp SparcV9CodeEmitter.cpp UltraSparcSchedInfo.cpp Message-ID: <200312172204.QAA25321@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Sparc: SparcFrameInfo.cpp added (r1.1) SparcFrameInfo.h added (r1.1) SparcInstrInfo.h added (r1.1) SparcRegInfo.h updated: 1.6 -> 1.7 SparcTargetMachine.h added (r1.1) SparcInstrInfo.cpp updated: 1.58 -> 1.59 SparcInstrSelection.cpp updated: 1.127 -> 1.128 SparcInternals.h updated: 1.108 -> 1.109 SparcRegClassInfo.cpp updated: 1.32 -> 1.33 SparcRegInfo.cpp updated: 1.114 -> 1.115 SparcTargetMachine.cpp updated: 1.91 -> 1.92 SparcV9CodeEmitter.cpp updated: 1.46 -> 1.47 UltraSparcSchedInfo.cpp updated: 1.8 -> 1.9 --- Log message: Reorganized the Sparc backend to be more modular -- each different implementation of a Target{RegInfo, InstrInfo, Machine, etc} now has a separate header and a separate implementation file. This means that instead of a massive SparcInternals.h that forces a recompilation of the whole target whenever a minor detail is changed, you should only recompile a few files. Note that SparcInternals.h is still around; its contents should be minimized. --- Diffs of the changes: (+845 -773) Index: llvm/lib/Target/Sparc/SparcFrameInfo.cpp diff -c /dev/null llvm/lib/Target/Sparc/SparcFrameInfo.cpp:1.1 *** /dev/null Wed Dec 17 16:04:11 2003 --- llvm/lib/Target/Sparc/SparcFrameInfo.cpp Wed Dec 17 16:04:00 2003 *************** *** 0 **** --- 1,65 ---- + //===-- Sparc.cpp - General implementation file for the Sparc Target ------===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // Interface to stack frame layout info for the UltraSPARC. Starting offsets + // for each area of the stack frame are aligned at a multiple of + // getStackFrameSizeAlignment(). + // + //===----------------------------------------------------------------------===// + + #include "llvm/CodeGen/MachineFunction.h" + #include "llvm/CodeGen/MachineFunctionInfo.h" + #include "llvm/Target/TargetFrameInfo.h" + #include "SparcFrameInfo.h" + + using namespace llvm; + + int + SparcFrameInfo::getFirstAutomaticVarOffset(MachineFunction&, bool& pos) const { + pos = false; // static stack area grows downwards + return StaticAreaOffsetFromFP; + } + + int + SparcFrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo, bool& pos) const + { + // ensure no more auto vars are added + mcInfo.getInfo()->freezeAutomaticVarsArea(); + + pos = false; // static stack area grows downwards + unsigned autoVarsSize = mcInfo.getInfo()->getAutomaticVarsSize(); + return StaticAreaOffsetFromFP - autoVarsSize; + } + + int SparcFrameInfo::getTmpAreaOffset(MachineFunction& mcInfo, bool& pos) const { + MachineFunctionInfo *MFI = mcInfo.getInfo(); + MFI->freezeAutomaticVarsArea(); // ensure no more auto vars are added + MFI->freezeSpillsArea(); // ensure no more spill slots are added + + pos = false; // static stack area grows downwards + unsigned autoVarsSize = MFI->getAutomaticVarsSize(); + unsigned spillAreaSize = MFI->getRegSpillsSize(); + int offset = autoVarsSize + spillAreaSize; + return StaticAreaOffsetFromFP - offset; + } + + int + SparcFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, bool& pos) const { + // Dynamic stack area grows downwards starting at top of opt-args area. + // The opt-args, required-args, and register-save areas are empty except + // during calls and traps, so they are shifted downwards on each + // dynamic-size alloca. + pos = false; + unsigned optArgsSize = mcInfo.getInfo()->getMaxOptionalArgsSize(); + if (int extra = optArgsSize % getStackFrameSizeAlignment()) + optArgsSize += (getStackFrameSizeAlignment() - extra); + int offset = optArgsSize + FirstOptionalOutgoingArgOffsetFromSP; + assert((offset - OFFSET) % getStackFrameSizeAlignment() == 0); + return offset; + } Index: llvm/lib/Target/Sparc/SparcFrameInfo.h diff -c /dev/null llvm/lib/Target/Sparc/SparcFrameInfo.h:1.1 *** /dev/null Wed Dec 17 16:04:11 2003 --- llvm/lib/Target/Sparc/SparcFrameInfo.h Wed Dec 17 16:04:00 2003 *************** *** 0 **** --- 1,174 ---- + //===-- SparcFrameInfo.h - Define TargetFrameInfo for Sparc -----*- C++ -*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // Interface to stack frame layout info for the UltraSPARC. + // Starting offsets for each area of the stack frame are aligned at + // a multiple of getStackFrameSizeAlignment(). + // + //---------------------------------------------------------------------------- + + #ifndef SPARC_FRAMEINFO_H + #define SPARC_FRAMEINFO_H + + #include "llvm/Target/TargetFrameInfo.h" + #include "llvm/Target/TargetMachine.h" + #include "llvm/Target/TargetRegInfo.h" + + namespace llvm { + + class SparcFrameInfo: public TargetFrameInfo { + const TargetMachine ⌖ + public: + SparcFrameInfo(const TargetMachine &TM) + : TargetFrameInfo(StackGrowsDown, StackFrameSizeAlignment, 0), target(TM) {} + + public: + // These methods provide constant parameters of the frame layout. + // + int getStackFrameSizeAlignment() const { return StackFrameSizeAlignment;} + int getMinStackFrameSize() const { return MinStackFrameSize; } + int getNumFixedOutgoingArgs() const { return NumFixedOutgoingArgs; } + int getSizeOfEachArgOnStack() const { return SizeOfEachArgOnStack; } + bool argsOnStackHaveFixedSize() const { return true; } + + // This method adjusts a stack offset to meet alignment rules of target. + // The fixed OFFSET (0x7ff) must be subtracted and the result aligned. + virtual int adjustAlignment(int unalignedOffset, bool growUp, + unsigned int align) const { + return unalignedOffset + (growUp? +1:-1)*((unalignedOffset-OFFSET) % align); + } + + // These methods compute offsets using the frame contents for a + // particular function. The frame contents are obtained from the + // MachineCodeInfoForMethod object for the given function. + // + int getFirstIncomingArgOffset(MachineFunction& mcInfo, bool& growUp) const { + growUp = true; // arguments area grows upwards + return FirstIncomingArgOffsetFromFP; + } + int getFirstOutgoingArgOffset(MachineFunction& mcInfo, bool& growUp) const { + growUp = true; // arguments area grows upwards + return FirstOutgoingArgOffsetFromSP; + } + int getFirstOptionalOutgoingArgOffset(MachineFunction& mcInfo, + bool& growUp) const { + growUp = true; // arguments area grows upwards + return FirstOptionalOutgoingArgOffsetFromSP; + } + + int getFirstAutomaticVarOffset(MachineFunction& mcInfo, bool& growUp) const; + int getRegSpillAreaOffset(MachineFunction& mcInfo, bool& growUp) const; + int getTmpAreaOffset(MachineFunction& mcInfo, bool& growUp) const; + int getDynamicAreaOffset(MachineFunction& mcInfo, bool& growUp) const; + + // + // These methods specify the base register used for each stack area + // (generally FP or SP) + // + virtual int getIncomingArgBaseRegNum() const { + return (int) target.getRegInfo().getFramePointer(); + } + virtual int getOutgoingArgBaseRegNum() const { + return (int) target.getRegInfo().getStackPointer(); + } + virtual int getOptionalOutgoingArgBaseRegNum() const { + return (int) target.getRegInfo().getStackPointer(); + } + virtual int getAutomaticVarBaseRegNum() const { + return (int) target.getRegInfo().getFramePointer(); + } + virtual int getRegSpillAreaBaseRegNum() const { + return (int) target.getRegInfo().getFramePointer(); + } + virtual int getDynamicAreaBaseRegNum() const { + return (int) target.getRegInfo().getStackPointer(); + } + + virtual int getIncomingArgOffset(MachineFunction& mcInfo, + unsigned argNum) const { + assert(argsOnStackHaveFixedSize()); + + unsigned relativeOffset = argNum * getSizeOfEachArgOnStack(); + bool growUp; // do args grow up or down + int firstArg = getFirstIncomingArgOffset(mcInfo, growUp); + return growUp ? firstArg + relativeOffset : firstArg - relativeOffset; + } + + virtual int getOutgoingArgOffset(MachineFunction& mcInfo, + unsigned argNum) const { + assert(argsOnStackHaveFixedSize()); + //assert(((int) argNum - this->getNumFixedOutgoingArgs()) + // <= (int) mcInfo.getInfo()->getMaxOptionalNumArgs()); + + unsigned relativeOffset = argNum * getSizeOfEachArgOnStack(); + bool growUp; // do args grow up or down + int firstArg = getFirstOutgoingArgOffset(mcInfo, growUp); + return growUp ? firstArg + relativeOffset : firstArg - relativeOffset; + } + + private: + /*---------------------------------------------------------------------- + This diagram shows the stack frame layout used by llc on Sparc V9. + Note that only the location of automatic variables, spill area, + temporary storage, and dynamically allocated stack area are chosen + by us. The rest conform to the Sparc V9 ABI. + All stack addresses are offset by OFFSET = 0x7ff (2047). + + Alignment assumptions and other invariants: + (1) %sp+OFFSET and %fp+OFFSET are always aligned on 16-byte boundary + (2) Variables in automatic, spill, temporary, or dynamic regions + are aligned according to their size as in all memory accesses. + (3) Everything below the dynamically allocated stack area is only used + during a call to another function, so it is never needed when + the current function is active. This is why space can be allocated + dynamically by incrementing %sp any time within the function. + + STACK FRAME LAYOUT: + + ... + %fp+OFFSET+176 Optional extra incoming arguments# 1..N + %fp+OFFSET+168 Incoming argument #6 + ... ... + %fp+OFFSET+128 Incoming argument #1 + ... ... + ---%fp+OFFSET-0--------Bottom of caller's stack frame-------------------- + %fp+OFFSET-8 Automatic variables <-- ****TOP OF STACK FRAME**** + Spill area + Temporary storage + ... + + %sp+OFFSET+176+8N Bottom of dynamically allocated stack area + %sp+OFFSET+168+8N Optional extra outgoing argument# N + ... ... + %sp+OFFSET+176 Optional extra outgoing argument# 1 + %sp+OFFSET+168 Outgoing argument #6 + ... ... + %sp+OFFSET+128 Outgoing argument #1 + %sp+OFFSET+120 Save area for %i7 + ... ... + %sp+OFFSET+0 Save area for %l0 <-- ****BOTTOM OF STACK FRAME**** + + *----------------------------------------------------------------------*/ + + // All stack addresses must be offset by 0x7ff (2047) on Sparc V9. + static const int OFFSET = (int) 0x7ff; + static const int StackFrameSizeAlignment = 16; + static const int MinStackFrameSize = 176; + static const int NumFixedOutgoingArgs = 6; + static const int SizeOfEachArgOnStack = 8; + static const int FirstIncomingArgOffsetFromFP = 128 + OFFSET; + static const int FirstOptionalIncomingArgOffsetFromFP = 176 + OFFSET; + static const int StaticAreaOffsetFromFP = 0 + OFFSET; + static const int FirstOutgoingArgOffsetFromSP = 128 + OFFSET; + static const int FirstOptionalOutgoingArgOffsetFromSP = 176 + OFFSET; + }; + + } // End llvm namespace + + #endif Index: llvm/lib/Target/Sparc/SparcInstrInfo.h diff -c /dev/null llvm/lib/Target/Sparc/SparcInstrInfo.h:1.1 *** /dev/null Wed Dec 17 16:04:11 2003 --- llvm/lib/Target/Sparc/SparcInstrInfo.h Wed Dec 17 16:04:00 2003 *************** *** 0 **** --- 1,201 ---- + //===-- SparcInstrInfo.h - Define TargetInstrInfo for Sparc -----*- C++ -*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This class contains information about individual instructions. + // Most information is stored in the SparcMachineInstrDesc array above. + // Other information is computed on demand, and most such functions + // default to member functions in base class TargetInstrInfo. + // + //===----------------------------------------------------------------------===// + + #ifndef SPARC_INSTRINFO_H + #define SPARC_INSTRINFO_H + + #include "llvm/Target/TargetInstrInfo.h" + #include "llvm/CodeGen/MachineInstr.h" + #include "SparcInternals.h" + + namespace llvm { + + struct SparcInstrInfo : public TargetInstrInfo { + SparcInstrInfo(); + + // All immediate constants are in position 1 except the + // store instructions and SETxx. + // + virtual int getImmedConstantPos(MachineOpCode opCode) const { + bool ignore; + if (this->maxImmedConstant(opCode, ignore) != 0) { + // 1st store opcode + assert(! this->isStore((MachineOpCode) V9::STBr - 1)); + // last store opcode + assert(! this->isStore((MachineOpCode) V9::STXFSRi + 1)); + + if (opCode == V9::SETSW || opCode == V9::SETUW || + opCode == V9::SETX || opCode == V9::SETHI) + return 0; + if (opCode >= V9::STBr && opCode <= V9::STXFSRi) + return 2; + return 1; + } + else + return -1; + } + + /// createNOPinstr - returns the target's implementation of NOP, which is + /// usually a pseudo-instruction, implemented by a degenerate version of + /// another instruction, e.g. X86: xchg ax, ax; SparcV9: sethi 0, g0 + /// + MachineInstr* createNOPinstr() const { + return BuildMI(V9::SETHI, 2).addZImm(0).addReg(SparcIntRegClass::g0); + } + + /// isNOPinstr - not having a special NOP opcode, we need to know if a given + /// instruction is interpreted as an `official' NOP instr, i.e., there may be + /// more than one way to `do nothing' but only one canonical way to slack off. + /// + bool isNOPinstr(const MachineInstr &MI) const { + // Make sure the instruction is EXACTLY `sethi g0, 0' + if (MI.getOpcode() == V9::SETHI && MI.getNumOperands() == 2) { + const MachineOperand &op0 = MI.getOperand(0), &op1 = MI.getOperand(1); + if (op0.isImmediate() && op0.getImmedValue() == 0 && + op1.isMachineRegister() && + op1.getMachineRegNum() == SparcIntRegClass::g0) + { + return true; + } + } + return false; + } + + virtual bool hasResultInterlock(MachineOpCode opCode) const + { + // All UltraSPARC instructions have interlocks (note that delay slots + // are not considered here). + // However, instructions that use the result of an FCMP produce a + // 9-cycle stall if they are issued less than 3 cycles after the FCMP. + // Force the compiler to insert a software interlock (i.e., gap of + // 2 other groups, including NOPs if necessary). + return (opCode == V9::FCMPS || opCode == V9::FCMPD || opCode == V9::FCMPQ); + } + + //------------------------------------------------------------------------- + // Queries about representation of LLVM quantities (e.g., constants) + //------------------------------------------------------------------------- + + virtual bool ConstantMayNotFitInImmedField(const Constant* CV, + const Instruction* I) const; + + //------------------------------------------------------------------------- + // Code generation support for creating individual machine instructions + //------------------------------------------------------------------------- + + // Get certain common op codes for the current target. This and all the + // Create* methods below should be moved to a machine code generation class + // + virtual MachineOpCode getNOPOpCode() const { return V9::NOP; } + + // Get the value of an integral constant in the form that must + // be put into the machine register. The specified constant is interpreted + // as (i.e., converted if necessary to) the specified destination type. The + // result is always returned as an uint64_t, since the representation of + // int64_t and uint64_t are identical. The argument can be any known const. + // + // isValidConstant is set to true if a valid constant was found. + // + virtual uint64_t ConvertConstantToIntType(const TargetMachine &target, + const Value *V, + const Type *destType, + bool &isValidConstant) const; + + // Create an instruction sequence to put the constant `val' into + // the virtual register `dest'. `val' may be a Constant or a + // GlobalValue, viz., the constant address of a global variable or function. + // The generated instructions are returned in `mvec'. + // Any temp. registers (TmpInstruction) created are recorded in mcfi. + // Any stack space required is allocated via mcff. + // + virtual void CreateCodeToLoadConst(const TargetMachine& target, + Function* F, + Value* val, + Instruction* dest, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const; + + // Create an instruction sequence to copy an integer value `val' + // to a floating point value `dest' by copying to memory and back. + // val must be an integral type. dest must be a Float or Double. + // The generated instructions are returned in `mvec'. + // Any temp. registers (TmpInstruction) created are recorded in mcfi. + // Any stack space required is allocated via mcff. + // + virtual void CreateCodeToCopyIntToFloat(const TargetMachine& target, + Function* F, + Value* val, + Instruction* dest, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const; + + // Similarly, create an instruction sequence to copy an FP value + // `val' to an integer value `dest' by copying to memory and back. + // The generated instructions are returned in `mvec'. + // Any temp. registers (TmpInstruction) created are recorded in mcfi. + // Any stack space required is allocated via mcff. + // + virtual void CreateCodeToCopyFloatToInt(const TargetMachine& target, + Function* F, + Value* val, + Instruction* dest, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const; + + // Create instruction(s) to copy src to dest, for arbitrary types + // The generated instructions are returned in `mvec'. + // Any temp. registers (TmpInstruction) created are recorded in mcfi. + // Any stack space required is allocated via mcff. + // + virtual void CreateCopyInstructionsByType(const TargetMachine& target, + Function* F, + Value* src, + Instruction* dest, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const; + + // Create instruction sequence to produce a sign-extended register value + // from an arbitrary sized value (sized in bits, not bytes). + // The generated instructions are appended to `mvec'. + // Any temp. registers (TmpInstruction) created are recorded in mcfi. + // Any stack space required is allocated via mcff. + // + virtual void CreateSignExtensionInstructions(const TargetMachine& target, + Function* F, + Value* srcVal, + Value* destVal, + unsigned int numLowBits, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const; + + // Create instruction sequence to produce a zero-extended register value + // from an arbitrary sized value (sized in bits, not bytes). + // The generated instructions are appended to `mvec'. + // Any temp. registers (TmpInstruction) created are recorded in mcfi. + // Any stack space required is allocated via mcff. + // + virtual void CreateZeroExtensionInstructions(const TargetMachine& target, + Function* F, + Value* srcVal, + Value* destVal, + unsigned int numLowBits, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const; + }; + + } // End llvm namespace + + #endif Index: llvm/lib/Target/Sparc/SparcRegInfo.h diff -u /dev/null llvm/lib/Target/Sparc/SparcRegInfo.h:1.7 --- /dev/null Wed Dec 17 16:04:11 2003 +++ llvm/lib/Target/Sparc/SparcRegInfo.h Wed Dec 17 16:04:00 2003 @@ -0,0 +1,190 @@ +//===-- SparcRegInfo.h - Define TargetRegInfo for Sparc ---------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This class implements the virtual class TargetRegInfo for Sparc. +// +//---------------------------------------------------------------------------- + +#ifndef SPARC_REGINFO_H +#define SPARC_REGINFO_H + +namespace llvm { + +class SparcRegInfo : public TargetRegInfo { + +private: + + // Number of registers used for passing int args (usually 6: %o0 - %o5) + // + unsigned const NumOfIntArgRegs; + + // Number of registers used for passing float args (usually 32: %f0 - %f31) + // + unsigned const NumOfFloatArgRegs; + + // The following methods are used to color special live ranges (e.g. + // function args and return values etc.) with specific hardware registers + // as required. See SparcRegInfo.cpp for the implementation. + // + void suggestReg4RetAddr(MachineInstr *RetMI, + LiveRangeInfo &LRI) const; + + void suggestReg4CallAddr(MachineInstr *CallMI, LiveRangeInfo &LRI) const; + + // Helper used by the all the getRegType() functions. + int getRegTypeForClassAndType(unsigned regClassID, const Type* type) const; + +public: + // Type of registers available in Sparc. There can be several reg types + // in the same class. For instace, the float reg class has Single/Double + // types + // + enum RegTypes { + IntRegType, + FPSingleRegType, + FPDoubleRegType, + IntCCRegType, + FloatCCRegType, + SpecialRegType + }; + + // The actual register classes in the Sparc + // + // **** WARNING: If this enum order is changed, also modify + // getRegisterClassOfValue method below since it assumes this particular + // order for efficiency. + // + enum RegClassIDs { + IntRegClassID, // Integer + FloatRegClassID, // Float (both single/double) + IntCCRegClassID, // Int Condition Code + FloatCCRegClassID, // Float Condition code + SpecialRegClassID // Special (unallocated) registers + }; + + SparcRegInfo(const SparcTargetMachine &tgt); + + // To find the register class used for a specified Type + // + unsigned getRegClassIDOfType(const Type *type, + bool isCCReg = false) const; + + // To find the register class to which a specified register belongs + // + unsigned getRegClassIDOfRegType(int regType) const; + + // getZeroRegNum - returns the register that contains always zero this is the + // unified register number + // + virtual int getZeroRegNum() const; + + // getCallAddressReg - returns the reg used for pushing the address when a + // function is called. This can be used for other purposes between calls + // + unsigned getCallAddressReg() const; + + // Returns the register containing the return address. + // It should be made sure that this register contains the return + // value when a return instruction is reached. + // + unsigned getReturnAddressReg() const; + + // Number of registers used for passing int args (usually 6: %o0 - %o5) + // and float args (usually 32: %f0 - %f31) + // + unsigned const getNumOfIntArgRegs() const { return NumOfIntArgRegs; } + unsigned const getNumOfFloatArgRegs() const { return NumOfFloatArgRegs; } + + // Compute which register can be used for an argument, if any + // + int regNumForIntArg(bool inCallee, bool isVarArgsCall, + unsigned argNo, unsigned& regClassId) const; + + int regNumForFPArg(unsigned RegType, bool inCallee, bool isVarArgsCall, + unsigned argNo, unsigned& regClassId) const; + + // The following methods are used to color special live ranges (e.g. + // function args and return values etc.) with specific hardware registers + // as required. See SparcRegInfo.cpp for the implementation for Sparc. + // + void suggestRegs4MethodArgs(const Function *Meth, + LiveRangeInfo& LRI) const; + + void suggestRegs4CallArgs(MachineInstr *CallMI, + LiveRangeInfo& LRI) const; + + void suggestReg4RetValue(MachineInstr *RetMI, + LiveRangeInfo& LRI) const; + + void colorMethodArgs(const Function *Meth, LiveRangeInfo& LRI, + std::vector& InstrnsBefore, + std::vector& InstrnsAfter) const; + + // method used for printing a register for debugging purposes + // + void printReg(const LiveRange *LR) const; + + // returns the # of bytes of stack space allocated for each register + // type. For Sparc, currently we allocate 8 bytes on stack for all + // register types. We can optimize this later if necessary to save stack + // space (However, should make sure that stack alignment is correct) + // + inline int getSpilledRegSize(int RegType) const { + return 8; + } + + + // To obtain the return value and the indirect call address (if any) + // contained in a CALL machine instruction + // + const Value * getCallInstRetVal(const MachineInstr *CallMI) const; + const Value * getCallInstIndirectAddrVal(const MachineInstr *CallMI) const; + + // The following methods are used to generate "copy" machine instructions + // for an architecture. + // + // The function regTypeNeedsScratchReg() can be used to check whether a + // scratch register is needed to copy a register of type `regType' to + // or from memory. If so, such a scratch register can be provided by + // the caller (e.g., if it knows which regsiters are free); otherwise + // an arbitrary one will be chosen and spilled by the copy instructions. + // + bool regTypeNeedsScratchReg(int RegType, + int& scratchRegClassId) const; + + void cpReg2RegMI(std::vector& mvec, + unsigned SrcReg, unsigned DestReg, + int RegType) const; + + void cpReg2MemMI(std::vector& mvec, + unsigned SrcReg, unsigned DestPtrReg, + int Offset, int RegType, int scratchReg = -1) const; + + void cpMem2RegMI(std::vector& mvec, + unsigned SrcPtrReg, int Offset, unsigned DestReg, + int RegType, int scratchReg = -1) const; + + void cpValue2Value(Value *Src, Value *Dest, + std::vector& mvec) const; + + // Get the register type for a register identified different ways. + // Note that getRegTypeForLR(LR) != getRegTypeForDataType(LR->getType())! + // The reg class of a LR depends both on the Value types in it and whether + // they are CC registers or not (for example). + int getRegTypeForDataType(const Type* type) const; + int getRegTypeForLR(const LiveRange *LR) const; + int getRegType(int unifiedRegNum) const; + + virtual unsigned getFramePointer() const; + virtual unsigned getStackPointer() const; +}; + +} // End llvm namespace + +#endif Index: llvm/lib/Target/Sparc/SparcTargetMachine.h diff -c /dev/null llvm/lib/Target/Sparc/SparcTargetMachine.h:1.1 *** /dev/null Wed Dec 17 16:04:11 2003 --- llvm/lib/Target/Sparc/SparcTargetMachine.h Wed Dec 17 16:04:00 2003 *************** *** 0 **** --- 1,59 ---- + //===-- SparcTargetMachine.h - Define TargetMachine for Sparc ---*- C++ -*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file declares the primary interface to machine description for the + // UltraSPARC. + // + //===----------------------------------------------------------------------===// + + #ifndef SPARC_TARGETMACHINE_H + #define SPARC_TARGETMACHINE_H + + #include "llvm/PassManager.h" + #include "llvm/Target/TargetFrameInfo.h" + #include "llvm/Target/TargetMachine.h" + #include "SparcInstrInfo.h" + #include "SparcInternals.h" + #include "SparcRegInfo.h" + #include "SparcFrameInfo.h" + + namespace llvm { + + class SparcTargetMachine : public TargetMachine { + SparcInstrInfo instrInfo; + SparcSchedInfo schedInfo; + SparcRegInfo regInfo; + SparcFrameInfo frameInfo; + SparcCacheInfo cacheInfo; + public: + SparcTargetMachine(); + + virtual const TargetInstrInfo &getInstrInfo() const { return instrInfo; } + virtual const TargetSchedInfo &getSchedInfo() const { return schedInfo; } + virtual const TargetRegInfo &getRegInfo() const { return regInfo; } + virtual const TargetFrameInfo &getFrameInfo() const { return frameInfo; } + virtual const TargetCacheInfo &getCacheInfo() const { return cacheInfo; } + + virtual bool addPassesToEmitAssembly(PassManager &PM, std::ostream &Out); + virtual bool addPassesToJITCompile(FunctionPassManager &PM); + virtual bool addPassesToEmitMachineCode(FunctionPassManager &PM, + MachineCodeEmitter &MCE); + virtual void replaceMachineCodeForFunction(void *Old, void *New); + + /// getJITStubForFunction - Create or return a stub for the specified + /// function. This stub acts just like the specified function, except that it + /// allows the "address" of the function to be taken without having to + /// generate code for it. + /// + ///virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE); + }; + + } // End llvm namespace + + #endif Index: llvm/lib/Target/Sparc/SparcInstrInfo.cpp diff -u llvm/lib/Target/Sparc/SparcInstrInfo.cpp:1.58 llvm/lib/Target/Sparc/SparcInstrInfo.cpp:1.59 --- llvm/lib/Target/Sparc/SparcInstrInfo.cpp:1.58 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/SparcInstrInfo.cpp Wed Dec 17 16:04:00 2003 @@ -9,8 +9,6 @@ // //===----------------------------------------------------------------------===// -#include "SparcInternals.h" -#include "SparcInstrSelectionSupport.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" @@ -22,6 +20,9 @@ #include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/MachineInstrBuilder.h" +#include "SparcInternals.h" +#include "SparcInstrSelectionSupport.h" +#include "SparcInstrInfo.h" namespace llvm { @@ -41,7 +42,7 @@ //--------------------------------------------------------------------------- uint64_t -UltraSparcInstrInfo::ConvertConstantToIntType(const TargetMachine &target, +SparcInstrInfo::ConvertConstantToIntType(const TargetMachine &target, const Value *V, const Type *destType, bool &isValidConstant) const @@ -406,7 +407,7 @@ //--------------------------------------------------------------------------- -// class UltraSparcInstrInfo +// class SparcInstrInfo // // Purpose: // Information about individual instructions. @@ -416,7 +417,7 @@ //--------------------------------------------------------------------------- /*ctor*/ -UltraSparcInstrInfo::UltraSparcInstrInfo() +SparcInstrInfo::SparcInstrInfo() : TargetInstrInfo(SparcMachineInstrDesc, /*descSize = */ V9::NUM_TOTAL_OPCODES, /*numRealOpCodes = */ V9::NUM_REAL_OPCODES) @@ -425,7 +426,7 @@ } bool -UltraSparcInstrInfo::ConstantMayNotFitInImmedField(const Constant* CV, +SparcInstrInfo::ConstantMayNotFitInImmedField(const Constant* CV, const Instruction* I) const { if (I->getOpcode() >= MaxConstantsTable.size()) // user-defined op (or bug!) @@ -455,12 +456,12 @@ // Any stack space required is allocated via MachineFunction. // void -UltraSparcInstrInfo::CreateCodeToLoadConst(const TargetMachine& target, - Function* F, - Value* val, - Instruction* dest, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const +SparcInstrInfo::CreateCodeToLoadConst(const TargetMachine& target, + Function* F, + Value* val, + Instruction* dest, + std::vector& mvec, + MachineCodeForInstruction& mcfi) const { assert(isa(val) || isa(val) && "I only know about constant values and global addresses"); @@ -552,7 +553,7 @@ // Any stack space required is allocated via MachineFunction. // void -UltraSparcInstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target, +SparcInstrInfo::CreateCodeToCopyIntToFloat(const TargetMachine& target, Function* F, Value* val, Instruction* dest, @@ -613,7 +614,7 @@ // Temporary stack space required is allocated via MachineFunction. // void -UltraSparcInstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target, +SparcInstrInfo::CreateCodeToCopyFloatToInt(const TargetMachine& target, Function* F, Value* val, Instruction* dest, @@ -664,11 +665,11 @@ // Any stack space required is allocated via MachineFunction. // void -UltraSparcInstrInfo::CreateCopyInstructionsByType(const TargetMachine& target, - Function *F, - Value* src, - Instruction* dest, - std::vector& mvec, +SparcInstrInfo::CreateCopyInstructionsByType(const TargetMachine& target, + Function *F, + Value* src, + Instruction* dest, + std::vector& mvec, MachineCodeForInstruction& mcfi) const { bool loadConstantToReg = false; @@ -760,7 +761,7 @@ // Any stack space required is allocated via MachineFunction. // void -UltraSparcInstrInfo::CreateSignExtensionInstructions( +SparcInstrInfo::CreateSignExtensionInstructions( const TargetMachine& target, Function* F, Value* srcVal, @@ -782,7 +783,7 @@ // Any stack space required is allocated via MachineFunction. // void -UltraSparcInstrInfo::CreateZeroExtensionInstructions( +SparcInstrInfo::CreateZeroExtensionInstructions( const TargetMachine& target, Function* F, Value* srcVal, Index: llvm/lib/Target/Sparc/SparcInstrSelection.cpp diff -u llvm/lib/Target/Sparc/SparcInstrSelection.cpp:1.127 llvm/lib/Target/Sparc/SparcInstrSelection.cpp:1.128 --- llvm/lib/Target/Sparc/SparcInstrSelection.cpp:1.127 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/SparcInstrSelection.cpp Wed Dec 17 16:04:00 2003 @@ -11,9 +11,6 @@ // //===----------------------------------------------------------------------===// -#include "SparcInstrSelectionSupport.h" -#include "SparcInternals.h" -#include "SparcRegClassInfo.h" #include "llvm/Constants.h" #include "llvm/ConstantHandling.h" #include "llvm/DerivedTypes.h" @@ -28,6 +25,10 @@ #include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/CodeGen/MachineInstrBuilder.h" #include "llvm/CodeGen/MachineInstrAnnot.h" +#include "SparcInstrSelectionSupport.h" +#include "SparcInternals.h" +#include "SparcRegClassInfo.h" +#include "SparcRegInfo.h" #include "Support/MathExtras.h" #include #include @@ -1583,8 +1584,8 @@ // -- For non-FP values, create an add-with-0 instruction // if (retVal != NULL) { - const UltraSparcRegInfo& regInfo = - (UltraSparcRegInfo&) target.getRegInfo(); + const SparcRegInfo& regInfo = + (SparcRegInfo&) target.getRegInfo(); const Type* retType = retVal->getType(); unsigned regClassID = regInfo.getRegClassIDOfType(retType); unsigned retRegNum = (retType->isFloatingPoint() @@ -2488,8 +2489,8 @@ MachineFunction& MF = MachineFunction::get(currentFunc); MachineCodeForInstruction& mcfi = MachineCodeForInstruction::get(callInstr); - const UltraSparcRegInfo& regInfo = - (UltraSparcRegInfo&) target.getRegInfo(); + const SparcRegInfo& regInfo = + (SparcRegInfo&) target.getRegInfo(); const TargetFrameInfo& frameInfo = target.getFrameInfo(); // Create hidden virtual register for return address with type void* Index: llvm/lib/Target/Sparc/SparcInternals.h diff -u llvm/lib/Target/Sparc/SparcInternals.h:1.108 llvm/lib/Target/Sparc/SparcInternals.h:1.109 --- llvm/lib/Target/Sparc/SparcInternals.h:1.108 Wed Nov 12 18:17:20 2003 +++ llvm/lib/Target/Sparc/SparcInternals.h Wed Dec 17 16:04:00 2003 @@ -28,7 +28,7 @@ namespace llvm { class LiveRange; -class UltraSparc; +class SparcTargetMachine; class Pass; enum SparcInstrSchedClass { @@ -71,571 +71,34 @@ }; } - // Array of machine instruction descriptions... extern const TargetInstrDescriptor SparcMachineInstrDesc[]; - //--------------------------------------------------------------------------- -// class UltraSparcInstrInfo -// -// Purpose: -// Information about individual instructions. -// Most information is stored in the SparcMachineInstrDesc array above. -// Other information is computed on demand, and most such functions -// default to member functions in base class TargetInstrInfo. -//--------------------------------------------------------------------------- - -struct UltraSparcInstrInfo : public TargetInstrInfo { - UltraSparcInstrInfo(); - - // - // All immediate constants are in position 1 except the - // store instructions and SETxx. - // - virtual int getImmedConstantPos(MachineOpCode opCode) const { - bool ignore; - if (this->maxImmedConstant(opCode, ignore) != 0) { - // 1st store opcode - assert(! this->isStore((MachineOpCode) V9::STBr - 1)); - // last store opcode - assert(! this->isStore((MachineOpCode) V9::STXFSRi + 1)); - - if (opCode == V9::SETSW || opCode == V9::SETUW || - opCode == V9::SETX || opCode == V9::SETHI) - return 0; - if (opCode >= V9::STBr && opCode <= V9::STXFSRi) - return 2; - return 1; - } - else - return -1; - } - - /// createNOPinstr - returns the target's implementation of NOP, which is - /// usually a pseudo-instruction, implemented by a degenerate version of - /// another instruction, e.g. X86: xchg ax, ax; SparcV9: sethi 0, g0 - /// - MachineInstr* createNOPinstr() const { - return BuildMI(V9::SETHI, 2).addZImm(0).addReg(SparcIntRegClass::g0); - } - - /// isNOPinstr - not having a special NOP opcode, we need to know if a given - /// instruction is interpreted as an `official' NOP instr, i.e., there may be - /// more than one way to `do nothing' but only one canonical way to slack off. - /// - bool isNOPinstr(const MachineInstr &MI) const { - // Make sure the instruction is EXACTLY `sethi g0, 0' - if (MI.getOpcode() == V9::SETHI && MI.getNumOperands() == 2) { - const MachineOperand &op0 = MI.getOperand(0), &op1 = MI.getOperand(1); - if (op0.isImmediate() && op0.getImmedValue() == 0 && - op1.isMachineRegister() && - op1.getMachineRegNum() == SparcIntRegClass::g0) - { - return true; - } - } - return false; - } - - virtual bool hasResultInterlock(MachineOpCode opCode) const - { - // All UltraSPARC instructions have interlocks (note that delay slots - // are not considered here). - // However, instructions that use the result of an FCMP produce a - // 9-cycle stall if they are issued less than 3 cycles after the FCMP. - // Force the compiler to insert a software interlock (i.e., gap of - // 2 other groups, including NOPs if necessary). - return (opCode == V9::FCMPS || opCode == V9::FCMPD || opCode == V9::FCMPQ); - } - - //------------------------------------------------------------------------- - // Queries about representation of LLVM quantities (e.g., constants) - //------------------------------------------------------------------------- - - virtual bool ConstantMayNotFitInImmedField(const Constant* CV, - const Instruction* I) const; - - //------------------------------------------------------------------------- - // Code generation support for creating individual machine instructions - //------------------------------------------------------------------------- - - // Get certain common op codes for the current target. This and all the - // Create* methods below should be moved to a machine code generation class - // - virtual MachineOpCode getNOPOpCode() const { return V9::NOP; } - - // Get the value of an integral constant in the form that must - // be put into the machine register. The specified constant is interpreted - // as (i.e., converted if necessary to) the specified destination type. The - // result is always returned as an uint64_t, since the representation of - // int64_t and uint64_t are identical. The argument can be any known const. - // - // isValidConstant is set to true if a valid constant was found. - // - virtual uint64_t ConvertConstantToIntType(const TargetMachine &target, - const Value *V, - const Type *destType, - bool &isValidConstant) const; - - // Create an instruction sequence to put the constant `val' into - // the virtual register `dest'. `val' may be a Constant or a - // GlobalValue, viz., the constant address of a global variable or function. - // The generated instructions are returned in `mvec'. - // Any temp. registers (TmpInstruction) created are recorded in mcfi. - // Any stack space required is allocated via mcff. - // - virtual void CreateCodeToLoadConst(const TargetMachine& target, - Function* F, - Value* val, - Instruction* dest, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const; - - // Create an instruction sequence to copy an integer value `val' - // to a floating point value `dest' by copying to memory and back. - // val must be an integral type. dest must be a Float or Double. - // The generated instructions are returned in `mvec'. - // Any temp. registers (TmpInstruction) created are recorded in mcfi. - // Any stack space required is allocated via mcff. - // - virtual void CreateCodeToCopyIntToFloat(const TargetMachine& target, - Function* F, - Value* val, - Instruction* dest, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const; - - // Similarly, create an instruction sequence to copy an FP value - // `val' to an integer value `dest' by copying to memory and back. - // The generated instructions are returned in `mvec'. - // Any temp. registers (TmpInstruction) created are recorded in mcfi. - // Any stack space required is allocated via mcff. - // - virtual void CreateCodeToCopyFloatToInt(const TargetMachine& target, - Function* F, - Value* val, - Instruction* dest, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const; - - // Create instruction(s) to copy src to dest, for arbitrary types - // The generated instructions are returned in `mvec'. - // Any temp. registers (TmpInstruction) created are recorded in mcfi. - // Any stack space required is allocated via mcff. - // - virtual void CreateCopyInstructionsByType(const TargetMachine& target, - Function* F, - Value* src, - Instruction* dest, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const; - - // Create instruction sequence to produce a sign-extended register value - // from an arbitrary sized value (sized in bits, not bytes). - // The generated instructions are appended to `mvec'. - // Any temp. registers (TmpInstruction) created are recorded in mcfi. - // Any stack space required is allocated via mcff. - // - virtual void CreateSignExtensionInstructions(const TargetMachine& target, - Function* F, - Value* srcVal, - Value* destVal, - unsigned int numLowBits, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const; - - // Create instruction sequence to produce a zero-extended register value - // from an arbitrary sized value (sized in bits, not bytes). - // The generated instructions are appended to `mvec'. - // Any temp. registers (TmpInstruction) created are recorded in mcfi. - // Any stack space required is allocated via mcff. - // - virtual void CreateZeroExtensionInstructions(const TargetMachine& target, - Function* F, - Value* srcVal, - Value* destVal, - unsigned int numLowBits, - std::vector& mvec, - MachineCodeForInstruction& mcfi) const; -}; - - -//---------------------------------------------------------------------------- -// class UltraSparcRegInfo -// -// This class implements the virtual class TargetRegInfo for Sparc. -// -//---------------------------------------------------------------------------- - -class UltraSparcRegInfo : public TargetRegInfo { - -private: - - // Number of registers used for passing int args (usually 6: %o0 - %o5) - // - unsigned const NumOfIntArgRegs; - - // Number of registers used for passing float args (usually 32: %f0 - %f31) - // - unsigned const NumOfFloatArgRegs; - - // ======================== Private Methods ============================= - - // The following methods are used to color special live ranges (e.g. - // function args and return values etc.) with specific hardware registers - // as required. See SparcRegInfo.cpp for the implementation. - // - void suggestReg4RetAddr(MachineInstr *RetMI, - LiveRangeInfo &LRI) const; - - void suggestReg4CallAddr(MachineInstr *CallMI, LiveRangeInfo &LRI) const; - - // Helper used by the all the getRegType() functions. - int getRegTypeForClassAndType(unsigned regClassID, const Type* type) const; - -public: - // Type of registers available in Sparc. There can be several reg types - // in the same class. For instace, the float reg class has Single/Double - // types - // - enum RegTypes { - IntRegType, - FPSingleRegType, - FPDoubleRegType, - IntCCRegType, - FloatCCRegType, - SpecialRegType - }; - - // The actual register classes in the Sparc - // - // **** WARNING: If this enum order is changed, also modify - // getRegisterClassOfValue method below since it assumes this particular - // order for efficiency. - // - enum RegClassIDs { - IntRegClassID, // Integer - FloatRegClassID, // Float (both single/double) - IntCCRegClassID, // Int Condition Code - FloatCCRegClassID, // Float Condition code - SpecialRegClassID // Special (unallocated) registers - }; - - UltraSparcRegInfo(const UltraSparc &tgt); - - // To find the register class used for a specified Type - // - unsigned getRegClassIDOfType(const Type *type, - bool isCCReg = false) const; - - // To find the register class to which a specified register belongs - // - unsigned getRegClassIDOfRegType(int regType) const; - - // getZeroRegNum - returns the register that contains always zero this is the - // unified register number - // - virtual int getZeroRegNum() const; - - // getCallAddressReg - returns the reg used for pushing the address when a - // function is called. This can be used for other purposes between calls - // - unsigned getCallAddressReg() const; - - // Returns the register containing the return address. - // It should be made sure that this register contains the return - // value when a return instruction is reached. - // - unsigned getReturnAddressReg() const; - - // Number of registers used for passing int args (usually 6: %o0 - %o5) - // and float args (usually 32: %f0 - %f31) - // - unsigned const getNumOfIntArgRegs() const { return NumOfIntArgRegs; } - unsigned const getNumOfFloatArgRegs() const { return NumOfFloatArgRegs; } - - // Compute which register can be used for an argument, if any - // - int regNumForIntArg(bool inCallee, bool isVarArgsCall, - unsigned argNo, unsigned& regClassId) const; - - int regNumForFPArg(unsigned RegType, bool inCallee, bool isVarArgsCall, - unsigned argNo, unsigned& regClassId) const; - - // The following methods are used to color special live ranges (e.g. - // function args and return values etc.) with specific hardware registers - // as required. See SparcRegInfo.cpp for the implementation for Sparc. - // - void suggestRegs4MethodArgs(const Function *Meth, - LiveRangeInfo& LRI) const; - - void suggestRegs4CallArgs(MachineInstr *CallMI, - LiveRangeInfo& LRI) const; - - void suggestReg4RetValue(MachineInstr *RetMI, - LiveRangeInfo& LRI) const; - - void colorMethodArgs(const Function *Meth, LiveRangeInfo& LRI, - std::vector& InstrnsBefore, - std::vector& InstrnsAfter) const; - - // method used for printing a register for debugging purposes - // - void printReg(const LiveRange *LR) const; - - // returns the # of bytes of stack space allocated for each register - // type. For Sparc, currently we allocate 8 bytes on stack for all - // register types. We can optimize this later if necessary to save stack - // space (However, should make sure that stack alignment is correct) - // - inline int getSpilledRegSize(int RegType) const { - return 8; - } - - - // To obtain the return value and the indirect call address (if any) - // contained in a CALL machine instruction - // - const Value * getCallInstRetVal(const MachineInstr *CallMI) const; - const Value * getCallInstIndirectAddrVal(const MachineInstr *CallMI) const; - - // The following methods are used to generate "copy" machine instructions - // for an architecture. - // - // The function regTypeNeedsScratchReg() can be used to check whether a - // scratch register is needed to copy a register of type `regType' to - // or from memory. If so, such a scratch register can be provided by - // the caller (e.g., if it knows which regsiters are free); otherwise - // an arbitrary one will be chosen and spilled by the copy instructions. - // - bool regTypeNeedsScratchReg(int RegType, - int& scratchRegClassId) const; - - void cpReg2RegMI(std::vector& mvec, - unsigned SrcReg, unsigned DestReg, - int RegType) const; - - void cpReg2MemMI(std::vector& mvec, - unsigned SrcReg, unsigned DestPtrReg, - int Offset, int RegType, int scratchReg = -1) const; - - void cpMem2RegMI(std::vector& mvec, - unsigned SrcPtrReg, int Offset, unsigned DestReg, - int RegType, int scratchReg = -1) const; - - void cpValue2Value(Value *Src, Value *Dest, - std::vector& mvec) const; - - // Get the register type for a register identified different ways. - // Note that getRegTypeForLR(LR) != getRegTypeForDataType(LR->getType())! - // The reg class of a LR depends both on the Value types in it and whether - // they are CC registers or not (for example). - int getRegTypeForDataType(const Type* type) const; - int getRegTypeForLR(const LiveRange *LR) const; - int getRegType(int unifiedRegNum) const; - - virtual unsigned getFramePointer() const; - virtual unsigned getStackPointer() const; -}; - - - - -//--------------------------------------------------------------------------- -// class UltraSparcSchedInfo +// class SparcSchedInfo // // Purpose: // Interface to instruction scheduling information for UltraSPARC. // The parameter values above are based on UltraSPARC IIi. //--------------------------------------------------------------------------- - -class UltraSparcSchedInfo: public TargetSchedInfo { +class SparcSchedInfo: public TargetSchedInfo { public: - UltraSparcSchedInfo(const TargetMachine &tgt); + SparcSchedInfo(const TargetMachine &tgt); protected: virtual void initializeResources(); }; - -//--------------------------------------------------------------------------- -// class UltraSparcFrameInfo -// -// Purpose: -// Interface to stack frame layout info for the UltraSPARC. -// Starting offsets for each area of the stack frame are aligned at -// a multiple of getStackFrameSizeAlignment(). -//--------------------------------------------------------------------------- - -class UltraSparcFrameInfo: public TargetFrameInfo { - const TargetMachine ⌖ -public: - UltraSparcFrameInfo(const TargetMachine &TM) - : TargetFrameInfo(StackGrowsDown, StackFrameSizeAlignment, 0), target(TM) {} - -public: - // These methods provide constant parameters of the frame layout. - // - int getStackFrameSizeAlignment() const { return StackFrameSizeAlignment;} - int getMinStackFrameSize() const { return MinStackFrameSize; } - int getNumFixedOutgoingArgs() const { return NumFixedOutgoingArgs; } - int getSizeOfEachArgOnStack() const { return SizeOfEachArgOnStack; } - bool argsOnStackHaveFixedSize() const { return true; } - - // This method adjusts a stack offset to meet alignment rules of target. - // The fixed OFFSET (0x7ff) must be subtracted and the result aligned. - virtual int adjustAlignment (int unalignedOffset, - bool growUp, - unsigned int align) const { - return unalignedOffset + (growUp? +1:-1)*((unalignedOffset-OFFSET) % align); - } - - // These methods compute offsets using the frame contents for a - // particular function. The frame contents are obtained from the - // MachineCodeInfoForMethod object for the given function. - // - int getFirstIncomingArgOffset (MachineFunction& mcInfo, - bool& growUp) const - { - growUp = true; // arguments area grows upwards - return FirstIncomingArgOffsetFromFP; - } - int getFirstOutgoingArgOffset (MachineFunction& mcInfo, - bool& growUp) const - { - growUp = true; // arguments area grows upwards - return FirstOutgoingArgOffsetFromSP; - } - int getFirstOptionalOutgoingArgOffset(MachineFunction& mcInfo, - bool& growUp)const - { - growUp = true; // arguments area grows upwards - return FirstOptionalOutgoingArgOffsetFromSP; - } - - int getFirstAutomaticVarOffset (MachineFunction& mcInfo, - bool& growUp) const; - int getRegSpillAreaOffset (MachineFunction& mcInfo, - bool& growUp) const; - int getTmpAreaOffset (MachineFunction& mcInfo, - bool& growUp) const; - int getDynamicAreaOffset (MachineFunction& mcInfo, - bool& growUp) const; - - // - // These methods specify the base register used for each stack area - // (generally FP or SP) - // - virtual int getIncomingArgBaseRegNum() const { - return (int) target.getRegInfo().getFramePointer(); - } - virtual int getOutgoingArgBaseRegNum() const { - return (int) target.getRegInfo().getStackPointer(); - } - virtual int getOptionalOutgoingArgBaseRegNum() const { - return (int) target.getRegInfo().getStackPointer(); - } - virtual int getAutomaticVarBaseRegNum() const { - return (int) target.getRegInfo().getFramePointer(); - } - virtual int getRegSpillAreaBaseRegNum() const { - return (int) target.getRegInfo().getFramePointer(); - } - virtual int getDynamicAreaBaseRegNum() const { - return (int) target.getRegInfo().getStackPointer(); - } - - virtual int getIncomingArgOffset(MachineFunction& mcInfo, - unsigned argNum) const { - assert(argsOnStackHaveFixedSize()); - - unsigned relativeOffset = argNum * getSizeOfEachArgOnStack(); - bool growUp; // do args grow up or down - int firstArg = getFirstIncomingArgOffset(mcInfo, growUp); - return growUp ? firstArg + relativeOffset : firstArg - relativeOffset; - } - - virtual int getOutgoingArgOffset(MachineFunction& mcInfo, - unsigned argNum) const { - assert(argsOnStackHaveFixedSize()); - //assert(((int) argNum - this->getNumFixedOutgoingArgs()) - // <= (int) mcInfo.getInfo()->getMaxOptionalNumArgs()); - - unsigned relativeOffset = argNum * getSizeOfEachArgOnStack(); - bool growUp; // do args grow up or down - int firstArg = getFirstOutgoingArgOffset(mcInfo, growUp); - return growUp ? firstArg + relativeOffset : firstArg - relativeOffset; - } - -private: - /*---------------------------------------------------------------------- - This diagram shows the stack frame layout used by llc on Sparc V9. - Note that only the location of automatic variables, spill area, - temporary storage, and dynamically allocated stack area are chosen - by us. The rest conform to the Sparc V9 ABI. - All stack addresses are offset by OFFSET = 0x7ff (2047). - - Alignment assumptions and other invariants: - (1) %sp+OFFSET and %fp+OFFSET are always aligned on 16-byte boundary - (2) Variables in automatic, spill, temporary, or dynamic regions - are aligned according to their size as in all memory accesses. - (3) Everything below the dynamically allocated stack area is only used - during a call to another function, so it is never needed when - the current function is active. This is why space can be allocated - dynamically by incrementing %sp any time within the function. - - STACK FRAME LAYOUT: - - ... - %fp+OFFSET+176 Optional extra incoming arguments# 1..N - %fp+OFFSET+168 Incoming argument #6 - ... ... - %fp+OFFSET+128 Incoming argument #1 - ... ... - ---%fp+OFFSET-0--------Bottom of caller's stack frame-------------------- - %fp+OFFSET-8 Automatic variables <-- ****TOP OF STACK FRAME**** - Spill area - Temporary storage - ... - - %sp+OFFSET+176+8N Bottom of dynamically allocated stack area - %sp+OFFSET+168+8N Optional extra outgoing argument# N - ... ... - %sp+OFFSET+176 Optional extra outgoing argument# 1 - %sp+OFFSET+168 Outgoing argument #6 - ... ... - %sp+OFFSET+128 Outgoing argument #1 - %sp+OFFSET+120 Save area for %i7 - ... ... - %sp+OFFSET+0 Save area for %l0 <-- ****BOTTOM OF STACK FRAME**** - - *----------------------------------------------------------------------*/ - - // All stack addresses must be offset by 0x7ff (2047) on Sparc V9. - static const int OFFSET = (int) 0x7ff; - static const int StackFrameSizeAlignment = 16; - static const int MinStackFrameSize = 176; - static const int NumFixedOutgoingArgs = 6; - static const int SizeOfEachArgOnStack = 8; - static const int FirstIncomingArgOffsetFromFP = 128 + OFFSET; - static const int FirstOptionalIncomingArgOffsetFromFP = 176 + OFFSET; - static const int StaticAreaOffsetFromFP = 0 + OFFSET; - static const int FirstOutgoingArgOffsetFromSP = 128 + OFFSET; - static const int FirstOptionalOutgoingArgOffsetFromSP = 176 + OFFSET; -}; - - //--------------------------------------------------------------------------- -// class UltraSparcCacheInfo +// class SparcCacheInfo // // Purpose: // Interface to cache parameters for the UltraSPARC. // Just use defaults for now. //--------------------------------------------------------------------------- -struct UltraSparcCacheInfo: public TargetCacheInfo { - UltraSparcCacheInfo(const TargetMachine &T) : TargetCacheInfo(T) {} +struct SparcCacheInfo: public TargetCacheInfo { + SparcCacheInfo(const TargetMachine &T) : TargetCacheInfo(T) {} }; @@ -663,38 +126,6 @@ /// getBytecodeAsmPrinterPass - Emits final LLVM bytecode to assembly file. /// Pass* createBytecodeAsmPrinterPass(std::ostream &Out); - -//--------------------------------------------------------------------------- -// class UltraSparc -// -// Purpose: -// Primary interface to machine description for the UltraSPARC. -// Primarily just initializes machine-dependent parameters in -// class TargetMachine, and creates machine-dependent subclasses -// for classes such as InstrInfo, SchedInfo and RegInfo. -//--------------------------------------------------------------------------- - -class UltraSparc : public TargetMachine { - UltraSparcInstrInfo instrInfo; - UltraSparcSchedInfo schedInfo; - UltraSparcRegInfo regInfo; - UltraSparcFrameInfo frameInfo; - UltraSparcCacheInfo cacheInfo; -public: - UltraSparc(); - - virtual const TargetInstrInfo &getInstrInfo() const { return instrInfo; } - virtual const TargetSchedInfo &getSchedInfo() const { return schedInfo; } - virtual const TargetRegInfo &getRegInfo() const { return regInfo; } - virtual const TargetFrameInfo &getFrameInfo() const { return frameInfo; } - virtual const TargetCacheInfo &getCacheInfo() const { return cacheInfo; } - - virtual bool addPassesToEmitAssembly(PassManager &PM, std::ostream &Out); - virtual bool addPassesToJITCompile(FunctionPassManager &PM); - virtual bool addPassesToEmitMachineCode(FunctionPassManager &PM, - MachineCodeEmitter &MCE); - virtual void replaceMachineCodeForFunction(void *Old, void *New); -}; } // End llvm namespace Index: llvm/lib/Target/Sparc/SparcRegClassInfo.cpp diff -u llvm/lib/Target/Sparc/SparcRegClassInfo.cpp:1.32 llvm/lib/Target/Sparc/SparcRegClassInfo.cpp:1.33 --- llvm/lib/Target/Sparc/SparcRegClassInfo.cpp:1.32 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/SparcRegClassInfo.cpp Wed Dec 17 16:04:00 2003 @@ -11,9 +11,10 @@ // //===----------------------------------------------------------------------===// +#include "llvm/Type.h" #include "SparcRegClassInfo.h" #include "SparcInternals.h" -#include "llvm/Type.h" +#include "SparcRegInfo.h" #include "../../CodeGen/RegAlloc/RegAllocCommon.h" // FIXME! #include "../../CodeGen/RegAlloc/IGNode.h" // FIXME! @@ -320,8 +321,8 @@ int RegTypeWanted, std::vector &IsColorUsedArr) const { - if (UserRegType == UltraSparcRegInfo::FPDoubleRegType || - RegTypeWanted == UltraSparcRegInfo::FPDoubleRegType) { + if (UserRegType == SparcRegInfo::FPDoubleRegType || + RegTypeWanted == SparcRegInfo::FPDoubleRegType) { // This register is used as or is needed as a double-precision reg. // We need to mark the [even,odd] pair corresponding to this reg. // Get the even numbered register corresponding to this reg. @@ -348,7 +349,7 @@ int SparcFloatRegClass::findUnusedColor(int RegTypeWanted, const std::vector &IsColorUsedArr) const { - if (RegTypeWanted == UltraSparcRegInfo::FPDoubleRegType) { + if (RegTypeWanted == SparcRegInfo::FPDoubleRegType) { unsigned NC = 2 * this->getNumOfAvailRegs(); assert(IsColorUsedArr.size() == NC && "Invalid colors-used array"); for (unsigned c = 0; c < NC; c+=2) Index: llvm/lib/Target/Sparc/SparcRegInfo.cpp diff -u llvm/lib/Target/Sparc/SparcRegInfo.cpp:1.114 llvm/lib/Target/Sparc/SparcRegInfo.cpp:1.115 --- llvm/lib/Target/Sparc/SparcRegInfo.cpp:1.114 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/SparcRegInfo.cpp Wed Dec 17 16:04:00 2003 @@ -12,8 +12,6 @@ // //===----------------------------------------------------------------------===// -#include "SparcInternals.h" -#include "SparcRegClassInfo.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/CodeGen/InstrSelection.h" @@ -22,10 +20,14 @@ #include "llvm/CodeGen/MachineInstrAnnot.h" #include "../../CodeGen/RegAlloc/LiveRangeInfo.h" // FIXME!! #include "../../CodeGen/RegAlloc/LiveRange.h" // FIXME!! +#include "llvm/DerivedTypes.h" +#include "llvm/Function.h" #include "llvm/iTerminators.h" #include "llvm/iOther.h" -#include "llvm/Function.h" -#include "llvm/DerivedTypes.h" +#include "SparcInternals.h" +#include "SparcRegClassInfo.h" +#include "SparcRegInfo.h" +#include "SparcTargetMachine.h" namespace llvm { @@ -33,7 +35,7 @@ BadRegClass = ~0 }; -UltraSparcRegInfo::UltraSparcRegInfo(const UltraSparc &tgt) +SparcRegInfo::SparcRegInfo(const SparcTargetMachine &tgt) : TargetRegInfo(tgt), NumOfIntArgRegs(6), NumOfFloatArgRegs(32) { MachineRegClassArr.push_back(new SparcIntRegClass(IntRegClassID)); @@ -50,16 +52,16 @@ // getZeroRegNum - returns the register that contains always zero. // this is the unified register number // -int UltraSparcRegInfo::getZeroRegNum() const { - return getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, +int SparcRegInfo::getZeroRegNum() const { + return getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::g0); } // getCallAddressReg - returns the reg used for pushing the address when a // method is called. This can be used for other purposes between calls // -unsigned UltraSparcRegInfo::getCallAddressReg() const { - return getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, +unsigned SparcRegInfo::getCallAddressReg() const { + return getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::o7); } @@ -67,8 +69,8 @@ // It should be made sure that this register contains the return // value when a return instruction is reached. // -unsigned UltraSparcRegInfo::getReturnAddressReg() const { - return getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, +unsigned SparcRegInfo::getReturnAddressReg() const { + return getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::i7); } @@ -133,14 +135,14 @@ } // Get unified reg number for frame pointer -unsigned UltraSparcRegInfo::getFramePointer() const { - return getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, +unsigned SparcRegInfo::getFramePointer() const { + return getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::i6); } // Get unified reg number for stack pointer -unsigned UltraSparcRegInfo::getStackPointer() const { - return getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, +unsigned SparcRegInfo::getStackPointer() const { + return getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::o6); } @@ -173,7 +175,7 @@ // regClassId is set to the register class ID. // int -UltraSparcRegInfo::regNumForIntArg(bool inCallee, bool isVarArgsCall, +SparcRegInfo::regNumForIntArg(bool inCallee, bool isVarArgsCall, unsigned argNo, unsigned& regClassId) const { regClassId = IntRegClassID; @@ -192,7 +194,7 @@ // regClassId is set to the register class ID. // int -UltraSparcRegInfo::regNumForFPArg(unsigned regType, +SparcRegInfo::regNumForFPArg(unsigned regType, bool inCallee, bool isVarArgsCall, unsigned argNo, unsigned& regClassId) const { @@ -221,7 +223,7 @@ // The following 4 methods are used to find the RegType (SparcInternals.h) // of a LiveRange, a Value, and for a given register unified reg number. // -int UltraSparcRegInfo::getRegTypeForClassAndType(unsigned regClassID, +int SparcRegInfo::getRegTypeForClassAndType(unsigned regClassID, const Type* type) const { switch (regClassID) { @@ -237,17 +239,17 @@ } } -int UltraSparcRegInfo::getRegTypeForDataType(const Type* type) const +int SparcRegInfo::getRegTypeForDataType(const Type* type) const { return getRegTypeForClassAndType(getRegClassIDOfType(type), type); } -int UltraSparcRegInfo::getRegTypeForLR(const LiveRange *LR) const +int SparcRegInfo::getRegTypeForLR(const LiveRange *LR) const { return getRegTypeForClassAndType(LR->getRegClassID(), LR->getType()); } -int UltraSparcRegInfo::getRegType(int unifiedRegNum) const +int SparcRegInfo::getRegType(int unifiedRegNum) const { if (unifiedRegNum < 32) return IntRegType; @@ -267,7 +269,7 @@ // To find the register class used for a specified Type // -unsigned UltraSparcRegInfo::getRegClassIDOfType(const Type *type, +unsigned SparcRegInfo::getRegClassIDOfType(const Type *type, bool isCCReg) const { Type::PrimitiveID ty = type->getPrimitiveID(); unsigned res; @@ -290,7 +292,7 @@ return res; } -unsigned UltraSparcRegInfo::getRegClassIDOfRegType(int regType) const { +unsigned SparcRegInfo::getRegClassIDOfRegType(int regType) const { switch(regType) { case IntRegType: return IntRegClassID; case FPSingleRegType: @@ -307,7 +309,7 @@ // Suggests a register for the ret address in the RET machine instruction. // We always suggest %i7 by convention. //--------------------------------------------------------------------------- -void UltraSparcRegInfo::suggestReg4RetAddr(MachineInstr *RetMI, +void SparcRegInfo::suggestReg4RetAddr(MachineInstr *RetMI, LiveRangeInfo& LRI) const { assert(target.getInstrInfo().isReturn(RetMI->getOpCode())); @@ -336,7 +338,7 @@ // Sparc ABI dictates that %o7 be used for this purpose. //--------------------------------------------------------------------------- void -UltraSparcRegInfo::suggestReg4CallAddr(MachineInstr * CallMI, +SparcRegInfo::suggestReg4CallAddr(MachineInstr * CallMI, LiveRangeInfo& LRI) const { CallArgsDescriptor* argDesc = CallArgsDescriptor::get(CallMI); @@ -360,7 +362,7 @@ // If the arg is passed on stack due to the lack of regs, NOTHING will be // done - it will be colored (or spilled) as a normal live range. //--------------------------------------------------------------------------- -void UltraSparcRegInfo::suggestRegs4MethodArgs(const Function *Meth, +void SparcRegInfo::suggestRegs4MethodArgs(const Function *Meth, LiveRangeInfo& LRI) const { // Check if this is a varArgs function. needed for choosing regs. @@ -393,7 +395,7 @@ // the correct hardware registers if they did not receive the correct // (suggested) color through graph coloring. //--------------------------------------------------------------------------- -void UltraSparcRegInfo::colorMethodArgs(const Function *Meth, +void SparcRegInfo::colorMethodArgs(const Function *Meth, LiveRangeInfo &LRI, std::vector& InstrnsBefore, std::vector& InstrnsAfter) const { @@ -566,7 +568,7 @@ // This method is called before graph coloring to suggest colors to the // outgoing call args and the return value of the call. //--------------------------------------------------------------------------- -void UltraSparcRegInfo::suggestRegs4CallArgs(MachineInstr *CallMI, +void SparcRegInfo::suggestRegs4CallArgs(MachineInstr *CallMI, LiveRangeInfo& LRI) const { assert ( (target.getInstrInfo()).isCall(CallMI->getOpCode()) ); @@ -634,7 +636,7 @@ // this method is called for an LLVM return instruction to identify which // values will be returned from this method and to suggest colors. //--------------------------------------------------------------------------- -void UltraSparcRegInfo::suggestReg4RetValue(MachineInstr *RetMI, +void SparcRegInfo::suggestReg4RetValue(MachineInstr *RetMI, LiveRangeInfo& LRI) const { assert( (target.getInstrInfo()).isReturn( RetMI->getOpCode() ) ); @@ -662,7 +664,7 @@ //--------------------------------------------------------------------------- bool -UltraSparcRegInfo::regTypeNeedsScratchReg(int RegType, +SparcRegInfo::regTypeNeedsScratchReg(int RegType, int& scratchRegType) const { if (RegType == IntCCRegType) @@ -679,7 +681,7 @@ //--------------------------------------------------------------------------- void -UltraSparcRegInfo::cpReg2RegMI(std::vector& mvec, +SparcRegInfo::cpReg2RegMI(std::vector& mvec, unsigned SrcReg, unsigned DestReg, int RegType) const { @@ -695,7 +697,7 @@ if (getRegType(DestReg) == IntRegType) { // copy intCC reg to int reg MI = (BuildMI(V9::RDCCR, 2) - .addMReg(getUnifiedRegNum(UltraSparcRegInfo::IntCCRegClassID, + .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID, SparcIntCCRegClass::ccr)) .addMReg(DestReg,MOTy::Def)); } else { @@ -705,7 +707,7 @@ MI = (BuildMI(V9::WRCCRr, 3) .addMReg(SrcReg) .addMReg(SparcIntRegClass::g0) - .addMReg(getUnifiedRegNum(UltraSparcRegInfo::IntCCRegClassID, + .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID, SparcIntCCRegClass::ccr), MOTy::Def)); } break; @@ -743,7 +745,7 @@ void -UltraSparcRegInfo::cpReg2MemMI(std::vector& mvec, +SparcRegInfo::cpReg2MemMI(std::vector& mvec, unsigned SrcReg, unsigned PtrReg, int Offset, int RegType, @@ -763,7 +765,7 @@ OffReg = PRA.getUnusedUniRegAtMI(RC, RegType, MInst, LVSetBef); #else // Default to using register g4 for holding large offsets - OffReg = getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, + OffReg = getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::g4); #endif assert(OffReg >= 0 && "FIXME: cpReg2MemMI cannot find an unused reg."); @@ -796,7 +798,7 @@ assert(scratchReg >= 0 && "Need scratch reg to store %ccr to memory"); assert(getRegType(scratchReg) ==IntRegType && "Invalid scratch reg"); MI = (BuildMI(V9::RDCCR, 2) - .addMReg(getUnifiedRegNum(UltraSparcRegInfo::IntCCRegClassID, + .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID, SparcIntCCRegClass::ccr)) .addMReg(scratchReg, MOTy::Def)); mvec.push_back(MI); @@ -805,7 +807,7 @@ return; case FloatCCRegType: { - unsigned fsrReg = getUnifiedRegNum(UltraSparcRegInfo::SpecialRegClassID, + unsigned fsrReg = getUnifiedRegNum(SparcRegInfo::SpecialRegClassID, SparcSpecialRegClass::fsr); if (target.getInstrInfo().constantFitsInImmedField(V9::STXFSRi, Offset)) MI=BuildMI(V9::STXFSRi,3).addMReg(fsrReg).addMReg(PtrReg).addSImm(Offset); @@ -827,7 +829,7 @@ void -UltraSparcRegInfo::cpMem2RegMI(std::vector& mvec, +SparcRegInfo::cpMem2RegMI(std::vector& mvec, unsigned PtrReg, int Offset, unsigned DestReg, @@ -848,7 +850,7 @@ OffReg = PRA.getUnusedUniRegAtMI(RC, RegType, MInst, LVSetBef); #else // Default to using register g4 for holding large offsets - OffReg = getUnifiedRegNum(UltraSparcRegInfo::IntRegClassID, + OffReg = getUnifiedRegNum(SparcRegInfo::IntRegClassID, SparcIntRegClass::g4); #endif assert(OffReg >= 0 && "FIXME: cpReg2MemMI cannot find an unused reg."); @@ -890,12 +892,12 @@ MI = (BuildMI(V9::WRCCRr, 3) .addMReg(scratchReg) .addMReg(SparcIntRegClass::g0) - .addMReg(getUnifiedRegNum(UltraSparcRegInfo::IntCCRegClassID, + .addMReg(getUnifiedRegNum(SparcRegInfo::IntCCRegClassID, SparcIntCCRegClass::ccr), MOTy::Def)); break; case FloatCCRegType: { - unsigned fsrRegNum = getUnifiedRegNum(UltraSparcRegInfo::SpecialRegClassID, + unsigned fsrRegNum = getUnifiedRegNum(SparcRegInfo::SpecialRegClassID, SparcSpecialRegClass::fsr); if (target.getInstrInfo().constantFitsInImmedField(V9::LDXFSRi, Offset)) MI = BuildMI(V9::LDXFSRi, 3).addMReg(PtrReg).addSImm(Offset) @@ -919,7 +921,7 @@ void -UltraSparcRegInfo::cpValue2Value(Value *Src, Value *Dest, +SparcRegInfo::cpValue2Value(Value *Src, Value *Dest, std::vector& mvec) const { int RegType = getRegTypeForDataType(Src->getType()); MachineInstr * MI = NULL; @@ -948,7 +950,7 @@ // Print the register assigned to a LR //--------------------------------------------------------------------------- -void UltraSparcRegInfo::printReg(const LiveRange *LR) const { +void SparcRegInfo::printReg(const LiveRange *LR) const { unsigned RegClassID = LR->getRegClassID(); std::cerr << " Node "; Index: llvm/lib/Target/Sparc/SparcTargetMachine.cpp diff -u llvm/lib/Target/Sparc/SparcTargetMachine.cpp:1.91 llvm/lib/Target/Sparc/SparcTargetMachine.cpp:1.92 --- llvm/lib/Target/Sparc/SparcTargetMachine.cpp:1.91 Wed Nov 12 18:16:28 2003 +++ llvm/lib/Target/Sparc/SparcTargetMachine.cpp Wed Dec 17 16:04:00 2003 @@ -6,27 +6,31 @@ // the University of Illinois Open Source License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This file contains the code for the Sparc Target that does not fit in any of -// the other files in this directory. -// +// +// Primary interface to machine description for the UltraSPARC. Primarily just +// initializes machine-dependent parameters in class TargetMachine, and creates +// machine-dependent subclasses for classes such as TargetInstrInfo. +// //===----------------------------------------------------------------------===// -#include "SparcInternals.h" -#include "MappingInfo.h" #include "llvm/Function.h" #include "llvm/PassManager.h" #include "llvm/Assembly/PrintModulePass.h" -#include "llvm/Transforms/Scalar.h" -#include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/CodeGen/InstrSelection.h" #include "llvm/CodeGen/InstrScheduling.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/CodeGen/MachineCodeForInstruction.h" #include "llvm/CodeGen/Passes.h" #include "llvm/Target/TargetMachineImpls.h" +#include "llvm/Transforms/Scalar.h" +#include "MappingInfo.h" +#include "SparcInternals.h" +#include "SparcTargetMachine.h" #include "Support/CommandLine.h" +using namespace llvm; + namespace llvm { static const unsigned ImplicitRegUseList[] = { 0 }; /* not used yet */ @@ -62,87 +66,9 @@ cl::Hidden); } -//---------------------------------------------------------------------------- -// allocateSparcTargetMachine - Allocate and return a subclass of TargetMachine -// that implements the Sparc backend. (the llvm/CodeGen/Sparc.h interface) -//---------------------------------------------------------------------------- - -TargetMachine *allocateSparcTargetMachine(const Module &M) { - return new UltraSparc(); -} - -//--------------------------------------------------------------------------- -// class UltraSparcFrameInfo -// -// Interface to stack frame layout info for the UltraSPARC. -// Starting offsets for each area of the stack frame are aligned at -// a multiple of getStackFrameSizeAlignment(). -//--------------------------------------------------------------------------- - -int -UltraSparcFrameInfo::getFirstAutomaticVarOffset(MachineFunction& , - bool& pos) const -{ - pos = false; // static stack area grows downwards - return StaticAreaOffsetFromFP; -} - -int -UltraSparcFrameInfo::getRegSpillAreaOffset(MachineFunction& mcInfo, - bool& pos) const -{ - // ensure no more auto vars are added - mcInfo.getInfo()->freezeAutomaticVarsArea(); - - pos = false; // static stack area grows downwards - unsigned autoVarsSize = mcInfo.getInfo()->getAutomaticVarsSize(); - return StaticAreaOffsetFromFP - autoVarsSize; -} - -int -UltraSparcFrameInfo::getTmpAreaOffset(MachineFunction& mcInfo, - bool& pos) const -{ - MachineFunctionInfo *MFI = mcInfo.getInfo(); - MFI->freezeAutomaticVarsArea(); // ensure no more auto vars are added - MFI->freezeSpillsArea(); // ensure no more spill slots are added - - pos = false; // static stack area grows downwards - unsigned autoVarsSize = MFI->getAutomaticVarsSize(); - unsigned spillAreaSize = MFI->getRegSpillsSize(); - int offset = autoVarsSize + spillAreaSize; - return StaticAreaOffsetFromFP - offset; -} - -int -UltraSparcFrameInfo::getDynamicAreaOffset(MachineFunction& mcInfo, - bool& pos) const -{ - // Dynamic stack area grows downwards starting at top of opt-args area. - // The opt-args, required-args, and register-save areas are empty except - // during calls and traps, so they are shifted downwards on each - // dynamic-size alloca. - pos = false; - unsigned optArgsSize = mcInfo.getInfo()->getMaxOptionalArgsSize(); - if (int extra = optArgsSize % getStackFrameSizeAlignment()) - optArgsSize += (getStackFrameSizeAlignment() - extra); - int offset = optArgsSize + FirstOptionalOutgoingArgOffsetFromSP; - assert((offset - OFFSET) % getStackFrameSizeAlignment() == 0); - return offset; -} - -//--------------------------------------------------------------------------- -// class UltraSparcMachine -// -// Purpose: -// Primary interface to machine description for the UltraSPARC. -// Primarily just initializes machine-dependent parameters in -// class TargetMachine, and creates machine-dependent subclasses -// for classes such as TargetInstrInfo. -// -//--------------------------------------------------------------------------- +} // End llvm namespace -UltraSparc::UltraSparc() +SparcTargetMachine::SparcTargetMachine() : TargetMachine("UltraSparc-Native", false), schedInfo(*this), regInfo(*this), @@ -153,7 +79,8 @@ // addPassesToEmitAssembly - This method controls the entire code generation // process for the ultra sparc. // -bool UltraSparc::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) +bool +SparcTargetMachine::addPassesToEmitAssembly(PassManager &PM, std::ostream &Out) { // The following 3 passes used to be inserted specially by llc. // Replace malloc and free instructions with library calls. @@ -225,7 +152,7 @@ // addPassesToJITCompile - This method controls the JIT method of code // generation for the UltraSparc. // -bool UltraSparc::addPassesToJITCompile(FunctionPassManager &PM) { +bool SparcTargetMachine::addPassesToJITCompile(FunctionPassManager &PM) { const TargetData &TD = getTargetData(); PM.add(new TargetData("lli", TD.isLittleEndian(), TD.getPointerSize(), @@ -269,4 +196,15 @@ return false; // success! } -} // End llvm namespace +//---------------------------------------------------------------------------- +// allocateSparcTargetMachine - Allocate and return a subclass of TargetMachine +// that implements the Sparc backend. (the llvm/CodeGen/Sparc.h interface) +//---------------------------------------------------------------------------- + +namespace llvm { + +TargetMachine *allocateSparcTargetMachine(const Module &M) { + return new SparcTargetMachine(); +} + +} Index: llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp diff -u llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp:1.46 llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp:1.47 --- llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp:1.46 Sun Dec 14 07:24:15 2003 +++ llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp Wed Dec 17 16:04:00 2003 @@ -35,6 +35,8 @@ #include "Support/hash_set" #include "Support/Statistic.h" #include "SparcInternals.h" +#include "SparcTargetMachine.h" +#include "SparcRegInfo.h" #include "SparcV9CodeEmitter.h" #include "Config/alloca.h" @@ -46,8 +48,8 @@ Statistic<> CallbackCalls("callback", "Number CompilationCallback() calls"); } -bool UltraSparc::addPassesToEmitMachineCode(FunctionPassManager &PM, - MachineCodeEmitter &MCE) { +bool SparcTargetMachine::addPassesToEmitMachineCode(FunctionPassManager &PM, + MachineCodeEmitter &MCE) { MachineCodeEmitter *M = &MCE; DEBUG(M = MachineCodeEmitter::createFilePrinterEmitter(MCE)); PM.add(new SparcV9CodeEmitter(*this, *M)); @@ -102,10 +104,10 @@ private: uint64_t emitStubForFunction(Function *F); - static void SaveRegisters(uint64_t DoubleFP[], uint64_t &FSR, - uint64_t &FPRS, uint64_t &CCR); - static void RestoreRegisters(uint64_t DoubleFP[], uint64_t &FSR, - uint64_t &FPRS, uint64_t &CCR); + static void SaveRegisters(uint64_t DoubleFP[], uint64_t CC[], + uint64_t Globals[]); + static void RestoreRegisters(uint64_t DoubleFP[], uint64_t CC[], + uint64_t Globals[]); static void CompilationCallback(); uint64_t resolveFunctionReference(uint64_t RetAddr); @@ -209,17 +211,20 @@ } } -void JITResolver::SaveRegisters(uint64_t DoubleFP[], uint64_t &FSR, - uint64_t &FPRS, uint64_t &CCR) { +void JITResolver::SaveRegisters(uint64_t DoubleFP[], uint64_t CC[], + uint64_t Globals[]) { #if defined(sparc) || defined(__sparc__) || defined(__sparcv9) -#if 0 __asm__ __volatile__ (// Save condition-code registers "stx %%fsr, %0;\n\t" "rd %%fprs, %1;\n\t" "rd %%ccr, %2;\n\t" - : "=m"(FSR), "=r"(FPRS), "=r"(CCR)); -#endif + : "=m"(CC[0]), "=r"(CC[1]), "=r"(CC[2])); + + __asm__ __volatile__ (// Save globals g1 and g5 + "stx %%g1, %0;\n\t" + "stx %%g5, %0;\n\t" + : "=m"(Globals[0]), "=m"(Globals[1])); // GCC says: `asm' only allows up to thirty parameters! __asm__ __volatile__ (// Save Single/Double FP registers, part 1 @@ -261,18 +266,21 @@ } -void JITResolver::RestoreRegisters(uint64_t DoubleFP[], uint64_t &FSR, - uint64_t &FPRS, uint64_t &CCR) +void JITResolver::RestoreRegisters(uint64_t DoubleFP[], uint64_t CC[], + uint64_t Globals[]) { #if defined(sparc) || defined(__sparc__) || defined(__sparcv9) -#if 0 __asm__ __volatile__ (// Restore condition-code registers "ldx %0, %%fsr;\n\t" "wr %1, 0, %%fprs;\n\t" "wr %2, 0, %%ccr;\n\t" - :: "m"(FSR), "r"(FPRS), "r"(CCR)); -#endif + :: "m"(CC[0]), "r"(CC[1]), "r"(CC[2])); + + __asm__ __volatile__ (// Restore globals g1 and g5 + "ldx %0, %%g1;\n\t" + "ldx %0, %%g5;\n\t" + :: "m"(Globals[0]), "m"(Globals[1])); // GCC says: `asm' only allows up to thirty parameters! __asm__ __volatile__ (// Restore Single/Double FP registers, part 1 @@ -314,11 +322,12 @@ } void JITResolver::CompilationCallback() { - // Local space to save double registers + // Local space to save the registers uint64_t DoubleFP[32]; - uint64_t FSR, FPRS, CCR; + uint64_t CC[3]; + uint64_t Globals[2]; - SaveRegisters(DoubleFP, FSR, FPRS, CCR); + SaveRegisters(DoubleFP, CC, Globals); ++CallbackCalls; uint64_t CameFrom = (uint64_t)(intptr_t)__builtin_return_address(0); @@ -394,7 +403,7 @@ __asm__ __volatile__ ("sub %%i7, %0, %%i7" : : "r" (Offset+12)); #endif - RestoreRegisters(DoubleFP, FSR, FPRS, CCR); + RestoreRegisters(DoubleFP, CC, Globals); } /// emitStubForFunction - This method is used by the JIT when it needs to emit @@ -476,7 +485,7 @@ fakeReg = RI.getClassRegNum(fakeReg, regClass); switch (regClass) { - case UltraSparcRegInfo::IntRegClassID: { + case SparcRegInfo::IntRegClassID: { // Sparc manual, p31 static const unsigned IntRegMap[] = { // "o0", "o1", "o2", "o3", "o4", "o5", "o7", @@ -494,12 +503,12 @@ return IntRegMap[fakeReg]; break; } - case UltraSparcRegInfo::FloatRegClassID: { + case SparcRegInfo::FloatRegClassID: { DEBUG(std::cerr << "FP reg: " << fakeReg << "\n"); - if (regType == UltraSparcRegInfo::FPSingleRegType) { + if (regType == SparcRegInfo::FPSingleRegType) { // only numbered 0-31, hence can already fit into 5 bits (and 6) DEBUG(std::cerr << "FP single reg, returning: " << fakeReg << "\n"); - } else if (regType == UltraSparcRegInfo::FPDoubleRegType) { + } else if (regType == SparcRegInfo::FPDoubleRegType) { // FIXME: This assumes that we only have 5-bit register fields! // From Sparc Manual, page 40. // The bit layout becomes: b[4], b[3], b[2], b[1], b[5] @@ -509,7 +518,7 @@ } return fakeReg; } - case UltraSparcRegInfo::IntCCRegClassID: { + case SparcRegInfo::IntCCRegClassID: { /* xcc, icc, ccr */ static const unsigned IntCCReg[] = { 6, 4, 2 }; @@ -518,7 +527,7 @@ DEBUG(std::cerr << "IntCC reg: " << IntCCReg[fakeReg] << "\n"); return IntCCReg[fakeReg]; } - case UltraSparcRegInfo::FloatCCRegClassID: { + case SparcRegInfo::FloatCCRegClassID: { /* These are laid out %fcc0 - %fcc3 => 0 - 3, so are correct */ DEBUG(std::cerr << "FP CC reg: " << fakeReg << "\n"); return fakeReg; @@ -573,7 +582,7 @@ } } -void UltraSparc::replaceMachineCodeForFunction (void *Old, void *New) { +void SparcTargetMachine::replaceMachineCodeForFunction (void *Old, void *New) { assert (TheJITResolver && "Can only call replaceMachineCodeForFunction from within JIT"); uint64_t Target = (uint64_t)(intptr_t)New; Index: llvm/lib/Target/Sparc/UltraSparcSchedInfo.cpp diff -u llvm/lib/Target/Sparc/UltraSparcSchedInfo.cpp:1.8 llvm/lib/Target/Sparc/UltraSparcSchedInfo.cpp:1.9 --- llvm/lib/Target/Sparc/UltraSparcSchedInfo.cpp:1.8 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/UltraSparcSchedInfo.cpp Wed Dec 17 16:04:00 2003 @@ -728,7 +728,7 @@ //--------------------------------------------------------------------------- -// class UltraSparcSchedInfo +// class SparcSchedInfo // // Purpose: // Scheduling information for the UltraSPARC. @@ -737,7 +737,7 @@ //--------------------------------------------------------------------------- /*ctor*/ -UltraSparcSchedInfo::UltraSparcSchedInfo(const TargetMachine& tgt) +SparcSchedInfo::SparcSchedInfo(const TargetMachine& tgt) : TargetSchedInfo(tgt, (unsigned int) SPARC_NUM_SCHED_CLASSES, SparcRUsageDesc, @@ -764,7 +764,7 @@ } void -UltraSparcSchedInfo::initializeResources() +SparcSchedInfo::initializeResources() { // Compute TargetSchedInfo::instrRUsages and TargetSchedInfo::issueGaps TargetSchedInfo::initializeResources(); From brukman at cs.uiuc.edu Wed Dec 17 16:06:06 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 16:06:06 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/Sparc/Sparc.cpp Message-ID: <200312172205.QAA25343@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Sparc: Sparc.cpp (r1.91) removed --- Log message: The contents of this file have been absorbed into SparcTargetMachine, et al. --- Diffs of the changes: (+0 -0) From brukman at cs.uiuc.edu Wed Dec 17 16:07:01 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 16:07:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/Sparc/PreSelection.cpp Message-ID: <200312172206.QAA25377@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Sparc: PreSelection.cpp updated: 1.26 -> 1.27 --- Log message: Doxygenified some comments, reduced extraneous space. --- Diffs of the changes: (+12 -19) Index: llvm/lib/Target/Sparc/PreSelection.cpp diff -u llvm/lib/Target/Sparc/PreSelection.cpp:1.26 llvm/lib/Target/Sparc/PreSelection.cpp:1.27 --- llvm/lib/Target/Sparc/PreSelection.cpp:1.26 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/PreSelection.cpp Wed Dec 17 16:06:08 2003 @@ -94,13 +94,11 @@ : NULL; } - -// Wrapper on Constant::classof to use in find_if :-( +// Wrapper on Constant::classof to use in find_if inline static bool nonConstant(const Use& U) { return ! isa(U); } - static Instruction* DecomposeConstantExpr(ConstantExpr* CE, Instruction& insertBefore) { @@ -177,15 +175,15 @@ } } -// visitOperands() transforms individual operands of all instructions: -// -- Load "large" int constants into a virtual register. What is large -// depends on the type of instruction and on the target architecture. -// -- For any constants that cannot be put in an immediate field, -// load address into virtual register first, and then load the constant. -// -// firstOp and lastOp can be used to skip leading and trailing operands. -// If lastOp is 0, it defaults to #operands or #incoming Phi values. -// +/// visitOperands - transform individual operands of all instructions: +/// -- Load "large" int constants into a virtual register. What is large +/// depends on the type of instruction and on the target architecture. +/// -- For any constants that cannot be put in an immediate field, +/// load address into virtual register first, and then load the constant. +/// +/// firstOp and lastOp can be used to skip leading and trailing operands. +/// If lastOp is 0, it defaults to #operands or #incoming Phi values. +/// inline void PreSelection::visitOperands(Instruction &I, int firstOp) { // For any instruction other than PHI, copies go just before the instr. for (unsigned i = firstOp, e = I.getNumOperands(); i != e; ++i) @@ -205,15 +203,12 @@ // do not call visitOperands! } - - // Common work for *all* instructions. This needs to be called explicitly // by other visit functions. inline void PreSelection::visitInstruction(Instruction &I) { visitOperands(I); // Perform operand transformations } - // GetElementPtr instructions: check if pointer is a global void PreSelection::visitGetElementPtrInst(GetElementPtrInst &I) { Instruction* curI = &I; @@ -239,10 +234,8 @@ visitOperands(I, (/*firstOp=*/ I.getCalledFunction()? 1 : 0)); } -//===----------------------------------------------------------------------===// -// createPreSelectionPass - Public entrypoint for pre-selection pass -// and this file as a whole... -// +/// createPreSelectionPass - Public entry point for the PreSelection pass +/// FunctionPass* createPreSelectionPass(const TargetMachine &TM) { return new PreSelection(TM); } From brukman at cs.uiuc.edu Wed Dec 17 16:07:07 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 16:07:07 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/Sparc/EmitAssembly.cpp Message-ID: <200312172206.QAA25401@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Sparc: EmitAssembly.cpp updated: 1.97 -> 1.98 --- Log message: Reordered #includes. --- Diffs of the changes: (+5 -5) Index: llvm/lib/Target/Sparc/EmitAssembly.cpp diff -u llvm/lib/Target/Sparc/EmitAssembly.cpp:1.97 llvm/lib/Target/Sparc/EmitAssembly.cpp:1.98 --- llvm/lib/Target/Sparc/EmitAssembly.cpp:1.97 Sun Dec 14 07:24:15 2003 +++ llvm/lib/Target/Sparc/EmitAssembly.cpp Wed Dec 17 16:06:28 2003 @@ -18,16 +18,16 @@ // //===----------------------------------------------------------------------===// -#include "llvm/CodeGen/MachineInstr.h" -#include "llvm/CodeGen/MachineConstantPool.h" -#include "llvm/CodeGen/MachineFunction.h" -#include "llvm/CodeGen/MachineFunctionInfo.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Module.h" -#include "llvm/SlotCalculator.h" #include "llvm/Pass.h" +#include "llvm/SlotCalculator.h" #include "llvm/Assembly/Writer.h" +#include "llvm/CodeGen/MachineConstantPool.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionInfo.h" +#include "llvm/CodeGen/MachineInstr.h" #include "Support/StringExtras.h" #include "Support/Statistic.h" #include "SparcInternals.h" From brukman at cs.uiuc.edu Wed Dec 17 16:09:01 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 16:09:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/Sparc/PeepholeOpts.cpp Message-ID: <200312172208.QAA25448@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Sparc: PeepholeOpts.cpp updated: 1.16 -> 1.17 --- Log message: * Converted C-style comments to C++ * Doxygenified comments * Reordered #includes --- Diffs of the changes: (+15 -13) Index: llvm/lib/Target/Sparc/PeepholeOpts.cpp diff -u llvm/lib/Target/Sparc/PeepholeOpts.cpp:1.16 llvm/lib/Target/Sparc/PeepholeOpts.cpp:1.17 --- llvm/lib/Target/Sparc/PeepholeOpts.cpp:1.16 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/Sparc/PeepholeOpts.cpp Wed Dec 17 16:08:20 2003 @@ -13,12 +13,12 @@ //===----------------------------------------------------------------------===// #include "SparcInternals.h" +#include "llvm/BasicBlock.h" +#include "llvm/Pass.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineInstr.h" -#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetInstrInfo.h" -#include "llvm/BasicBlock.h" -#include "llvm/Pass.h" +#include "llvm/Target/TargetMachine.h" namespace llvm { @@ -62,7 +62,7 @@ static bool IsUselessCopy(const TargetMachine &target, const MachineInstr* MI) { if (MI->getOpCode() == V9::FMOVS || MI->getOpCode() == V9::FMOVD) { - return (/* both operands are allocated to the same register */ + return (// both operands are allocated to the same register MI->getOperand(0).getAllocatedRegNum() == MI->getOperand(1).getAllocatedRegNum()); } else if (MI->getOpCode() == V9::ADDr || MI->getOpCode() == V9::ORr || @@ -78,14 +78,14 @@ if (srcWithDestReg == 2) return false; else { - /* else source and dest are allocated to the same register */ + // else source and dest are allocated to the same register unsigned otherOp = 1 - srcWithDestReg; - return (/* either operand otherOp is register %g0 */ + return (// either operand otherOp is register %g0 (MI->getOperand(otherOp).hasAllocatedReg() && MI->getOperand(otherOp).getAllocatedRegNum() == target.getRegInfo().getZeroRegNum()) || - /* or operand otherOp == 0 */ + // or operand otherOp == 0 (MI->getOperand(otherOp).getType() == MachineOperand::MO_SignExtendedImmed && MI->getOperand(otherOp).getImmedValue() == 0)); @@ -117,6 +117,11 @@ PeepholeOpts(const TargetMachine &TM): target(TM) { } bool runOnBasicBlock(BasicBlock &BB); // apply this pass to each BB virtual const char *getPassName() const { return "Peephole Optimization"; } + + // getAnalysisUsage - this pass preserves the CFG + void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesCFG(); + } }; // Apply a list of peephole optimizations to this machine instruction @@ -125,7 +130,7 @@ // bool PeepholeOpts::visit(MachineBasicBlock& mvec, MachineBasicBlock::iterator BBI) const { - /* Remove redundant copy instructions */ + // Remove redundant copy instructions return RemoveUselessCopies(mvec, BBI, target); } @@ -157,11 +162,8 @@ return true; } - -//===----------------------------------------------------------------------===// -// createPeepholeOptsPass - Public entrypoint for peephole optimization -// and this file as a whole... -// +/// createPeepholeOptsPass - Public entry point for peephole optimization +/// FunctionPass* createPeepholeOptsPass(const TargetMachine &TM) { return new PeepholeOpts(TM); } From criswell at cs.uiuc.edu Wed Dec 17 16:48:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 16:48:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/docs/AliasAnalysis.html CFEBuildInstrs.html CodingStandards.html CommandLine.html FAQ.html GettingStarted.html HowToSubmitABug.html LLVMVsTheWorld.html LangRef.html OpenProjects.html Projects.html ReleaseNotes.html Stacker.html TestingGuide.html Message-ID: <200312172247.QAA01383@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1/docs: AliasAnalysis.html updated: 1.1 -> 1.2 CFEBuildInstrs.html updated: 1.1 -> 1.2 CodingStandards.html updated: 1.1 -> 1.2 CommandLine.html updated: 1.1 -> 1.2 FAQ.html updated: 1.1 -> 1.2 GettingStarted.html updated: 1.1 -> 1.2 HowToSubmitABug.html updated: 1.1 -> 1.2 LLVMVsTheWorld.html updated: 1.1 -> 1.2 LangRef.html updated: 1.1 -> 1.2 OpenProjects.html updated: 1.1 -> 1.2 Projects.html updated: 1.1 -> 1.2 ReleaseNotes.html updated: 1.3 -> 1.4 Stacker.html updated: 1.1 -> 1.2 TestingGuide.html updated: 1.1 -> 1.2 --- Log message: Updating to new docs in LLVM tarball. --- Diffs of the changes: (+254 -165) Index: llvm-www/releases/1.1/docs/AliasAnalysis.html diff -u llvm-www/releases/1.1/docs/AliasAnalysis.html:1.1 llvm-www/releases/1.1/docs/AliasAnalysis.html:1.2 --- llvm-www/releases/1.1/docs/AliasAnalysis.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/AliasAnalysis.html Wed Dec 17 16:47:16 2003 @@ -486,7 +486,7 @@ Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/CFEBuildInstrs.html diff -u llvm-www/releases/1.1/docs/CFEBuildInstrs.html:1.1 llvm-www/releases/1.1/docs/CFEBuildInstrs.html:1.2 --- llvm-www/releases/1.1/docs/CFEBuildInstrs.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/CFEBuildInstrs.html Wed Dec 17 16:47:16 2003 @@ -262,7 +262,7 @@
      Brian Gaeke
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/CodingStandards.html diff -u llvm-www/releases/1.1/docs/CodingStandards.html:1.1 llvm-www/releases/1.1/docs/CodingStandards.html:1.2 --- llvm-www/releases/1.1/docs/CodingStandards.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/CodingStandards.html Wed Dec 17 16:47:16 2003 @@ -952,7 +952,7 @@
      Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/CommandLine.html diff -u llvm-www/releases/1.1/docs/CommandLine.html:1.1 llvm-www/releases/1.1/docs/CommandLine.html:1.2 --- llvm-www/releases/1.1/docs/CommandLine.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/CommandLine.html Wed Dec 17 16:47:16 2003 @@ -1692,7 +1692,7 @@
      Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/FAQ.html diff -u llvm-www/releases/1.1/docs/FAQ.html:1.1 llvm-www/releases/1.1/docs/FAQ.html:1.2 --- llvm-www/releases/1.1/docs/FAQ.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/FAQ.html Wed Dec 17 16:47:16 2003 @@ -438,7 +438,7 @@ Index: llvm-www/releases/1.1/docs/GettingStarted.html diff -u llvm-www/releases/1.1/docs/GettingStarted.html:1.1 llvm-www/releases/1.1/docs/GettingStarted.html:1.2 --- llvm-www/releases/1.1/docs/GettingStarted.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/GettingStarted.html Wed Dec 17 16:47:16 2003 @@ -182,24 +182,55 @@
    17. Linux on x86 (Pentium and above)
        -
      • Approximately 760 MB of Free Disk Space +
      • Approximately 918 MB of Free Disk Space
          -
        • Source code: 30 MB
        • -
        • Object code: 670 MB
        • -
        • GCC front end: 60 MB
        • +
        • Source code: 28 MB
        • +
        • Object code: 850 MB
        • +
        • GCC front end: 40 MB
      • -
    18. + + + +

    19. Solaris on SparcV9 (Ultrasparc)
        -
      • Approximately 1.24 GB of Free Disk Space +
      • Approximately 1.52 GB of Free Disk Space +
          +
        • Source code: 28 MB
        • +
        • Object code: 1470 MB
        • +
        • GCC front end: 50 MB
        • +
      • +
      +
    20. + +

      + +
    21. FreeBSD on x86 (Pentium and above) +
        +
      • Approximately 918 MB of Free Disk Space +
          +
        • Source code: 28 MB
        • +
        • Object code: 850 MB
        • +
        • GCC front end: 40 MB
        • +
      • +
      +
    22. + +

      + +
    23. MacOS X on PowerPC +
        +
      • No native code generation +
      • Approximately 1.20 GB of Free Disk Space
          -
        • Source code: 30 MB
        • -
        • Object code: 1000 MB
        • -
        • GCC front end: 210 MB
        • +
        • Source code: 28 MB
        • +
        • Object code: 1160 MB
        • +
        • GCC front end: 40 MB
      • -
    24. + +

      The LLVM suite may compile on other platforms, but it is not @@ -253,7 +284,6 @@ -

      The remainder of this guide is meant to get you up and running with LLVM and to give you some basic information about the LLVM environment. A complete guide to installation is provided in the @@ -348,22 +378,31 @@

      If you have the LLVM distribution, you will need to unpack it before you -can begin to compile it. LLVM is distributed as a set of three files. Each +can begin to compile it. LLVM is distributed as a set of two files: the LLVM +suite and the LLVM GCC front end compiled for your platform. Each file is a TAR archive that is compressed with the gzip program.

      -

      The three files are as follows: +

      The files are as follows:

      -
      llvm.tar.gz +
      llvm-1.1.tar.gz
      This is the source code to the LLVM suite.

      -

      cfrontend.sparc.tar.gz +
      cfrontend-1.1.sparc-sun-solaris2.8.tar.gz
      This is the binary release of the GCC front end for Solaris/Sparc.

      -

      cfrontend.x86.tar.gz +
      cfrontend-1.1.i686-redhat-linux-gnu.tar.gz
      This is the binary release of the GCC front end for Linux/x86. +

      + +

      cfrontend-1.1.i386-unknown-freebsd5.1.tar.gz +
      This is the binary release of the GCC front end for FreeBSD/x86. +

      + +

      cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz +
      This is the binary release of the GCC front end for MacOS X/PPC.
      @@ -391,6 +430,20 @@ directory and fully populate it with the LLVM source code, Makefiles, test directories, and local copies of documentation files.

      +

      +If you want to get a specific release (as opposed to the most recent revision), +you can specify a label. The following releases have the following label: +

        +
      • + Release 1.1: RELEASE_11 +
      • + +
      • + Release 1.0: RELEASE_1 +
      • +
      +

      +

      Note that the GCC front end is not included in the CVS repository. You should have downloaded the binary distribution for your platform.

      @@ -412,12 +465,12 @@
      1. cd where-you-want-the-front-end-to-live
      2. -
      3. gunzip --stdout cfrontend.platform.tar.gz | tar -xvf +
      4. gunzip --stdout cfrontend-version.platform.tar.gz | tar -xvf -
      -

      If you are on a Sparc/Solaris machine, you will need to fix the header -files:

      +

      If you are using Solaris/Sparc or MacOS X/PPC, you will need to fix the +header files:

      cd cfrontend/sparc
      ./fixheaders

      @@ -443,7 +496,8 @@

      Once checked out from the CVS repository, the LLVM suite source code must be configured via the configure script. This script sets variables in llvm/Makefile.config and llvm/include/Config/config.h. It -also populates OBJ_ROOT with the Makefiles needed to build LLVM.

      +also populates OBJ_ROOT with the Makefiles needed to begin building +LLVM.

      The following environment variables are used by the configure script to configure the build system:

      @@ -477,7 +531,7 @@
      --with-llvmgccdir=LLVMGCCDIR
      Path to the location where the LLVM C front end binaries and - associated libraries will be installed. This must be specified as an + associated libraries were installed. This must be specified as an absolute pathname.

      --enable-optimized @@ -488,7 +542,8 @@

      --enable-jit
      - Compile the Just In Time (JIT) functionality. This is not available + Compile the Just In Time (JIT) compiler functionality. This is not + available on all platforms. The default is dependent on platform, so it is best to explicitly enable it if you want it.

      @@ -521,10 +576,10 @@ LLVM_LIB_SEARCH_PATH environment variable in your startup scripts. This environment variable is used to locate "system" libraries like "-lc" and "-lm" when linking. This variable should be set to -the absolute path for the bytecode-libs subdirectory of the GCC front end -install, or LLVMGCCDIR/bytecode-libs. For example, one might set +the absolute path of the bytecode-libs subdirectory of the GCC front +end, or LLVMGCCDIR/bytecode-libs. For example, one might set LLVM_LIB_SEARCH_PATH to -/home/vadve/lattner/local/x86/llvm-gcc/bytecode-libs for the X86 +/home/vadve/lattner/local/x86/llvm-gcc/bytecode-libs for the x86 version of the GCC front end on our research machines.

      @@ -1091,7 +1146,7 @@
      Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $
      Index: llvm-www/releases/1.1/docs/HowToSubmitABug.html diff -u llvm-www/releases/1.1/docs/HowToSubmitABug.html:1.1 llvm-www/releases/1.1/docs/HowToSubmitABug.html:1.2 --- llvm-www/releases/1.1/docs/HowToSubmitABug.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/HowToSubmitABug.html Wed Dec 17 16:47:16 2003 @@ -311,7 +311,7 @@
      Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/LLVMVsTheWorld.html diff -u llvm-www/releases/1.1/docs/LLVMVsTheWorld.html:1.1 llvm-www/releases/1.1/docs/LLVMVsTheWorld.html:1.2 --- llvm-www/releases/1.1/docs/LLVMVsTheWorld.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/LLVMVsTheWorld.html Wed Dec 17 16:47:16 2003 @@ -173,7 +173,7 @@
      Brian R. Gaeke
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/LangRef.html diff -u llvm-www/releases/1.1/docs/LangRef.html:1.1 llvm-www/releases/1.1/docs/LangRef.html:1.2 --- llvm-www/releases/1.1/docs/LangRef.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/LangRef.html Wed Dec 17 16:47:16 2003 @@ -1692,6 +1692,6 @@ +Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/OpenProjects.html diff -u llvm-www/releases/1.1/docs/OpenProjects.html:1.1 llvm-www/releases/1.1/docs/OpenProjects.html:1.2 --- llvm-www/releases/1.1/docs/OpenProjects.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/OpenProjects.html Wed Dec 17 16:47:16 2003 @@ -313,7 +313,7 @@
      Chris Lattner
      The LLVM Compiler Infrastructure
      - Last modified: $Date: 2003/12/13 22:03:42 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/Projects.html diff -u llvm-www/releases/1.1/docs/Projects.html:1.1 llvm-www/releases/1.1/docs/Projects.html:1.2 --- llvm-www/releases/1.1/docs/Projects.html:1.1 Sat Dec 13 16:03:42 2003 +++ llvm-www/releases/1.1/docs/Projects.html Wed Dec 17 16:47:16 2003 @@ -385,7 +385,7 @@
      John Criswell

      The LLVM Compiler Infrastructure
      -Last modified: $Date: 2003/12/13 22:03:42 $ +Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/ReleaseNotes.html diff -u llvm-www/releases/1.1/docs/ReleaseNotes.html:1.3 llvm-www/releases/1.1/docs/ReleaseNotes.html:1.4 --- llvm-www/releases/1.1/docs/ReleaseNotes.html:1.3 Sun Dec 14 16:36:45 2003 +++ llvm-www/releases/1.1/docs/ReleaseNotes.html Wed Dec 17 16:47:16 2003 @@ -7,9 +7,7 @@ -
      - LLVM 1.1 Release Notes -
      +
      LLVM 1.1 Release Notes
      1. Introduction
      2. @@ -18,7 +16,6 @@
      3. Installation Instructions
      4. Known Problems
      -

      Written by Chris Lattner

      +

      Written by the LLVM team

      @@ -43,10 +40,10 @@

      This document contains the release notes for the LLVM compiler infrastructure, release 1.1. Here we describe the status of LLVM, including any -known problems, and bug fixes from the previous release. The most up-to-date +known problems and bug fixes from the previous release. The most up-to-date version of this document can be found on the LLVM 1.1 web site. If you are -not reading this on the LLVM web pages, you should probably go there, because +not reading this on the LLVM web pages, you should probably go there because this document may be updated after the release.

      For more information about LLVM, including information about potentially more @@ -72,10 +69,12 @@

      This is the second public release of the LLVM compiler infrastructure. This release is primarily a bugfix release, dramatically improving the C/C++ -front-end, and improving support for C++ in the LLVM core. This release also -includes a few new features, such as a simple profiler, support for Mac OS/X, +front-end and improving support for C++ in the LLVM core. This release also +includes a few new features, such as a simple profiler, support for Mac OS X, better interoperability with external source bases, a new example language -front-end, and improvements in a few optimizations.

      +front-end, and improvements in a few optimizations. The performance of several +LLVM components has been improved, and several gratuitous type-safety issues in +the C front-end have been fixed.

      At this time, LLVM is known to correctly compile and run all non-unwinding C & C++ SPEC CPU2000 benchmarks, the Olden benchmarks, and the Ptrdist @@ -85,10 +84,10 @@

      -The LLVM native code generators are very stable, but do not currently support +The LLVM native code generators are very stable but do not currently support unwinding (exception throwing or longjmping), which prevent them from working with programs like the 253.perlbmk in SPEC CPU2000. The C -backend and the rest of LLVM does support these programs however, so you can +backend and the rest of LLVM supports these programs, so you can still use LLVM with them. Support for unwinding will be added in a future release.

      @@ -102,15 +101,15 @@
      1. A new -LLVM profiler, similar to gprof is available
      2. +LLVM profiler, similar to gprof, is available. -
      3. LLVM and the C/C++ front-end now compile on Mac OS/X! Mac OS/X users can +
      4. LLVM and the C/C++ front-end now compile on Mac OS X! Mac OS X users can now explore the LLVM optimizer with the C backend and interpreter. Note that -LLVM requires GCC 3.3 on Mac OS/X.
      5. +LLVM requires GCC 3.3 on Mac OS X.
      6. LLVM has been moved -into an 'llvm' C++ namespace, for easier integration with third-party +into an 'llvm' C++ namespace for easier integration with third-party code. Note that due to lack of namespace support in GDB 5.x, you will probably want to upgrade to GDB 6 or better to debug LLVM code.
      7. @@ -120,7 +119,8 @@
        1. New directories can be added to the source tree, and the build will - automatically pick them up (i.e. no need to re-run configure). + automatically pick them up (i.e. no need to edit configure.ac and + re-run configure).
        2. @@ -132,7 +132,9 @@
        3. A front-end for "Stacker" (a simple Forth-like language) is now included in the main LLVM tree. - Additionally, Reid Spencer, the author, contributed a document describing his experiences writing Stacker, and the language itself. This document is invaluable for others writing front-ends targetting LLVM.
        4. + Additionally, Reid Spencer, the author, contributed a document + describing his experiences writing Stacker and the language itself. + This document is invaluable for others writing front-ends targetting LLVM.
        5. The configure script will now configure all projects placed in the llvm/projects directory.
        6. @@ -143,12 +145,12 @@
        7. The -licm pass can now sink instructions out the bottom of loops in addition to being able to hoist them out the top.
        8. -
        9. The -basicaa pass (the default alias analysis) has been upgraded -to be significantly more +
        10. The -basicaa pass (the default alias analysis pass) has been +upgraded to be significantly more precise.
        11. LLVM 1.1 implements a simple size optimization for LLVM bytecode files. - This means that the 1.1 files are smaller than 1.0, but that 1.0 won't + This means that the 1.1 files are smaller than 1.0, but LLVM 1.0 won't read 1.1 bytecode files.
        12. The gccld program produces a runner script that includes command-line options to load the necessary shared objects.
        13. @@ -185,15 +187,15 @@
        14. The C++ front-end now compiles functions to use the linkonce linkage type - more, giving the optimizer more freedom.
        15. + more, giving the optimizer more freedom.
        16. The C front-end now generates - type-safe code in several cases that it did not before, which prevented - some important optimizations.
        17. + type-safe code in several cases that it did not before, allowing + optimization of code that could not be optimized previously.
        18. The LLVM build system has been taught to catch some common configuration problems that caused it to get - horribly confused before.
        19. + horribly confused.
        20. The LLVM header files are now -Wold-style-cast clean.
        21. @@ -210,15 +212,11 @@ generated N^2 amounts of duplicated cleanup code in some cases.
        22. The JIT used to generate code for - all functions pointed to by globals immediately, before the program - started execution, but now it waits until the first time they are called to + all functions pointed to by globals before the program + started execution. Now, it waits until the first time the functions are + called to compile them. This dramatically speeds up short runs of large C++ programs, which often have large numbers of functions pointed to by vtables.
        23. - -
        24. The C front-end had an inefficient - implementation of the LLVM type-system, which caused the C++ front-end - to be very slow in some cases.
        25. -
        @@ -238,7 +236,7 @@
      8. llvm-as crashes when labels are used in phi nodes
      9. [build problem] Callgraph.cpp not pulled in from libipa.a
      10. Variables in scope of output setjmp -calls should be volatile (Note that this does not effect correctness on +calls should be volatile (Note that this does not affect correctness on many platforms, such as X86).
      11. [X86] Emission of global bool initializers broken
      12. [gccld] The -r (relinking) option does not work correctly
      13. @@ -274,7 +272,7 @@
      14. CFrontend crashes when compiling C99 compound expressions
      15. llvm-gcc infinite loops on "case MAXINT:"
      16. [C++] Catch blocks make unparsable labels
      17. -
      18. [C++] Initializing array with constructable objects fail
      19. +
      20. [C++] Initializing array with constructible objects fail
      21. llvm-gcc tries to add bools
      22. [c++] C++ Frontend lays out superclasses like anonymous bitfields!
      23. C front-end miscompiles unsigned enums whose LLVM types are signed
      24. @@ -307,13 +305,13 @@

        LLVM has been extensively tested on Intel and AMD machines running Red -Hat Linux and FreeBSD. It has also been tested on Sun UltraSPARC workstations running Solaris 8. +Hat Linux and has been tested on Sun UltraSPARC workstations running Solaris 8. Additionally, -LLVM works on Mac OS/X 10.3 and above, but only with the C backend or +LLVM works on Mac OS X 10.3 and above, but only with the C backend or interpreter (no native backend for the PowerPC is available yet). The core LLVM infrastructure uses "autoconf" for portability, so hopefully we work on more platforms than that. However, it is likely that we -missed something, and that minor porting is required to get LLVM to work on +missed something and that minor porting is required to get LLVM to work on new platforms. We welcome portability patches and error messages.

        @@ -329,7 +327,7 @@

        This section contains all known problems with the LLVM system, listed by component. As new problems are discovered, they will be added to these sections. If you run into a problem, please check the LLVM bug database, and submit a bug if +href="http://llvm.cs.uiuc.edu/bugs/">LLVM bug database and submit a bug if there isn't already one.

        @@ -364,10 +362,18 @@
      25. LLVM cannot handle structures with more than 256 elements.
      26. -Bugs in 1.1 fixed in 1.2: @@ -383,9 +389,7 @@
        -
          -
        • C99 Variable sized arrays do not release stack memory when they go out of scope. Thus, the following program may run out of stack space:
          @@ -395,8 +399,27 @@
               }
           
        • -
        +
      27. +Initialization of global union variables can only be done +with the largest +union member. +
      28. +
      29. + +Functions marked "extern inline" are not compiled into LLVM with linkonce +linkage. + +
      30. + + +
      31. +The memory management functions in the libc runtime +need weak linkage so that they can be +overridden. + +
      32. +
        @@ -428,11 +451,11 @@ the following extensions are known to not be supported:
        1. Local Labels: Labels local to a block.
        2. -
        3. Labels as Values: Getting pointers to labels, and computed gotos.
        4. +
        5. Labels as Values: Getting pointers to labels and computed gotos.
        6. Nested Functions: As in Algol and Pascal, lexical scoping of functions.
        7. Constructing Calls: Dispatching a call to another function.
        8. Extended Asm: Assembler instructions with C expressions as operands.
        9. -
        10. Constraints: Constraints for asm operands
        11. +
        12. Constraints: Constraints for asm operands.
        13. Asm Labels: Specifying the assembler name to use for a C symbol.
        14. Explicit Reg Vars: Defining variables residing in specified registers.
        15. Return Address: Getting the return or frame address of a function.
        16. @@ -445,7 +468,7 @@

          The following GCC extensions are partially supported. An ignored attribute means that the LLVM compiler ignores the presence of the attribute, but the code should still work. An unsupported attribute is one which is - ignored by the LLVM compiler, which will cause a different interpretation of + ignored by the LLVM compiler and will cause a different interpretation of the program.

            @@ -455,7 +478,7 @@
          1. Function Attributes: - Declaring that functions have no side effects, or that they can never + Declaring that functions have no side effects or that they can never return.
            Supported: format, format_arg, non_null, @@ -514,7 +537,8 @@
          2. Subscripting: Any array can be subscripted, even if not an lvalue.
          3. Pointer Arith: Arithmetic on void-pointers and function pointers.
          4. Initializers: Non-constant initializers.
          5. -
          6. Compound Literals: Compound literals give structures, unions or arrays as values.
          7. +
          8. Compound Literals: Compound literals give structures, unions, +or arrays as values.
          9. Designated Inits: Labeling elements of initializers.
          10. Cast to Union: Casting to union type from any member of the union.
          11. Case Ranges: `case 1 ... 9' and such.
          12. @@ -546,7 +570,7 @@
            -

            For this release, the C++ front-end is considered to be fully functional, but +

            For this release, the C++ front-end is considered to be fully functional but has not been tested as thoroughly as the C front-end. It has been tested and works for a number of non-trivial programs, but there may be lurking bugs. Please report any bugs or problems.

            @@ -562,9 +586,14 @@
            • The C++ front-end inherits all problems afflicting the C - front-end
            • -
            + front-end. +
          13. + +Code is generated for empty classes. + +
          14. +
            @@ -584,7 +613,7 @@
          15. Destructors for local objects are not always run when a longjmp is performed. In particular, destructors for objects in the longjmping function and in the setjmp receiver function may not be run. - Objects in intervening stack frames will be destroyed however (which is + Objects in intervening stack frames will be destroyed, however (which is better than most compilers).
          16. The LLVM C++ front-end follows the unwind instruction, so code that throws a C++ exception or calls the C longjmp function will abort.
          17. +
          18. + +The llc program can crash on legal code. + +
          19. @@ -673,7 +707,7 @@

            A wide variety of additional information is available on the LLVM web page, -including mailing lists publications describing algorithms and components +including mailing lists and publications describing algorithms and components implemented in LLVM. The web page also contains versions of the API documentation which is up-to-date with the CVS version of the source code. You can access versions of these documents specific to this release by going into @@ -695,7 +729,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
            - Last modified: $Date: 2003/12/14 22:36:45 $ + Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/Stacker.html diff -u llvm-www/releases/1.1/docs/Stacker.html:1.1 llvm-www/releases/1.1/docs/Stacker.html:1.2 --- llvm-www/releases/1.1/docs/Stacker.html:1.1 Sat Dec 13 16:03:43 2003 +++ llvm-www/releases/1.1/docs/Stacker.html Wed Dec 17 16:47:16 2003 @@ -61,7 +61,7 @@ about LLVM through the experience of creating a simple programming language named Stacker. Stacker was invented specifically as a demonstration of LLVM. The emphasis in this document is not on describing the -intricacies of LLVM itself, but on how to use it to build your own +intricacies of LLVM itself but on how to use it to build your own compiler system.

            @@ -70,7 +70,7 @@

            Amongst other things, LLVM is a platform for compiler writers. Because of its exceptionally clean and small IR (intermediate representation), compiler writing with LLVM is much easier than with -other system. As proof, the author of Stacker wrote the entire +other systems. As proof, the author of Stacker wrote the entire compiler (language definition, lexer, parser, code generator, etc.) in about four days! That's important to know because it shows how quickly you can get a new @@ -78,11 +78,11 @@ language the author ever created using LLVM. The learning curve is included in that four days.

            The language described here, Stacker, is Forth-like. Programs -are simple collections of word definitions and the only thing definitions +are simple collections of word definitions, and the only thing definitions can do is manipulate a stack or generate I/O. Stacker is not a "real" -programming language; its very simple. Although it is computationally +programming language; it's very simple. Although it is computationally complete, you wouldn't use it for your next big project. However, -the fact that it is complete, its simple, and it doesn't have +the fact that it is complete, it's simple, and it doesn't have a C-like syntax make it useful for demonstration purposes. It shows that LLVM could be applied to a wide variety of languages.

            The basic notions behind stacker is very simple. There's a stack of @@ -96,11 +96,11 @@ : MAIN hello_world ;

            This has two "definitions" (Stacker manipulates words, not functions and words have definitions): MAIN and -hello_world. The MAIN definition is standard, it +hello_world. The MAIN definition is standard; it tells Stacker where to start. Here, MAIN is defined to simply invoke the word hello_world. The hello_world definition tells stacker to push the -"Hello, World!" string onto the stack, print it out +"Hello, World!" string on to the stack, print it out (>s), pop it off the stack (DROP), and finally print a carriage return (CR). Although hello_world uses the stack, its net effect is null. Well @@ -124,7 +124,7 @@

            Although I knew that LLVM uses a Single Static Assignment (SSA) format, it wasn't obvious to me how prevalent this idea was in LLVM until I really started using it. Reading the -Programmer's Manual and Language Reference +Programmer's Manual and Language Reference, I noted that most of the important LLVM IR (Intermediate Representation) C++ classes were derived from the Value class. The full power of that simple design only became fully understood once I started constructing executable @@ -200,7 +200,7 @@

            1. Create your blocks early. While writing your compiler, you will encounter several situations where you know apriori that you will - need several blocks. For example, if-then-else, switch, while and for + need several blocks. For example, if-then-else, switch, while, and for statements in C/C++ all need multiple blocks for expression in LVVM. The rule is, create them early.
            2. Terminate your blocks early. This just reduces the chances @@ -261,15 +261,15 @@ the instructions for the "then" and "else" parts. They would use the third part of the idiom almost exclusively (inserting new instructions before the terminator). Furthermore, they could even recurse back to handle_if -should they encounter another if/then/else statement and it will just work.

              +should they encounter another if/then/else statement, and it will just work.

              Note how cleanly this all works out. In particular, the push_back methods on the BasicBlock's instruction list. These are lists of type Instruction which also happen to be Values. To create -the "if" branch we merely instantiate a BranchInst that takes as +the "if" branch, we merely instantiate a BranchInst that takes as arguments the blocks to branch to and the condition to branch on. The blocks act like branch labels! This new BranchInst terminates the BasicBlock provided as an argument. To give the caller a way -to keep inserting after calling handle_if we create an "exit" block +to keep inserting after calling handle_if, we create an "exit" block which is returned to the caller. Note that the "exit" block is used as the terminator for both the "then" and the "else" blocks. This guarantees that no matter what else "handle_if" or "fill_in" does, they end up at the "exit" block. @@ -283,7 +283,7 @@ method on the various lists. This is so common that it is worth mentioning. The "push_back" inserts a value into an STL list, vector, array, etc. at the end. The method might have also been named "insert_tail" or "append". -Althought I've used STL quite frequently, my use of push_back wasn't very +Although I've used STL quite frequently, my use of push_back wasn't very high in other programs. In LLVM, you'll use it all the time.

              @@ -292,17 +292,17 @@

              It took a little getting used to and several rounds of postings to the LLVM -mail list to wrap my head around this instruction correctly. Even though I had +mailing list to wrap my head around this instruction correctly. Even though I had read the Language Reference and Programmer's Manual a couple times each, I still missed a few very key points:

                -
              • GetElementPtrInst gives you back a Value for the last thing indexed +
              • GetElementPtrInst gives you back a Value for the last thing indexed.
              • All global variables in LLVM are pointers.
              • Pointers must also be dereferenced with the GetElementPtrInst instruction.

              This means that when you look up an element in the global variable (assuming -its a struct or array), you must deference the pointer first! For many +it's a struct or array), you must deference the pointer first! For many things, this leads to the idiom:

              
              @@ -319,13 +319,13 @@
               variable and the address of its first element as the same. That tripped me up
               for a while until I realized that they really do differ .. by type.
               Remember that LLVM is a strongly typed language itself. Everything
              -has a type.  The "type" of the global variable is [24 x int]*. That is, its
              +has a type.  The "type" of the global variable is [24 x int]*. That is, it's
               a pointer to an array of 24 ints.  When you dereference that global variable with
               a single (0) index, you now have a "[24 x int]" type.  Although
               the pointer value of the dereferenced global and the address of the zero'th element
               in the array will be the same, they differ in their type. The zero'th element has
               type "int" while the pointer value has type "[24 x int]".

              -

              Get this one aspect of LLVM right in your head and you'll save yourself +

              Get this one aspect of LLVM right in your head, and you'll save yourself a lot of compiler writing headaches down the road.

              @@ -334,7 +334,7 @@

              Linkage types in LLVM can be a little confusing, especially if your compiler writing mind has affixed very hard concepts to particular words like "weak", "external", "global", "linkonce", etc. LLVM does not use the precise -definitions of say ELF or GCC even though they share common terms. To be fair, +definitions of, say, ELF or GCC, even though they share common terms. To be fair, the concepts are related and similar but not precisely the same. This can lead you to think you know what a linkage type represents but in fact it is slightly different. I recommend you read the @@ -342,10 +342,10 @@ carefully. Then, read it again.

              Here are some handy tips that I discovered along the way:

                -
              • Unitialized means external. That is, the symbol is declared in the current +
              • Uninitialized means external. That is, the symbol is declared in the current module and can be used by that module but it is not defined by that module.
              • Setting an initializer changes a global's linkage type from whatever it was - to a normal, defind global (not external). You'll need to call the setLinkage() + to a normal, defined global (not external). You'll need to call the setLinkage() method to reset it if you specify the initializer after the GlobalValue has been constructed. This is important for LinkOnce and Weak linkage types.
              • Appending linkage can be used to keep track of compilation information at @@ -362,7 +362,7 @@ functions in the LLVM IR that make things easier. Here's what I learned:

                • Constants are Values like anything else and can be operands of instructions
                • -
                • Integer constants, frequently needed can be created using the static "get" +
                • Integer constants, frequently needed, can be created using the static "get" methods of the ConstantInt, ConstantSInt, and ConstantUInt classes. The nice thing about these is that you can "get" any kind of integer quickly.
                • There's a special method on Constant class which allows you to get the null @@ -379,14 +379,14 @@ proceeding, a few words about the stack are in order. The stack is simply a global array of 32-bit integers or pointers. A global index keeps track of the location of the top of the stack. All of this is hidden from the -programmer but it needs to be noted because it is the foundation of the +programmer, but it needs to be noted because it is the foundation of the conceptual programming model for Stacker. When you write a definition, you are, essentially, saying how you want that definition to manipulate the global stack.

                  Manipulating the stack can be quite hazardous. There is no distinction given and no checking for the various types of values that can be placed on the stack. Automatic coercion between types is performed. In many -cases this is useful. For example, a boolean value placed on the stack +cases, this is useful. For example, a boolean value placed on the stack can be interpreted as an integer with good results. However, using a word that interprets that boolean value as a pointer to a string to print out will almost always yield a crash. Stacker simply leaves it @@ -406,9 +406,9 @@

                  So, your typical definition will have the form:

                  : name ... ;

                  The name is up to you but it must start with a letter and contain -only letters numbers and underscore. Names are case sensitive and must not be +only letters, numbers, and underscore. Names are case sensitive and must not be the same as the name of a built-in word. The ... is replaced by -the stack manipulting words that you wish define name as.

                  +the stack manipulating words that you wish to define name as.

                  Comments
                  @@ -429,12 +429,12 @@
                  Literals
                  -

                  There are three kinds of literal values in Stacker. Integer, Strings, +

                  There are three kinds of literal values in Stacker: Integers, Strings, and Booleans. In each case, the stack operation is to simply push the - value onto the stack. So, for example:
                  + value on to the stack. So, for example:
                  42 " is the answer." TRUE
                  - will push three values onto the stack: the integer 42, the - string " is the answer." and the boolean TRUE.

                  + will push three values on to the stack: the integer 42, the + string " is the answer.", and the boolean TRUE.

                  Words
                  @@ -464,20 +464,20 @@

                  The built-in words of the Stacker language are put in several groups depending on what they do. The groups are as follows:

                    -
                  1. LogicalThese words provide the logical operations for +
                  2. Logical: These words provide the logical operations for comparing stack operands.
                    The words are: < > <= >= = <> true false.
                  3. -
                  4. BitwiseThese words perform bitwise computations on +
                  5. Bitwise: These words perform bitwise computations on their operands.
                    The words are: << >> XOR AND NOT
                  6. -
                  7. ArithmeticThese words perform arithmetic computations on +
                  8. Arithmetic: These words perform arithmetic computations on their operands.
                    The words are: ABS NEG + - * / MOD */ ++ -- MIN MAX
                  9. -
                  10. StackThese words manipulate the stack directly by moving +
                  11. Stack: These words manipulate the stack directly by moving its elements around.
                    The words are: DROP DUP SWAP OVER ROT DUP2 DROP2 PICK TUCK
                  12. -
                  13. MemoryThese words allocate, free and manipulate memory +
                  14. Memory: These words allocate, free, and manipulate memory areas outside the stack.
                    The words are: MALLOC FREE GET PUT
                  15. -
                  16. ControlThese words alter the normal left to right flow +
                  17. Control: These words alter the normal left to right flow of execution.
                    The words are: IF ELSE ENDIF WHILE END RETURN EXIT RECURSE
                  18. -
                  19. I/O These words perform output on the standard output +
                  20. I/O: These words perform output on the standard output and input on the standard input. No other I/O is possible in Stacker.
                    The words are: SPACE TAB CR >s >d >c <s <d <c.
                  @@ -554,12 +554,12 @@ FALSE FALSE -- b - The boolean value FALSE (0) is pushed onto the stack. + The boolean value FALSE (0) is pushed on to the stack. TRUE TRUE -- b - The boolean value TRUE (-1) is pushed onto the stack. + The boolean value TRUE (-1) is pushed on to the stack. BITWISE OPERATIONS WordNameOperationDescription @@ -604,75 +604,75 @@ ABS w -- |w| One value s popped off the stack; its absolute value is computed - and then pushed onto the stack. If w1 is -1 then w2 is 1. If w1 is + and then pushed on to the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is also 1. NEG NEG w -- -w One value is popped off the stack which is negated and then - pushed back onto the stack. If w1 is -1 then w2 is 1. If w1 is + pushed back on to the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is -1. + ADD w1 w2 -- w2+w1 Two values are popped off the stack. Their sum is pushed back - onto the stack + on to the stack - SUB w1 w2 -- w2-w1 Two values are popped off the stack. Their difference is pushed back - onto the stack + on to the stack * MUL w1 w2 -- w2*w1 Two values are popped off the stack. Their product is pushed back - onto the stack + on to the stack / DIV w1 w2 -- w2/w1 Two values are popped off the stack. Their quotient is pushed back - onto the stack + on to the stack MOD MOD w1 w2 -- w2%w1 Two values are popped off the stack. Their remainder after division - of w1 by w2 is pushed back onto the stack + of w1 by w2 is pushed back on to the stack */ STAR_SLAH w1 w2 w3 -- (w3*w2)/w1 Three values are popped off the stack. The product of w1 and w2 is - divided by w3. The result is pushed back onto the stack. + divided by w3. The result is pushed back on to the stack. ++ INCR w -- w+1 One value is popped off the stack. It is incremented by one and then - pushed back onto the stack. + pushed back on to the stack. -- DECR w -- w-1 One value is popped off the stack. It is decremented by one and then - pushed back onto the stack. + pushed back on to the stack. MIN MIN w1 w2 -- (w2<w1?w2:w1) Two values are popped off the stack. The larger one is pushed back - onto the stack. + on to the stack. MAX MAX w1 w2 -- (w2>w1?w2:w1) Two values are popped off the stack. The larger value is pushed back - onto the stack. + on to the stack. STACK MANIPULATION OPERATIONS WordNameOperationDescription @@ -703,13 +703,13 @@ DUP DUP w1 -- w1 w1 - One value is popped off the stack. That value is then pushed onto - the stack twice to duplicate the top stack vaue. + One value is popped off the stack. That value is then pushed on to + the stack twice to duplicate the top stack value. DUP2 DUP2 w1 w2 -- w1 w2 w1 w2 - The top two values on the stack are duplicated. That is, two vaues + The top two values on the stack are duplicated. That is, two values are popped off the stack. They are alternately pushed back on the stack twice each. @@ -717,7 +717,7 @@ SWAP w1 w2 -- w2 w1 The top two stack items are reversed in their order. That is, two - values are popped off the stack and pushed back onto the stack in + values are popped off the stack and pushed back on to the stack in the opposite order they were popped. SWAP2 @@ -725,27 +725,27 @@ w1 w2 w3 w4 -- w3 w4 w2 w1 The top four stack items are swapped in pairs. That is, two values are popped and retained. Then, two more values are popped and retained. - The values are pushed back onto the stack in the reverse order but + The values are pushed back on to the stack in the reverse order but in pairs.

                  OVER OVER w1 w2-- w1 w2 w1 Two values are popped from the stack. They are pushed back - onto the stack in the order w1 w2 w1. This seems to cause the + on to the stack in the order w1 w2 w1. This seems to cause the top stack element to be duplicated "over" the next value. OVER2 OVER2 w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2 - The third and fourth values on the stack are replicated onto the + The third and fourth values on the stack are replicated on to the top of the stack ROT ROT w1 w2 w3 -- w2 w3 w1 The top three values are rotated. That is, three value are popped - off the stack. They are pushed back onto the stack in the order + off the stack. They are pushed back on to the stack in the order w1 w3 w2. ROT2 @@ -822,7 +822,7 @@ One value is popped off the stack. The value is used as the size of a memory block to allocate. The size is in bytes, not words. The memory allocation is completed and the address of the memory - block is pushed onto the stack. + block is pushed on to the stack. FREE FREE @@ -911,7 +911,7 @@ The boolean value on the top of the stack is examined. If it is non-zero then the "words..." between WHILE and END are executed. Execution then begins again at the WHILE where another boolean is popped off the stack. To prevent this operation from eating up the entire - stack, you should push onto the stack (just before the END) a boolean value that indicates + stack, you should push on to the stack (just before the END) a boolean value that indicates whether to terminate. Note that since booleans and integers can be coerced you can use the following "for loop" idiom:
                  (push count) WHILE (words...) -- END
                  @@ -960,19 +960,19 @@ IN_STR -- s A string is read from the input via the scanf(3) format string " %as". The - resulting string is pushed onto the stack. + resulting string is pushed on to the stack. <d IN_STR -- w An integer is read from the input via the scanf(3) format string " %d". The - resulting value is pushed onto the stack + resulting value is pushed on to the stack <c IN_CHR -- w A single character is read from the input via the scanf(3) format string - " %c". The value is converted to an integer and pushed onto the stack. + " %c". The value is converted to an integer and pushed on to the stack. DUMP DUMP @@ -989,9 +989,9 @@

                  The following fully documented program highlights many features of both the Stacker language and what is possible with LLVM. The program has two modes of operations. If you provide numeric arguments to the program, it checks to see -if those arguments are prime numbers, prints out the results. Without any -aruments, the program prints out any prime numbers it finds between 1 and one -million (there's a log of them!). The source code comments below tell the +if those arguments are prime numbers and prints out the results. Without any +arguments, the program prints out any prime numbers it finds between 1 and one +million (there's a lot of them!). The source code comments below tell the remainder of the story.

                  @@ -1015,7 +1015,7 @@ : exit_loop FALSE; ################################################################################ -# This definition tryies an actual division of a candidate prime number. It +# This definition tries an actual division of a candidate prime number. It # determines whether the division loop on this candidate should continue or # not. # STACK<: @@ -1075,7 +1075,7 @@ # STACK<: # p - the prime number to check # STACK>: -# yn - boolean indiating if its a prime or not +# yn - boolean indicating if its a prime or not # p - the prime number checked ################################################################################ : try_harder @@ -1248,7 +1248,7 @@ under the LLVM "projects" directory. You will need to obtain the LLVM sources to find it (either via anonymous CVS or a tarball. See the Getting Started document).

                  -

                  Under the "projects" directory there is a directory named "stacker". That +

                  Under the "projects" directory there is a directory named "Stacker". That directory contains everything, as follows:

                  • lib - contains most of the source code @@ -1301,7 +1301,7 @@ definitions, the ROLL word is not implemented. This word was left out of Stacker on purpose so that it can be an exercise for the student. The exercise is to implement the ROLL functionality (in your own workspace) and build a test -program for it. If you can implement ROLL you understand Stacker and probably +program for it. If you can implement ROLL, you understand Stacker and probably a fair amount about LLVM since this is one of the more complicated Stacker operations. The work will almost be completely limited to the compiler. @@ -1326,7 +1326,7 @@ emitted currently is somewhat wasteful. It gets cleaned up a lot by existing passes but more could be done.
                  • Add -O -O1 -O2 and -O3 optimization switches to the compiler driver to - allow LLVM optimization without using "opt"
                  • + allow LLVM optimization without using "opt."
                  • Make the compiler driver use the LLVM linking facilities (with IPO) before depending on GCC to do the final link.
                  • Clean up parsing. It doesn't handle errors very well.
                  • @@ -1346,6 +1346,6 @@ +
                    Last modified: $Date: 2003/12/17 22:47:16 $ Index: llvm-www/releases/1.1/docs/TestingGuide.html diff -u llvm-www/releases/1.1/docs/TestingGuide.html:1.1 llvm-www/releases/1.1/docs/TestingGuide.html:1.2 --- llvm-www/releases/1.1/docs/TestingGuide.html:1.1 Sat Dec 13 16:03:43 2003 +++ llvm-www/releases/1.1/docs/TestingGuide.html Wed Dec 17 16:47:16 2003 @@ -422,7 +422,7 @@
                    John T. Criswell
                    The LLVM Compiler Infrastructure
                    -Last modified: $Date: 2003/12/13 22:03:43 $ +Last modified: $Date: 2003/12/17 22:47:16 $ From criswell at cs.uiuc.edu Wed Dec 17 16:50:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 16:50:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/index.html Message-ID: <200312172249.QAA01517@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: index.html updated: 1.10 -> 1.11 --- Log message: Blessing LLVM 1.1. --- Diffs of the changes: (+6 -1) Index: llvm-www/releases/index.html diff -u llvm-www/releases/index.html:1.10 llvm-www/releases/index.html:1.11 --- llvm-www/releases/index.html:1.10 Fri Dec 12 16:09:41 2003 +++ llvm-www/releases/index.html Wed Dec 17 16:48:50 2003 @@ -6,7 +6,7 @@
                    - LLVM Release 1.0 + LLVM Public Release
                    @@ -39,6 +39,10 @@
                    +

                    The 1.1 release (17 Dec 2003) is available for +download. You can read the Release Notes +here.

                    +

                    The 1.0 release (24 Oct 2003) is available for download. You can read the Release Notes here.

                    @@ -54,6 +58,7 @@ the documentation here:

                      +
                    • Complete documentation for release 1.1.
                    • Complete documentation for release 1.0.
                    • Up-to-date LLVM documentation on the LLVM Web page.
                    • From criswell at cs.uiuc.edu Wed Dec 17 16:52:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 16:52:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/download.html Message-ID: <200312172251.QAA01637@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: download.html updated: 1.7 -> 1.8 --- Log message: Blessing LLVM 1.1. --- Diffs of the changes: (+29 -4) Index: llvm-www/releases/download.html diff -u llvm-www/releases/download.html:1.7 llvm-www/releases/download.html:1.8 --- llvm-www/releases/download.html:1.7 Fri Dec 12 16:16:10 2003 +++ llvm-www/releases/download.html Wed Dec 17 16:50:50 2003 @@ -1,12 +1,12 @@ - LLVM 1.0 Download Page + LLVM Download Page
                      - LLVM 1.0 Download Page + LLVM Download Page
                      @@ -20,11 +20,36 @@
                      - +
                      Download
                      Download LLVM 1.1
                      -Please read the Release Notes before +Please read the Release Notes before +downloading: + + + +
                      + + + +
                      Download LLVM 1.0
                      + +
                      +Please read the Release Notes before downloading:
                        From criswell at cs.uiuc.edu Wed Dec 17 16:57:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 16:57:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/download.html Message-ID: <200312172256.QAA01795@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: download.html updated: 1.8 -> 1.9 --- Log message: Bless MacOS X too. :) --- Diffs of the changes: (+3 -0) Index: llvm-www/releases/download.html diff -u llvm-www/releases/download.html:1.8 llvm-www/releases/download.html:1.9 --- llvm-www/releases/download.html:1.8 Wed Dec 17 16:50:50 2003 +++ llvm-www/releases/download.html Wed Dec 17 16:56:04 2003 @@ -39,6 +39,9 @@
                      • GCC Front End Binaries for Solaris/Sparc (43.3M)
                      • +
                      • GCC Front End Binaries + for MacOS X/PowerPC (43.3M)
                      • +
                      • GCC Front End Source Code (36.1M)
                      From criswell at cs.uiuc.edu Wed Dec 17 17:03:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 17:03:01 2003 Subject: [llvm-commits] CVS: llvm-www/header.incl www-index.html Message-ID: <200312172302.RAA01940@choi.cs.uiuc.edu> Changes in directory llvm-www: header.incl updated: 1.6 -> 1.7 www-index.html updated: 1.92 -> 1.93 --- Log message: Update to 1.1. --- Diffs of the changes: (+4 -4) Index: llvm-www/header.incl diff -u llvm-www/header.incl:1.6 llvm-www/header.incl:1.7 --- llvm-www/header.incl:1.6 Mon Dec 15 14:14:58 2003 +++ llvm-www/header.incl Wed Dec 17 17:02:40 2003 @@ -32,7 +32,7 @@ Download!
                      Download now: -LLVM 1.0
                      +LLVM 1.1

                      Try the:
                      @@ -40,7 +40,7 @@
                      View the open-source
                      -license +license

                      Index: llvm-www/www-index.html diff -u llvm-www/www-index.html:1.92 llvm-www/www-index.html:1.93 --- llvm-www/www-index.html:1.92 Fri Dec 12 12:23:51 2003 +++ llvm-www/www-index.html Wed Dec 17 17:02:40 2003 @@ -101,9 +101,9 @@
                      Public LLVM Release!

                      - The LLVM 1.0 is now available for + The LLVM 1.1 is now available for download! LLVM is publicly available under the OSI-certified University of Illinois Open-Source + href="releases/1.1/LICENSE.TXT">University of Illinois Open-Source License. See answers to common licensing questions.

                      From brukman at cs.uiuc.edu Wed Dec 17 17:12:09 2003 From: brukman at cs.uiuc.edu (Misha Brukman) Date: Wed Dec 17 17:12:09 2003 Subject: [llvm-commits] CVS: llvm/docs/AliasAnalysis.html Message-ID: <200312172310.RAA30705@zion.cs.uiuc.edu> Changes in directory llvm/docs: AliasAnalysis.html updated: 1.13 -> 1.14 --- Log message: Fix the links to match our 'llvm' namespace in doxygen-generated docs. --- Diffs of the changes: (+5 -5) Index: llvm/docs/AliasAnalysis.html diff -u llvm/docs/AliasAnalysis.html:1.13 llvm/docs/AliasAnalysis.html:1.14 --- llvm/docs/AliasAnalysis.html:1.13 Wed Dec 17 12:46:49 2003 +++ llvm/docs/AliasAnalysis.html Wed Dec 17 17:10:49 2003 @@ -65,7 +65,7 @@ pointers do point to the same object, might point to the same object, or are known not to point to the same object.

                      -

                      The AliasAnalysis class is the +

                      The AliasAnalysis class is the centerpiece of the LLVM Alias Analysis related infrastructure. This class is the common interface between clients of alias analysis information and the implementations providing it. In addition to simple alias analysis information, @@ -89,7 +89,7 @@

                      -

                      The AliasAnalysis class +

                      The AliasAnalysis class defines the interface that Alias Analysis implementations should support. This class exports two important enums: AliasResult and ModRefResult which represent the result of an alias query or a mod/ref @@ -277,7 +277,7 @@

                      -

                      All of the AliasAnalysis +

                      All of the AliasAnalysis virtual methods default to providing conservatively correct information (returning "May" Alias and "Mod/Ref" for alias and mod/ref queries respectively). Depending on the capabilities of the analysis you are @@ -355,7 +355,7 @@

                      Many transformations need information about alias sets that are active in some scope, rather than information about pairwise aliasing. The AliasSetTracker class is used +href="/doxygen/classllvm_1_1AliasSetTracker.html">AliasSetTracker class is used to efficiently build these Alias Sets from the pairwise alias analysis information provided by the AliasAnalysis interface.

                      @@ -486,7 +486,7 @@ Chris Lattner
                      The LLVM Compiler Infrastructure
                      - Last modified: $Date: 2003/12/17 18:46:49 $ + Last modified: $Date: 2003/12/17 23:10:49 $ From lattner at cs.uiuc.edu Wed Dec 17 17:48:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Wed Dec 17 17:48:01 2003 Subject: [llvm-commits] CVS: llvm-www/header.incl Message-ID: <200312172347.RAA31397@zion.cs.uiuc.edu> Changes in directory llvm-www: header.incl updated: 1.7 -> 1.8 --- Log message: Add link to new status update --- Diffs of the changes: (+1 -0) Index: llvm-www/header.incl diff -u llvm-www/header.incl:1.7 llvm-www/header.incl:1.8 --- llvm-www/header.incl:1.7 Wed Dec 17 17:02:40 2003 +++ llvm-www/header.incl Wed Dec 17 17:46:57 2003 @@ -48,6 +48,7 @@ Status Updates
                      + December 17, 2003
                      November 18, 2003
                      October 7, 2003
                      September 10, 2003
                      From lattner at cs.uiuc.edu Wed Dec 17 17:51:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Wed Dec 17 17:51:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/announcement.txt Message-ID: <200312172350.RAA31671@zion.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1: announcement.txt updated: 1.4 -> 1.5 --- Log message: Add link --- Diffs of the changes: (+2 -2) Index: llvm-www/releases/1.1/announcement.txt diff -u llvm-www/releases/1.1/announcement.txt:1.4 llvm-www/releases/1.1/announcement.txt:1.5 --- llvm-www/releases/1.1/announcement.txt:1.4 Wed Dec 17 15:04:43 2003 +++ llvm-www/releases/1.1/announcement.txt Wed Dec 17 17:50:16 2003 @@ -22,7 +22,7 @@ This release is primarily a bugfix release, dramatically improving the C/C++ front-end, and improving support for C++ in the LLVM core. This release also - includes a few new features, such as a simple profiler, support for Mac OS/X, + includes a few new features, such as a simple profiler, support for Mac OS X, better interoperability with external source bases, a new example language front-end, and improvements in a few optimizations. This release also features several substantial speedups and implementation of missing features. @@ -32,7 +32,7 @@ For an easier to read set of changes, please see the status updates: http://mail.cs.uiuc.edu/pipermail/llvm-announce/2003-November/000003.html - ***** Second 1.1 status update ***** + http://mail.cs.uiuc.edu/pipermail/llvm-announce/2003-December/000004.html HOW DO I GET IT? From criswell at cs.uiuc.edu Wed Dec 17 19:22:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 19:22:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/download.html Message-ID: <200312180121.TAA02337@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: download.html updated: 1.9 -> 1.10 --- Log message: Update the sizes to be more accurate. --- Diffs of the changes: (+5 -5) Index: llvm-www/releases/download.html diff -u llvm-www/releases/download.html:1.9 llvm-www/releases/download.html:1.10 --- llvm-www/releases/download.html:1.9 Wed Dec 17 16:56:04 2003 +++ llvm-www/releases/download.html Wed Dec 17 19:21:03 2003 @@ -31,18 +31,18 @@
                    • LLVM source code (6.2M)
                    • GCC Front End - Binaries for Linux/x86 (15.3M)
                    • + Binaries for Linux/x86 (14.5M)
                    • GCC Front End - Binaries for FreeBSD/x86 (14.4M)
                    • + Binaries for FreeBSD/x86 (13.9M)
                    • GCC Front End Binaries - for Solaris/Sparc (43.3M)
                    • + for Solaris/Sparc (16.1M)
                    • GCC Front End Binaries - for MacOS X/PowerPC (43.3M)
                    • + for MacOS X/PowerPC (12.2M) -
                    • GCC Front End Source Code (36.1M)
                    • +
                    • GCC Front End Source Code (32.4M)
                    From criswell at cs.uiuc.edu Wed Dec 17 19:38:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 19:38:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/docs/CommandGuide/index.html Message-ID: <200312180137.TAA02490@choi.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1/docs/CommandGuide: index.html updated: 1.1 -> 1.2 --- Log message: Update command guide. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/1.1/docs/CommandGuide/index.html diff -u llvm-www/releases/1.1/docs/CommandGuide/index.html:1.1 llvm-www/releases/1.1/docs/CommandGuide/index.html:1.2 --- llvm-www/releases/1.1/docs/CommandGuide/index.html:1.1 Sat Dec 13 16:26:47 2003 +++ llvm-www/releases/1.1/docs/CommandGuide/index.html Wed Dec 17 19:37:38 2003 @@ -116,7 +116,7 @@
                    Maintained by the LLVM Team.
                    -Last modified: $Date: 2003/12/13 22:26:47 $ +Last modified: $Date: 2003/12/18 01:37:38 $
                    From criswell at cs.uiuc.edu Wed Dec 17 19:41:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 19:41:01 2003 Subject: [llvm-commits] CVS: llvm-www/Features.html Message-ID: <200312180140.TAA02614@choi.cs.uiuc.edu> Changes in directory llvm-www: Features.html added (r1.1) --- Log message: List of LLVM Features. --- Diffs of the changes: (+172 -0) Index: llvm-www/Features.html diff -c /dev/null llvm-www/Features.html:1.1 *** /dev/null Wed Dec 17 19:40:42 2003 --- llvm-www/Features.html Wed Dec 17 19:40:32 2003 *************** *** 0 **** --- 1,172 ---- + +
                    LLVM Features
                    + +

                    + The public release of LLVM is intended to be a fully functional release of our + compiler system for C and C++. As such, it includes the following: +

                    + +
                      +
                    • + Front-ends for C and C++ based on GCC 3.4, supporting the full ANSI-standard + C and C++ languages, plus many GCC extensions. +
                    • + +
                    • + A wide range of global scalar optimizations. +
                    • + +
                    • + A link-time interprocedural optimization framework with a rich set of + analyses and transformations, including sophisticated whole-program pointer + analysis and call graph construction. +
                    • + +
                    • + Native code generators for x86 and Sparc. +
                    • + +
                    • + A JIT code generation system for x86 and Sparc. +
                    • + +
                    • + A C back-end, useful for testing and to support other targets. +
                    • + +
                    • + A test framework with a number of benchmark codes and some applications. +
                    • + +
                    • + APIs and debugging tools to simplify rapid development. +
                    • +
                        + + LLVM Features: + + + + LLVM User Guides: + +
                          +
                        • + The LLVM Getting Started Guide + + - Discusses how to get up and running + quickly with the LLVM infrastructure. + Everything from unpacking and + compilation of the distribution to + execution of some tools.
                        • + +
                        • LLVM Command Guide + - A reference manual for the LLVM command line + utilities ("man" pages for LLVM tools).
                        • + +
                        • LLVM Project Guide + - How-to guide and templates for new + projects that use the LLVM infrastructure. + The templates (directory organization, Makefiles, + and test tree) allow the project code to be located + outside (or inside) the llvm/ tree, + while using LLVM header files and libraries.
                        • + +
                        • How to Submit A Bug + Report - Instructions for properly submitting information + about any bugs you run into in the LLVM system.
                        • + +
                        • LLVM Test Suite Guide + - A reference manual for using the LLVM test suite.
                        • + +
                        • How to build the C/C++ + front-end - Instructions for building the front-end + from source.
                        • +
                        + + Programming Documentation: + + + + + + +
                        LLVM Support
                        + +

                        + + + From criswell at cs.uiuc.edu Wed Dec 17 19:44:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 19:44:01 2003 Subject: [llvm-commits] CVS: llvm-www/Features.html Message-ID: <200312180143.TAA02731@choi.cs.uiuc.edu> Changes in directory llvm-www: Features.html updated: 1.1 -> 1.2 --- Log message: Get rid of old contents of original file. --- Diffs of the changes: (+2 -126) Index: llvm-www/Features.html diff -u llvm-www/Features.html:1.1 llvm-www/Features.html:1.2 --- llvm-www/Features.html:1.1 Wed Dec 17 19:40:32 2003 +++ llvm-www/Features.html Wed Dec 17 19:43:01 2003 @@ -1,6 +1,8 @@

                        LLVM Features
                        +LLVM Features: +

                        The public release of LLVM is intended to be a fully functional release of our compiler system for C and C++. As such, it includes the following: @@ -42,131 +44,5 @@ APIs and debugging tools to simplify rapid development.

                          - -LLVM Features: - - - - LLVM User Guides: - -
                            -
                          • - The LLVM Getting Started Guide - - - Discusses how to get up and running - quickly with the LLVM infrastructure. - Everything from unpacking and - compilation of the distribution to - execution of some tools.
                          • - -
                          • LLVM Command Guide - - A reference manual for the LLVM command line - utilities ("man" pages for LLVM tools).
                          • - -
                          • LLVM Project Guide - - How-to guide and templates for new - projects that use the LLVM infrastructure. - The templates (directory organization, Makefiles, - and test tree) allow the project code to be located - outside (or inside) the llvm/ tree, - while using LLVM header files and libraries.
                          • - -
                          • How to Submit A Bug - Report - Instructions for properly submitting information - about any bugs you run into in the LLVM system.
                          • - -
                          • LLVM Test Suite Guide - - A reference manual for using the LLVM test suite.
                          • - -
                          • How to build the C/C++ - front-end - Instructions for building the front-end - from source.
                          • -
                          - - Programming Documentation: - - - - - - -
                          LLVM Support
                          - -

                          - From criswell at cs.uiuc.edu Wed Dec 17 20:25:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Wed Dec 17 20:25:01 2003 Subject: [llvm-commits] CVS: llvm-www/Features.html Message-ID: <200312180224.UAA03106@choi.cs.uiuc.edu> Changes in directory llvm-www: Features.html updated: 1.2 -> 1.3 --- Log message: Added information on how might find it useful and links to where interested parties can find more information. --- Diffs of the changes: (+43 -5) Index: llvm-www/Features.html diff -u llvm-www/Features.html:1.2 llvm-www/Features.html:1.3 --- llvm-www/Features.html:1.2 Wed Dec 17 19:43:01 2003 +++ llvm-www/Features.html Wed Dec 17 20:24:31 2003 @@ -1,8 +1,6 @@

                          LLVM Features
                          -LLVM Features: -

                          The public release of LLVM is intended to be a fully functional release of our compiler system for C and C++. As such, it includes the following: @@ -10,8 +8,8 @@

                          • - Front-ends for C and C++ based on GCC 3.4, supporting the full ANSI-standard - C and C++ languages, plus many GCC extensions. + Front-ends for C and C++ based on GCC 3.4. They support the full + ANSI-standard C and C++ languages and many GCC extensions.
                          • @@ -33,7 +31,7 @@
                          • - A C back-end, useful for testing and to support other targets. + A C back-end useful for testing and for supporting other targets.
                          • @@ -44,5 +42,45 @@ APIs and debugging tools to simplify rapid development.
                            • + +
                              LLVM Audience
                              + +

                              +LLVM can be used in many different kinds of projects. You might be interested +in LLVM if you are: +

                              + +
                                +
                              • + A compiler researcher interested in compile-time, link-time + (interprocedural), and runtime transformations for C and C++ programs. +
                              • + +
                              • + A virtual machine researcher/developer interested in a portable, + language-independent instruction set and compilation framework. +
                              • + +
                              • + An architecture researcher interested in compiler/hardware techniques. +
                              • + +
                              • + A security researcher interested in static analysis or instrumentation. +
                              • + +
                              • + An instructor (or other person) interested in a system for quick + prototyping of compiler transformations. +
                              • +
                              + +
                              Want to Know More?
                              + +

                              +You can browse the documentation online, +try LLVM in your web browser, or +download the source code. +

                              From lattner at cs.uiuc.edu Wed Dec 17 21:10:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Wed Dec 17 21:10:01 2003 Subject: [llvm-commits] CVS: llvm-www/Features.html Message-ID: <200312180309.VAA04044@zion.cs.uiuc.edu> Changes in directory llvm-www: Features.html updated: 1.3 -> 1.4 --- Log message: minor cleanups --- Diffs of the changes: (+11 -6) Index: llvm-www/Features.html diff -u llvm-www/Features.html:1.3 llvm-www/Features.html:1.4 --- llvm-www/Features.html:1.3 Wed Dec 17 20:24:31 2003 +++ llvm-www/Features.html Wed Dec 17 21:08:50 2003 @@ -9,7 +9,7 @@
                              • Front-ends for C and C++ based on GCC 3.4. They support the full - ANSI-standard C and C++ languages and many GCC extensions. + ANSI-standard C and C++ languages, plus many GCC extensions.
                              • @@ -27,11 +27,16 @@
                              • - A JIT code generation system for x86 and Sparc. + A Just-In-Time (JIT) code generation system for x86 and Sparc.
                              • - A C back-end useful for testing and for supporting other targets. + A C back-end useful for testing, for supporting targets other than X86 and + Sparc, and allowing LLVM to use a native code generator. +
                              • + +
                              • + A simple profiling system, similar to gprof.
                              • @@ -39,9 +44,9 @@
                              • - APIs and debugging tools to simplify rapid development. + APIs and debugging tools to simplify rapid development of LLVM components.
                              • -
                                  +
                                LLVM Audience
                                @@ -78,7 +83,7 @@
                                Want to Know More?

                                -You can browse the documentation online, +You can browse the documentation online, try LLVM in your web browser, or download the source code.

                                From lattner at cs.uiuc.edu Wed Dec 17 21:11:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Wed Dec 17 21:11:01 2003 Subject: [llvm-commits] CVS: llvm-www/header.incl Message-ID: <200312180310.VAA04368@zion.cs.uiuc.edu> Changes in directory llvm-www: header.incl updated: 1.8 -> 1.9 --- Log message: Add features link to the sidebar --- Diffs of the changes: (+1 -0) Index: llvm-www/header.incl diff -u llvm-www/header.incl:1.8 llvm-www/header.incl:1.9 --- llvm-www/header.incl:1.8 Wed Dec 17 17:46:57 2003 +++ llvm-www/header.incl Wed Dec 17 21:10:11 2003 @@ -18,6 +18,7 @@ Site Map:
                                Overview
                                +Features
                                Documentation
                                Support
                                FAQ
                                From lattner at cs.uiuc.edu Thu Dec 18 00:41:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 00:41:01 2003 Subject: [llvm-commits] CVS: llvm/docs/Stacker.html Message-ID: <200312180640.AAA11913@zion.cs.uiuc.edu> Changes in directory llvm/docs: Stacker.html updated: 1.5 -> 1.6 --- Log message: Check in patch that Reid submitted --- Diffs of the changes: (+384 -336) Index: llvm/docs/Stacker.html diff -u llvm/docs/Stacker.html:1.5 llvm/docs/Stacker.html:1.6 --- llvm/docs/Stacker.html:1.5 Sun Nov 30 23:12:09 2003 +++ llvm/docs/Stacker.html Thu Dec 18 00:40:22 2003 @@ -57,7 +57,7 @@

                                This document is another way to learn about LLVM. Unlike the LLVM Reference Manual or -LLVM Programmer's Manual, we learn +LLVM Programmer's Manual, here we learn about LLVM through the experience of creating a simple programming language named Stacker. Stacker was invented specifically as a demonstration of LLVM. The emphasis in this document is not on describing the @@ -70,11 +70,10 @@

                                Amongst other things, LLVM is a platform for compiler writers. Because of its exceptionally clean and small IR (intermediate representation), compiler writing with LLVM is much easier than with -other system. As proof, the author of Stacker wrote the entire -compiler (language definition, lexer, parser, code generator, etc.) in -about four days! That's important to know because it shows -how quickly you can get a new -language up when using LLVM. Furthermore, this was the first +other system. As proof, I wrote the entire compiler (language definition, +lexer, parser, code generator, etc.) in about four days! +That's important to know because it shows how quickly you can get a new +language running when using LLVM. Furthermore, this was the first language the author ever created using LLVM. The learning curve is included in that four days.

                                The language described here, Stacker, is Forth-like. Programs @@ -136,7 +135,7 @@ You could write a function using LLVM that computes this expression like this:

                                
                                 Value* 
                                -expression(BasicBlock*bb, Value* a, Value* b, Value* x, Value* y )
                                +expression(BasicBlock* bb, Value* a, Value* b, Value* x, Value* y )
                                 {
                                     Instruction* tail = bb->getTerminator();
                                     ConstantSInt* one = ConstantSInt::get( Type::IntTy, 1);
                                @@ -154,14 +153,16 @@
                                     return mult1;
                                 }
                                 
                                -

                                "Okay, big deal," you say. It is a big deal. Here's why. Note that I didn't +

                                "Okay, big deal," you say? It is a big deal. Here's why. Note that I didn't have to tell this function which kinds of Values are being passed in. They could be -Instructions, Constants, GlobalVariables, -etc. Furthermore, if you specify Values that are incorrect for this sequence of +Instructions, Constants, GlobalVariables, or +any of the other subclasses of Value that LLVM supports. +Furthermore, if you specify Values that are incorrect for this sequence of operations, LLVM will either notice right away (at compilation time) or the LLVM -Verifier will pick up the inconsistency when the compiler runs. In no case will -you make a type error that gets passed through to the generated program. -This really helps you write a compiler that always generates correct code!

                                +Verifier will pick up the inconsistency when the compiler runs. In either case +LLVM prevents you from making a type error that gets passed through to the +generated program. This really helps you write a compiler that +always generates correct code!

                                The second point is that we don't have to worry about branching, registers, stack variables, saving partial results, etc. The instructions we create are the values we use. Note that all that was created in the above @@ -235,26 +236,26 @@ MyCompiler::handle_if( BasicBlock* bb, SetCondInst* condition ) { // Create the blocks to contain code in the structure of if/then/else - BasicBlock* then = new BasicBlock(); - BasicBlock* else = new BasicBlock(); - BasicBlock* exit = new BasicBlock(); + BasicBlock* then_bb = new BasicBlock(); + BasicBlock* else_bb = new BasicBlock(); + BasicBlock* exit_bb = new BasicBlock(); // Insert the branch instruction for the "if" - bb->getInstList().push_back( new BranchInst( then, else, condition ) ); + bb->getInstList().push_back( new BranchInst( then_bb, else_bb, condition ) ); // Set up the terminating instructions - then->getInstList().push_back( new BranchInst( exit ) ); - else->getInstList().push_back( new BranchInst( exit ) ); + then->getInstList().push_back( new BranchInst( exit_bb ) ); + else->getInstList().push_back( new BranchInst( exit_bb ) ); // Fill in the then part .. details excised for brevity - this->fill_in( then ); + this->fill_in( then_bb ); // Fill in the else part .. details excised for brevity - this->fill_in( else ); + this->fill_in( else_bb ); // Return a block to the caller that can be filled in with the code // that follows the if/then/else construct. - return exit; + return exit_bb; }

                                Presumably in the foregoing, the calls to the "fill_in" method would add @@ -264,15 +265,17 @@ should they encounter another if/then/else statement and it will just work.

                                Note how cleanly this all works out. In particular, the push_back methods on the BasicBlock's instruction list. These are lists of type -Instruction which also happen to be Values. To create +Instruction (which is also of type Value). To create the "if" branch we merely instantiate a BranchInst that takes as -arguments the blocks to branch to and the condition to branch on. The blocks -act like branch labels! This new BranchInst terminates -the BasicBlock provided as an argument. To give the caller a way -to keep inserting after calling handle_if we create an "exit" block -which is returned to the caller. Note that the "exit" block is used as the -terminator for both the "then" and the "else" blocks. This guarantees that no -matter what else "handle_if" or "fill_in" does, they end up at the "exit" block. +arguments the blocks to branch to and the condition to branch on. The +BasicBlock objects act like branch labels! This new +BranchInst terminates the BasicBlock provided +as an argument. To give the caller a way to keep inserting after calling +handle_if we create an exit_bb block which is returned +to the caller. Note that the exit_bb block is used as the +terminator for both the then_bb and the else_bb +blocks. This guarantees that no matter what else handle_if +or fill_in does, they end up at the exit_bb block.

                                @@ -318,8 +321,8 @@ will run against your grain because you'll naturally think of the global array variable and the address of its first element as the same. That tripped me up for a while until I realized that they really do differ .. by type. -Remember that LLVM is a strongly typed language itself. Everything -has a type. The "type" of the global variable is [24 x int]*. That is, its +Remember that LLVM is strongly typed. Everything has a type. +The "type" of the global variable is [24 x int]*. That is, its a pointer to an array of 24 ints. When you dereference that global variable with a single (0) index, you now have a "[24 x int]" type. Although the pointer value of the dereferenced global and the address of the zero'th element @@ -332,7 +335,7 @@
                                Getting Linkage Types Right

                                Linkage types in LLVM can be a little confusing, especially if your compiler -writing mind has affixed very hard concepts to particular words like "weak", +writing mind has affixed firm concepts to particular words like "weak", "external", "global", "linkonce", etc. LLVM does not use the precise definitions of say ELF or GCC even though they share common terms. To be fair, the concepts are related and similar but not precisely the same. This can lead @@ -342,16 +345,19 @@ carefully. Then, read it again.

                                Here are some handy tips that I discovered along the way:

                                  -
                                • Unitialized means external. That is, the symbol is declared in the current +
                                • Unitialized means external. That is, the symbol is declared in the current module and can be used by that module but it is not defined by that module.
                                • -
                                • Setting an initializer changes a global's linkage type from whatever it was - to a normal, defind global (not external). You'll need to call the setLinkage() - method to reset it if you specify the initializer after the GlobalValue has been - constructed. This is important for LinkOnce and Weak linkage types.
                                • -
                                • Appending linkage can be used to keep track of compilation information at - runtime. It could be used, for example, to build a full table of all the C++ - virtual tables or hold the C++ RTTI data, or whatever. Appending linkage can - only be applied to arrays. The arrays are concatenated together at link time.
                                • +
                                • Setting an initializer changes a global' linkage type. Setting an + initializer changes a global's linkage type from whatever it was to a normal, + defind global (not external). You'll need to call the setLinkage() method to + reset it if you specify the initializer after the GlobalValue has been constructed. + This is important for LinkOnce and Weak linkage types.
                                • +
                                • Appending linkage can keep track of things. Appending linkage can + be used to keep track of compilation information at runtime. It could be used, + for example, to build a full table of all the C++ virtual tables or hold the + C++ RTTI data, or whatever. Appending linkage can only be applied to arrays. + All arrays with the same name in each module are concatenated together at link + time.
                                @@ -423,7 +429,7 @@ # This is a comment to end of line ( This is an enclosed comment ) -

                                See the example program to see how this works in +

                                See the example program to see comments in use in a real program.

                                @@ -446,9 +452,9 @@ transformation he applies will affect the program.

                                Words in a definition come in two flavors: built-in and programmer defined. Simply mentioning the name of a previously defined or declared -programmer-defined word causes that word's definition to be invoked. It +programmer-defined word causes that word's stack actions to be invoked. It is somewhat like a function call in other languages. The built-in -words have various effects, described below.

                                +words have various effects, described below.

                                Sometimes you need to call a word before it is defined. For this, you can use the FORWARD declaration. It looks like this:

                                FORWARD name ;

                                @@ -472,7 +478,8 @@
                              • ArithmeticThese words perform arithmetic computations on their operands.
                                The words are: ABS NEG + - * / MOD */ ++ -- MIN MAX
                              • StackThese words manipulate the stack directly by moving - its elements around.
                                The words are: DROP DUP SWAP OVER ROT DUP2 DROP2 PICK TUCK
                              • + its elements around.
                                The words are: DROP DROP2 NIP NIP2 DUP DUP2 + SWAP SWAP2 OVER OVER2 ROT ROT2 RROT RROT2 TUCK TUCK2 PICK SELECT ROLL
                              • MemoryThese words allocate, free and manipulate memory areas outside the stack.
                                The words are: MALLOC FREE GET PUT
                              • ControlThese words alter the normal left to right flow @@ -500,311 +507,331 @@
                              • p - a pointer to a malloc'd memory block
            -
            - - - - - - - -
            Definition Of Operation Of Built In Words
            LOGICAL OPERATIONS
            WordNameOperationDescription
            <LTw1 w2 -- bTwo values (w1 and w2) are popped off the stack and +
            + + + + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - - - + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - - - + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + - - - - - - + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + + + - - - - + + + - - - - + + + @@ -989,9 +1031,9 @@

            The following fully documented program highlights many features of both the Stacker language and what is possible with LLVM. The program has two modes of operations. If you provide numeric arguments to the program, it checks to see -if those arguments are prime numbers, prints out the results. Without any +if those arguments are prime numbers and prints out the results. Without any aruments, the program prints out any prime numbers it finds between 1 and one -million (there's a log of them!). The source code comments below tell the +million (there's a lot of them!). The source code comments below tell the remainder of the story.

            @@ -1321,7 +1363,13 @@ interested, here are some things that could be implemented better:

            1. Write an LLVM pass to compute the correct stack depth needed by the - program.
            2. + program. Currently the stack is set to a fixed number which means programs + with large numbers of definitions might fail. +
            3. Enhance to run on 64-bit platforms like SPARC. Right now the size of a + pointer on 64-bit machines will cause incorrect results because of the 32-bit + size of a stack element currently supported. This feature was not implemented + because LLVM needs a union type to be able to support the different sizes + correctly (portably and efficiently).
            4. Write an LLVM pass to optimize the use of the global stack. The code emitted currently is somewhat wasteful. It gets cleaned up a lot by existing passes but more could be done.
            5. @@ -1335,10 +1383,10 @@ technique out until I was nearly done with LLVM. As it is, its a bad example of how to insert instructions!
            6. Provide for I/O to arbitrary files instead of just stdin/stdout.
            7. -
            8. Write additional built-in words.
            9. +
            10. Write additional built-in words; with inspiration from FORTH
            11. Write additional sample Stacker programs.
            12. -
            13. Add your own compiler writing experiences and tips in the - Lessons I Learned About LLVM section.
            14. +
            15. Add your own compiler writing experiences and tips in the + Lessons I Learned About LLVM section.
            @@ -1346,6 +1394,6 @@ +
            Last modified: $Date: 2003/12/18 06:40:22 $ From lattner at cs.uiuc.edu Thu Dec 18 02:12:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 02:12:02 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/Analysis/AliasSetTracker.h Message-ID: <200312180811.CAA28368@zion.cs.uiuc.edu> Changes in directory llvm/include/llvm/Analysis: AliasSetTracker.h updated: 1.10 -> 1.11 --- Log message: Add a new AliassetTracker::remove method. Because we need to be able to remove a pointer from an AliasSet, maintain the pointer values on a doubly linked list instead of a singly linked list, to permit efficient removal from the middle of the list. --- Diffs of the changes: (+33 -9) Index: llvm/include/llvm/Analysis/AliasSetTracker.h diff -u llvm/include/llvm/Analysis/AliasSetTracker.h:1.10 llvm/include/llvm/Analysis/AliasSetTracker.h:1.11 --- llvm/include/llvm/Analysis/AliasSetTracker.h:1.10 Sat Dec 13 22:51:34 2003 +++ llvm/include/llvm/Analysis/AliasSetTracker.h Thu Dec 18 02:11:11 2003 @@ -37,15 +37,20 @@ typedef std::pair HashNodePair; class PointerRec { - HashNodePair *NextInList; + HashNodePair **PrevInList, *NextInList; AliasSet *AS; unsigned Size; public: - PointerRec() : NextInList(0), AS(0), Size(0) {} + PointerRec() : PrevInList(0), NextInList(0), AS(0), Size(0) {} HashNodePair *getNext() const { return NextInList; } bool hasAliasSet() const { return AS != 0; } + HashNodePair** setPrevInList(HashNodePair **PIL) { + PrevInList = PIL; + return &NextInList; + } + void updateSize(unsigned NewSize) { if (NewSize > Size) Size = NewSize; } @@ -68,13 +73,14 @@ assert(AS == 0 && "Already have an alias set!"); AS = as; } - void setTail(HashNodePair *T) { - assert(NextInList == 0 && "Already have tail!"); - NextInList = T; + + void removeFromList() { + if (NextInList) NextInList->second.PrevInList = PrevInList; + *PrevInList = NextInList; } }; - HashNodePair *PtrListHead, *PtrListTail; // Singly linked list of nodes + HashNodePair *PtrList, **PtrListEnd; // Doubly linked list of nodes AliasSet *Forward; // Forwarding pointer AliasSet *Next, *Prev; // Doubly linked list of AliasSets @@ -135,7 +141,7 @@ // Alias Set iteration - Allow access to all of the pointer which are part of // this alias set... class iterator; - iterator begin() const { return iterator(PtrListHead); } + iterator begin() const { return iterator(PtrList); } iterator end() const { return iterator(); } void print(std::ostream &OS) const; @@ -175,11 +181,22 @@ private: // Can only be created by AliasSetTracker - AliasSet() : PtrListHead(0), PtrListTail(0), Forward(0), RefCount(0), + AliasSet() : PtrList(0), PtrListEnd(&PtrList), Forward(0), RefCount(0), AccessTy(NoModRef), AliasTy(MustAlias), Volatile(false) { } + AliasSet(const AliasSet &AS) { + // AliasSet's only get copy constructed in simple circumstances. In + // particular, they cannot have any pointers in their list. Despite this, + // we have to be sure to update the PtrListEnd to not point to the source + // AliasSet's list. + assert(AS.PtrList == 0 && "AliasSet has pointers in it!"); + PtrList = 0; PtrListEnd = &PtrList; + Forward = AS.Forward; RefCount = AS.RefCount; + AccessTy = AS.AccessTy; AliasTy = AS.AliasTy; Volatile = AS.Volatile; + } + HashNodePair *getSomePointer() const { - return PtrListHead ? PtrListHead : 0; + return PtrList; } /// getForwardedTarget - Return the real alias set this represents. If this @@ -246,6 +263,13 @@ void add(Instruction *I); // Dispatch to one of the other add methods... void add(BasicBlock &BB); // Add all instructions in basic block void add(const AliasSetTracker &AST); // Add alias relations from another AST + + /// remove method - This method is used to remove a pointer value from the + /// AliasSetTracker entirely. It should be used when an instruction is + /// deleted from the program to update the AST. If you don't use this, you + /// would have dangling pointers to deleted instructions. + /// + void remove(Value *PtrVal); /// getAliasSets - Return the alias sets that are active. const ilist &getAliasSets() const { return AliasSets; } From lattner at cs.uiuc.edu Thu Dec 18 02:13:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 02:13:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Analysis/AliasSetTracker.cpp Message-ID: <200312180812.CAA29360@zion.cs.uiuc.edu> Changes in directory llvm/lib/Analysis: AliasSetTracker.cpp updated: 1.9 -> 1.10 --- Log message: Add a new AliassetTracker::remove method. Because we need to be able to remove a pointer from an AliasSet, maintain the pointer values on a doubly linked list instead of a singly linked list, to permit efficient removal from the middle of the list. --- Diffs of the changes: (+36 -8) Index: llvm/lib/Analysis/AliasSetTracker.cpp diff -u llvm/lib/Analysis/AliasSetTracker.cpp:1.9 llvm/lib/Analysis/AliasSetTracker.cpp:1.10 --- llvm/lib/Analysis/AliasSetTracker.cpp:1.9 Sat Dec 13 22:52:11 2003 +++ llvm/lib/Analysis/AliasSetTracker.cpp Thu Dec 18 02:11:56 2003 @@ -47,9 +47,14 @@ RefCount++; // AS is now pointing to us... // Merge the list of constituent pointers... - PtrListTail->second.setTail(AS.PtrListHead); - PtrListTail = AS.PtrListTail; - AS.PtrListHead = AS.PtrListTail = 0; + if (AS.PtrList) { + *PtrListEnd = AS.PtrList; + AS.PtrList->second.setPrevInList(PtrListEnd); + PtrListEnd = AS.PtrListEnd; + + AS.PtrList = 0; + AS.PtrListEnd = &AS.PtrList; + } } void AliasSetTracker::removeAliasSet(AliasSet *AS) { @@ -82,11 +87,9 @@ Entry.second.updateSize(Size); // Add it to the end of the list... - if (PtrListTail) - PtrListTail->second.setTail(&Entry); - else - PtrListHead = &Entry; - PtrListTail = &Entry; + assert(*PtrListEnd == 0 && "End of list is not null?"); + *PtrListEnd = &Entry; + PtrListEnd = Entry.second.setPrevInList(PtrListEnd); RefCount++; // Entry points to alias set... } @@ -252,6 +255,31 @@ (AliasSet::AccessType)AS.AccessTy); } } + + +// remove method - This method is used to remove a pointer value from the +// AliasSetTracker entirely. It should be used when an instruction is deleted +// from the program to update the AST. If you don't use this, you would have +// dangling pointers to deleted instructions. +// +void AliasSetTracker::remove(Value *PtrVal) { + // First, look up the PointerRec for this pointer... + hash_map::iterator I = PointerMap.find(PtrVal); + if (I == PointerMap.end()) return; // Noop + + // If we found one, remove the pointer from the alias set it is in. + AliasSet::HashNodePair &PtrValEnt = *I; + AliasSet *AS = PtrValEnt.second.getAliasSet(*this); + + // Unlink from the list of values... + PtrValEnt.second.removeFromList(); + // Stop using the alias set + if (--AS->RefCount == 0) + AS->removeFromTracker(*this); + + PointerMap.erase(I); +} + //===----------------------------------------------------------------------===// // AliasSet/AliasSetTracker Printing Support From lattner at cs.uiuc.edu Thu Dec 18 02:13:08 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 02:13:08 2003 Subject: [llvm-commits] CVS: llvm/lib/Transforms/Scalar/LICM.cpp Message-ID: <200312180812.CAA30197@zion.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/Scalar: LICM.cpp updated: 1.51 -> 1.52 --- Log message: When we delete instructions from the loop, make sure to remove them from the AliasSetTracker as well. --- Diffs of the changes: (+2 -0) Index: llvm/lib/Transforms/Scalar/LICM.cpp diff -u llvm/lib/Transforms/Scalar/LICM.cpp:1.51 llvm/lib/Transforms/Scalar/LICM.cpp:1.52 --- llvm/lib/Transforms/Scalar/LICM.cpp:1.51 Sat Dec 13 22:52:31 2003 +++ llvm/lib/Transforms/Scalar/LICM.cpp Thu Dec 18 02:12:32 2003 @@ -387,6 +387,7 @@ if (ExitBlocks.size() == 1) { if (!isExitBlockDominatedByBlockInLoop(ExitBlocks[0], I.getParent())) { // Instruction is not used, just delete it. + CurAST->remove(&I); I.getParent()->getInstList().erase(&I); } else { // Move the instruction to the start of the exit block, after any PHI @@ -399,6 +400,7 @@ } } else if (ExitBlocks.size() == 0) { // The instruction is actually dead if there ARE NO exit blocks. + CurAST->remove(&I); I.getParent()->getInstList().erase(&I); } else { // Otherwise, if we have multiple exits, use the PromoteMem2Reg function to From lattner at cs.uiuc.edu Thu Dec 18 02:17:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 02:17:01 2003 Subject: [llvm-commits] CVS: llvm/docs/ReleaseNotes.html Message-ID: <200312180816.CAA32722@zion.cs.uiuc.edu> Changes in directory llvm/docs: ReleaseNotes.html updated: 1.86 -> 1.87 --- Log message: add boog --- Diffs of the changes: (+3 -1) Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.86 llvm/docs/ReleaseNotes.html:1.87 --- llvm/docs/ReleaseNotes.html:1.86 Mon Dec 15 16:48:12 2003 +++ llvm/docs/ReleaseNotes.html Thu Dec 18 02:16:25 2003 @@ -137,6 +137,8 @@
            1. [licm] LICM promotes volatile memory locations to registers
            2. +
            3. [licm] Memory read after free causes +infrequent crash
            @@ -542,7 +544,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
            - Last modified: $Date: 2003/12/15 22:48:12 $ + Last modified: $Date: 2003/12/18 08:16:25 $ From lattner at cs.uiuc.edu Thu Dec 18 02:21:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 02:21:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/1.1/docs/ReleaseNotes.html Message-ID: <200312180820.CAA00793@zion.cs.uiuc.edu> Changes in directory llvm-www/releases/1.1/docs: ReleaseNotes.html updated: 1.4 -> 1.5 --- Log message: Add boogs, fixed in 1.2 --- Diffs of the changes: (+11 -1) Index: llvm-www/releases/1.1/docs/ReleaseNotes.html diff -u llvm-www/releases/1.1/docs/ReleaseNotes.html:1.4 llvm-www/releases/1.1/docs/ReleaseNotes.html:1.5 --- llvm-www/releases/1.1/docs/ReleaseNotes.html:1.4 Wed Dec 17 16:47:16 2003 +++ llvm-www/releases/1.1/docs/ReleaseNotes.html Thu Dec 18 02:20:31 2003 @@ -374,10 +374,20 @@ Tail duplication does not update SSA form correctly. + +Bugs in 1.0 fixed in 1.1: + +
            Known problems with the C front-end @@ -729,7 +739,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
            - Last modified: $Date: 2003/12/17 22:47:16 $ + Last modified: $Date: 2003/12/18 08:20:31 $ From alkis at cs.uiuc.edu Thu Dec 18 02:49:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 02:49:01 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/LiveIntervals.h Message-ID: <200312180848.CAA28098@morpheus.cs.uiuc.edu> Changes in directory llvm/include/llvm/CodeGen: LiveIntervals.h updated: 1.3 -> 1.4 --- Log message: Handle multiple virtual register definitions gracefully. Move some of the longer LiveIntervals::Interval method out of the header and add debug information to them. Fix bug and simplify range merging code. --- Diffs of the changes: (+4 -47) Index: llvm/include/llvm/CodeGen/LiveIntervals.h diff -u llvm/include/llvm/CodeGen/LiveIntervals.h:1.3 llvm/include/llvm/CodeGen/LiveIntervals.h:1.4 --- llvm/include/llvm/CodeGen/LiveIntervals.h:1.3 Fri Dec 5 04:38:28 2003 +++ llvm/include/llvm/CodeGen/LiveIntervals.h Thu Dec 18 02:48:48 2003 @@ -59,55 +59,12 @@ return end() <= index; } - bool overlaps(unsigned index) const { - for (Ranges::const_iterator - i = ranges.begin(), e = ranges.end(); i != e; ++i) { - if (index >= i->first && index < i->second) { - return true; - } - } - return false; - } - - void addRange(unsigned start, unsigned end) { - Range range = std::make_pair(start, end); - Ranges::iterator it = - std::lower_bound(ranges.begin(), ranges.end(), range); - - if (it == ranges.end()) { - it = ranges.insert(it, range); - goto exit; - } - - assert(range.first <= it->first && "got wrong iterator?"); - // merge ranges if necesary - if (range.first < it->first) { - if (range.second >= it->first) { - it->first = range.first; - } - else { - it = ranges.insert(it, range); - assert(it != ranges.end() && "wtf?"); - goto exit; - } - } - - exit: - mergeRangesIfNecessary(it); - } + void addRange(unsigned start, unsigned end); private: - void mergeRangesIfNecessary(Ranges::iterator it) { - while (it != ranges.begin()) { - Ranges::iterator prev = it - 1; - if (prev->second < it->first) { - break; - } - prev->second = it->second; - ranges.erase(it); - it = prev; - } - } + void mergeRangesForward(Ranges::iterator it); + + void mergeRangesBackward(Ranges::iterator it); }; struct StartPointComp { From alkis at cs.uiuc.edu Thu Dec 18 02:49:08 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 02:49:08 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/LiveIntervals.cpp Message-ID: <200312180848.CAA28090@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: LiveIntervals.cpp updated: 1.8 -> 1.9 --- Log message: Handle multiple virtual register definitions gracefully. Move some of the longer LiveIntervals::Interval method out of the header and add debug information to them. Fix bug and simplify range merging code. --- Diffs of the changes: (+67 -51) Index: llvm/lib/CodeGen/LiveIntervals.cpp diff -u llvm/lib/CodeGen/LiveIntervals.cpp:1.8 llvm/lib/CodeGen/LiveIntervals.cpp:1.9 --- llvm/lib/CodeGen/LiveIntervals.cpp:1.8 Sun Dec 14 22:55:38 2003 +++ llvm/lib/CodeGen/LiveIntervals.cpp Thu Dec 18 02:48:47 2003 @@ -122,60 +122,46 @@ LiveVariables::VarInfo& vi = lv_->getVarInfo(reg); + Interval* interval = 0; Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); - // handle multiple definition case (machine instructions violating - // ssa after phi-elimination - if (r2iit != r2iMap_.end()) { - unsigned ii = r2iit->second; - Interval& interval = intervals_[ii]; - unsigned end = getInstructionIndex(mbb->back()) + 1; - DEBUG(std::cerr << "\t\t\t\tadding range: [" - << instrIndex << ',' << end << "]\n"); - interval.addRange(instrIndex, end); - DEBUG(std::cerr << "\t\t\t\t" << interval << '\n'); - } - else { + if (r2iit == r2iMap_.end()) { // add new interval intervals_.push_back(Interval(reg)); - Interval& interval = intervals_.back(); // update interval index for this register r2iMap_[reg] = intervals_.size() - 1; + interval = &intervals_.back(); + } + else { + interval = &intervals_[r2iit->second]; + } - for (MbbIndex2MbbMap::iterator - it = mbbi2mbbMap_.begin(), itEnd = mbbi2mbbMap_.end(); - it != itEnd; ++it) { - unsigned liveBlockIndex = it->first; - MachineBasicBlock* liveBlock = it->second; - if (liveBlockIndex < vi.AliveBlocks.size() && - vi.AliveBlocks[liveBlockIndex]) { - unsigned start = getInstructionIndex(liveBlock->front()); - unsigned end = getInstructionIndex(liveBlock->back()) + 1; - DEBUG(std::cerr << "\t\t\t\tadding range: [" - << start << ',' << end << "]\n"); - interval.addRange(start, end); - } - } - - bool killedInDefiningBasicBlock = false; - for (int i = 0, e = vi.Kills.size(); i != e; ++i) { - MachineBasicBlock* killerBlock = vi.Kills[i].first; - MachineInstr* killerInstr = vi.Kills[i].second; - killedInDefiningBasicBlock |= mbb == killerBlock; - unsigned start = (mbb == killerBlock ? - instrIndex : - getInstructionIndex(killerBlock->front())); - unsigned end = getInstructionIndex(killerInstr) + 1; - DEBUG(std::cerr << "\t\t\t\tadding range: [" - << start << ',' << end << "]\n"); - interval.addRange(start, end); + for (MbbIndex2MbbMap::iterator + it = mbbi2mbbMap_.begin(), itEnd = mbbi2mbbMap_.end(); + it != itEnd; ++it) { + unsigned liveBlockIndex = it->first; + MachineBasicBlock* liveBlock = it->second; + if (liveBlockIndex < vi.AliveBlocks.size() && + vi.AliveBlocks[liveBlockIndex]) { + unsigned start = getInstructionIndex(liveBlock->front()); + unsigned end = getInstructionIndex(liveBlock->back()) + 1; + interval->addRange(start, end); } + } - if (!killedInDefiningBasicBlock) { - unsigned end = getInstructionIndex(mbb->back()) + 1; - interval.addRange(instrIndex, end); - } + bool killedInDefiningBasicBlock = false; + for (int i = 0, e = vi.Kills.size(); i != e; ++i) { + MachineBasicBlock* killerBlock = vi.Kills[i].first; + MachineInstr* killerInstr = vi.Kills[i].second; + killedInDefiningBasicBlock |= mbb == killerBlock; + unsigned start = (mbb == killerBlock ? + instrIndex : + getInstructionIndex(killerBlock->front())); + unsigned end = getInstructionIndex(killerInstr) + 1; + } - DEBUG(std::cerr << "\t\t\t\t" << interval << '\n'); + if (!killedInDefiningBasicBlock) { + unsigned end = getInstructionIndex(mbb->back()) + 1; + interval->addRange(instrIndex, end); } } @@ -220,20 +206,14 @@ if (r2iit != r2iMap_.end()) { unsigned ii = r2iit->second; Interval& interval = intervals_[ii]; - DEBUG(std::cerr << "\t\t\t\tadding range: [" - << start << ',' << end << "]\n"); interval.addRange(start, end); - DEBUG(std::cerr << "\t\t\t\t" << interval << '\n'); } else { intervals_.push_back(Interval(reg)); Interval& interval = intervals_.back(); // update interval index for this register r2iMap_[reg] = intervals_.size() - 1; - DEBUG(std::cerr << "\t\t\t\tadding range: [" - << start << ',' << end << "]\n"); interval.addRange(start, end); - DEBUG(std::cerr << "\t\t\t\t" << interval << '\n'); } } @@ -308,6 +288,42 @@ std::sort(intervals_.begin(), intervals_.end(), StartPointComp()); DEBUG(std::copy(intervals_.begin(), intervals_.end(), std::ostream_iterator(std::cerr, "\n"))); +} + +void LiveIntervals::Interval::addRange(unsigned start, unsigned end) +{ + DEBUG(std::cerr << "\t\t\t\tadding range: [" << start <<','<< end << "]\n"); + //assert(start < end && "invalid range?"); + Range range = std::make_pair(start, end); + Ranges::iterator it = + ranges.insert(std::upper_bound(ranges.begin(), ranges.end(), range), + range); + + DEBUG(std::cerr << "\t\t\t\tbefore merge forward: " << *this << '\n'); + mergeRangesForward(it); + DEBUG(std::cerr << "\t\t\t\tbefore merge backward: " << *this << '\n'); + mergeRangesBackward(it); + DEBUG(std::cerr << "\t\t\t\tafter merging: " << *this << '\n'); +} + +void LiveIntervals::Interval::mergeRangesForward(Ranges::iterator it) +{ + for (Ranges::iterator next = it + 1; + next != ranges.end() && it->second >= next->first; ) { + it->second = std::max(it->second, next->second); + next = ranges.erase(next); + } +} + +void LiveIntervals::Interval::mergeRangesBackward(Ranges::iterator it) +{ + for (Ranges::iterator prev = it - 1; + it != ranges.begin() && it->first <= prev->second; ) { + it->first = std::min(it->first, prev->first); + it->second = std::max(it->second, prev->second); + it = ranges.erase(prev); + prev = it - 1; + } } std::ostream& llvm::operator<<(std::ostream& os, From alkis at cs.uiuc.edu Thu Dec 18 02:54:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 02:54:01 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/LiveIntervals.cpp Message-ID: <200312180853.CAA28154@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: LiveIntervals.cpp updated: 1.9 -> 1.10 --- Log message: When a variable is killed and redifined in a basic block only one killing instruction is tracked. This causes the LiveIntervals to create bogus intervals. The workaound is to add a range to the interval from the redefinition to the end of the basic block. --- Diffs of the changes: (+4 -1) Index: llvm/lib/CodeGen/LiveIntervals.cpp diff -u llvm/lib/CodeGen/LiveIntervals.cpp:1.9 llvm/lib/CodeGen/LiveIntervals.cpp:1.10 --- llvm/lib/CodeGen/LiveIntervals.cpp:1.9 Thu Dec 18 02:48:47 2003 +++ llvm/lib/CodeGen/LiveIntervals.cpp Thu Dec 18 02:53:43 2003 @@ -152,11 +152,14 @@ for (int i = 0, e = vi.Kills.size(); i != e; ++i) { MachineBasicBlock* killerBlock = vi.Kills[i].first; MachineInstr* killerInstr = vi.Kills[i].second; - killedInDefiningBasicBlock |= mbb == killerBlock; unsigned start = (mbb == killerBlock ? instrIndex : getInstructionIndex(killerBlock->front())); unsigned end = getInstructionIndex(killerInstr) + 1; + if (start < end) { + killedInDefiningBasicBlock |= mbb == killerBlock; + interval->addRange(start, end); + } } if (!killedInDefiningBasicBlock) { From alkis at cs.uiuc.edu Thu Dec 18 02:57:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 02:57:01 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/RegAllocLinearScan.cpp Message-ID: <200312180856.CAA28202@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: RegAllocLinearScan.cpp updated: 1.10 -> 1.11 --- Log message: Rename LiveIntervals::expired() to LiveIntervals::expiredAt(). --- Diffs of the changes: (+1 -1) Index: llvm/lib/CodeGen/RegAllocLinearScan.cpp diff -u llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.10 llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.11 --- llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.10 Sun Dec 14 07:24:16 2003 +++ llvm/lib/CodeGen/RegAllocLinearScan.cpp Thu Dec 18 02:56:11 2003 @@ -464,7 +464,7 @@ // an interval expires this is going to be the last use. in // this case we can reuse the register for a def in the same // instruction - if ((*i)->expired(cur->start() + 1)) { + if ((*i)->expiredAt(cur->start() + 1)) { DEBUG(std::cerr << "\t\tinterval " << **i << " expired\n"); if (reg < MRegisterInfo::FirstVirtualRegister) { clearReservedPhysReg(reg); From alkis at cs.uiuc.edu Thu Dec 18 02:57:08 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 02:57:08 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/LiveIntervals.h Message-ID: <200312180856.CAA28211@morpheus.cs.uiuc.edu> Changes in directory llvm/include/llvm/CodeGen: LiveIntervals.h updated: 1.4 -> 1.5 --- Log message: Rename LiveIntervals::expired() to LiveIntervals::expiredAt(). --- Diffs of the changes: (+1 -1) Index: llvm/include/llvm/CodeGen/LiveIntervals.h diff -u llvm/include/llvm/CodeGen/LiveIntervals.h:1.4 llvm/include/llvm/CodeGen/LiveIntervals.h:1.5 --- llvm/include/llvm/CodeGen/LiveIntervals.h:1.4 Thu Dec 18 02:48:48 2003 +++ llvm/include/llvm/CodeGen/LiveIntervals.h Thu Dec 18 02:56:11 2003 @@ -55,7 +55,7 @@ return ranges.back().second; } - bool expired(unsigned index) const { + bool expiredAt(unsigned index) const { return end() <= index; } From alkis at cs.uiuc.edu Thu Dec 18 07:06:03 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 07:06:03 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/LiveVariables.h Message-ID: <200312181302.HAA29036@morpheus.cs.uiuc.edu> Changes in directory llvm/include/llvm/CodeGen: LiveVariables.h updated: 1.9 -> 1.10 --- Log message: Add TwoAddressInstructionPass to handle instructions that have two or more operands and the two first operands are constrained to be the same. The pass takes an instruction of the form: a = b op c and transforms it into: a = b a = a op c and also preserves live variables. --- Diffs of the changes: (+56 -12) Index: llvm/include/llvm/CodeGen/LiveVariables.h diff -u llvm/include/llvm/CodeGen/LiveVariables.h:1.9 llvm/include/llvm/CodeGen/LiveVariables.h:1.10 --- llvm/include/llvm/CodeGen/LiveVariables.h:1.9 Sat Dec 13 05:11:02 2003 +++ llvm/include/llvm/CodeGen/LiveVariables.h Thu Dec 18 07:02:36 2003 @@ -57,15 +57,18 @@ VarInfo() : DefBlock(0), DefInst(0) {} - /// removeKill - Delete a kill corresponding to the specified machine instr - void removeKill(MachineInstr *MI) { - for (unsigned i = 0; ; ++i) { - assert(i < Kills.size() && "Machine instr is not a kill!"); - if (Kills[i].second == MI) { - Kills.erase(Kills.begin()+i); - return; + /// removeKill - Delete a kill corresponding to the specified + /// machine instruction. Returns true if there was a kill + /// corresponding to this instruction, false otherwise. + bool removeKill(MachineInstr *MI) { + for (std::vector >::iterator + i = Kills.begin(); i != Kills.end(); ++i) { + if (i->second == MI) { + Kills.erase(i); + return true; } } + return false; } }; @@ -156,30 +159,71 @@ /// specified register is killed after being used by the specified /// instruction. /// - void addVirtualRegisterKilled(unsigned IncomingReg, MachineBasicBlock *MBB, + void addVirtualRegisterKilled(unsigned IncomingReg, + MachineBasicBlock *MBB, MachineInstr *MI) { RegistersKilled.insert(std::make_pair(MI, IncomingReg)); getVarInfo(IncomingReg).Kills.push_back(std::make_pair(MBB, MI)); } + /// removeVirtualRegisterKilled - Remove the specified virtual + /// register from the live variable information. Returns true if the + /// variable was marked as killed by the specified instruction, + /// false otherwise. + bool removeVirtualRegisterKilled(unsigned reg, + MachineBasicBlock *MBB, + MachineInstr *MI) { + if (!getVarInfo(reg).removeKill(MI)) + return false; + for (killed_iterator i = killed_begin(MI), e = killed_end(MI); i != e; ) { + if (i->second == reg) + RegistersKilled.erase(i++); + else + ++i; + } + return true; + } + /// removeVirtualRegistersKilled - Remove all of the specified killed /// registers from the live variable information. void removeVirtualRegistersKilled(killed_iterator B, killed_iterator E) { - for (killed_iterator I = B; I != E; ++I) // Remove VarInfo entries... - getVarInfo(I->second).removeKill(I->first); + for (killed_iterator I = B; I != E; ++I) { // Remove VarInfo entries... + bool removed = getVarInfo(I->second).removeKill(I->first); + assert(removed && "kill not in register's VarInfo?"); + } RegistersKilled.erase(B, E); } /// addVirtualRegisterDead - Add information about the fact that the specified /// register is dead after being used by the specified instruction. /// - void addVirtualRegisterDead(unsigned IncomingReg, MachineBasicBlock *MBB, + void addVirtualRegisterDead(unsigned IncomingReg, + MachineBasicBlock *MBB, MachineInstr *MI) { RegistersDead.insert(std::make_pair(MI, IncomingReg)); getVarInfo(IncomingReg).Kills.push_back(std::make_pair(MBB, MI)); } - /// removeVirtualRegistersKilled - Remove all of the specified killed + /// removeVirtualRegisterDead - Remove the specified virtual + /// register from the live variable information. Returns true if the + /// variable was marked dead at the specified instruction, false + /// otherwise. + bool removeVirtualRegisterDead(unsigned reg, + MachineBasicBlock *MBB, + MachineInstr *MI) { + if (!getVarInfo(reg).removeKill(MI)) + return false; + + for (killed_iterator i = killed_begin(MI), e = killed_end(MI); i != e; ) { + if (i->second == reg) + RegistersKilled.erase(i++); + else + ++i; + } + return true; + } + + /// removeVirtualRegistersDead - Remove all of the specified dead /// registers from the live variable information. void removeVirtualRegistersDead(killed_iterator B, killed_iterator E) { for (killed_iterator I = B; I != E; ++I) // Remove VarInfo entries... From alkis at cs.uiuc.edu Thu Dec 18 07:07:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 07:07:01 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/TwoAddressInstructionPass.h Message-ID: <200312181306.HAA29088@morpheus.cs.uiuc.edu> Changes in directory llvm/include/llvm/CodeGen: TwoAddressInstructionPass.h added (r1.1) --- Log message: Add TwoAddressInstructionPass to handle instructions that have two or more operands and the two first operands are constrained to be the same. The pass takes an instruction of the form: a = b op c and transforms it into: a = b a = a op c and also preserves live variables. --- Diffs of the changes: (+51 -0) Index: llvm/include/llvm/CodeGen/TwoAddressInstructionPass.h diff -c /dev/null llvm/include/llvm/CodeGen/TwoAddressInstructionPass.h:1.1 *** /dev/null Thu Dec 18 07:06:14 2003 --- llvm/include/llvm/CodeGen/TwoAddressInstructionPass.h Thu Dec 18 07:06:04 2003 *************** *** 0 **** --- 1,51 ---- + //===-- llvm/CodeGen/TwoAddressInstructionPass.h - Two-Address instruction pass -*- C++ -*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file implements the Two-Address instruction rewriter pass. In + // some architectures instructions have a combined source/destination + // operand. In those cases the instruction cannot have three operands + // as the destination is implicit (for example ADD %EAX, %EBX on the + // IA-32). After code generation this restrictions are not handled and + // instructions may have three operands. This pass remedies this and + // reduces all two-address instructions to two operands. + // + //===----------------------------------------------------------------------===// + + #ifndef LLVM_CODEGEN_TWOADDRESSINSTRUCTIONPASS_H + #define LLVM_CODEGEN_TWOADDRESSINSTRUCTIONPASS_H + + #include "llvm/CodeGen/MachineFunctionPass.h" + #include "llvm/CodeGen/MachineBasicBlock.h" + #include + #include + + namespace llvm { + + class LiveVariables; + class MRegisterInfo; + + class TwoAddressInstructionPass : public MachineFunctionPass + { + private: + MachineFunction* mf_; + const TargetMachine* tm_; + const MRegisterInfo* mri_; + LiveVariables* lv_; + + public: + virtual void getAnalysisUsage(AnalysisUsage &AU) const; + + private: + /// runOnMachineFunction - pass entry point + bool runOnMachineFunction(MachineFunction&); + }; + + } // End llvm namespace + + #endif From alkis at cs.uiuc.edu Thu Dec 18 07:07:10 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 07:07:10 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/TwoAddressInstructionPass.cpp Message-ID: <200312181306.HAA29083@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: TwoAddressInstructionPass.cpp added (r1.1) --- Log message: Add TwoAddressInstructionPass to handle instructions that have two or more operands and the two first operands are constrained to be the same. The pass takes an instruction of the form: a = b op c and transforms it into: a = b a = a op c and also preserves live variables. --- Diffs of the changes: (+149 -0) Index: llvm/lib/CodeGen/TwoAddressInstructionPass.cpp diff -c /dev/null llvm/lib/CodeGen/TwoAddressInstructionPass.cpp:1.1 *** /dev/null Thu Dec 18 07:06:14 2003 --- llvm/lib/CodeGen/TwoAddressInstructionPass.cpp Thu Dec 18 07:06:03 2003 *************** *** 0 **** --- 1,149 ---- + //===-- TwoAddressInstructionPass.cpp - Two-Address instruction pass ------===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file implements the LiveInterval analysis pass which is used + // by the Linear Scan Register allocator. This pass linearizes the + // basic blocks of the function in DFS order and uses the + // LiveVariables pass to conservatively compute live intervals for + // each virtual and physical register. + // + //===----------------------------------------------------------------------===// + + #define DEBUG_TYPE "twoaddrinstr" + #include "llvm/CodeGen/TwoAddressInstructionPass.h" + #include "llvm/Function.h" + #include "llvm/CodeGen/LiveVariables.h" + #include "llvm/CodeGen/MachineFrameInfo.h" + #include "llvm/CodeGen/MachineFunctionPass.h" + #include "llvm/CodeGen/MachineInstr.h" + #include "llvm/CodeGen/Passes.h" + #include "llvm/CodeGen/SSARegMap.h" + #include "llvm/Target/MRegisterInfo.h" + #include "llvm/Target/TargetInstrInfo.h" + #include "llvm/Target/TargetMachine.h" + #include "llvm/Target/TargetRegInfo.h" + #include "Support/Debug.h" + #include "Support/Statistic.h" + #include "Support/STLExtras.h" + #include + + using namespace llvm; + + namespace { + RegisterAnalysis X( + "twoaddressinstruction", "Two-Address instruction pass"); + + Statistic<> numTwoAddressInstrs("twoaddressinstruction", + "Number of two-address instructions"); + Statistic<> numInstrsAdded("twoaddressinstruction", + "Number of instructions added"); + }; + + void TwoAddressInstructionPass::getAnalysisUsage(AnalysisUsage &AU) const + { + AU.addPreserved(); + AU.addRequired(); + AU.addPreservedID(PHIEliminationID); + AU.addRequiredID(PHIEliminationID); + MachineFunctionPass::getAnalysisUsage(AU); + } + + /// runOnMachineFunction - Reduce two-address instructions to two + /// operands + /// + bool TwoAddressInstructionPass::runOnMachineFunction(MachineFunction &fn) { + DEBUG(std::cerr << "Machine Function\n"); + mf_ = &fn; + tm_ = &fn.getTarget(); + mri_ = tm_->getRegisterInfo(); + lv_ = &getAnalysis(); + + const TargetInstrInfo& tii = tm_->getInstrInfo(); + + for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); + mbbi != mbbe; ++mbbi) { + for (MachineBasicBlock::iterator mii = mbbi->begin(); + mii != mbbi->end(); ++mii) { + MachineInstr* mi = *mii; + + unsigned opcode = mi->getOpcode(); + // ignore if it is not a two-address instruction + if (!tii.isTwoAddrInstr(opcode)) + continue; + + ++numTwoAddressInstrs; + + DEBUG(std::cerr << "\tinstruction: "; mi->print(std::cerr, *tm_)); + + // we have nothing to do if the two operands are the same + if (mi->getOperand(0).getAllocatedRegNum() == + mi->getOperand(1).getAllocatedRegNum()) + continue; + + assert(mi->getOperand(1).isRegister() && + mi->getOperand(1).getAllocatedRegNum() && + mi->getOperand(1).isUse() && + "two address instruction invalid"); + + // rewrite: + // a = b op c + // to: + // a = b + // a = a op c + unsigned regA = mi->getOperand(0).getAllocatedRegNum(); + unsigned regB = mi->getOperand(1).getAllocatedRegNum(); + bool regAisPhysical = regA < MRegisterInfo::FirstVirtualRegister; + bool regBisPhysical = regB < MRegisterInfo::FirstVirtualRegister; + + const TargetRegisterClass* rc = regAisPhysical ? + mri_->getRegClass(regA) : + mf_->getSSARegMap()->getRegClass(regA); + + numInstrsAdded += mri_->copyRegToReg(*mbbi, mii, regA, regB, rc); + + MachineInstr* prevMi = *(mii - 1); + DEBUG(std::cerr << "\t\tadded instruction: "; + prevMi->print(std::cerr, *tm_)); + + // update live variables for regA + if (regAisPhysical) { + lv_->HandlePhysRegDef(regA, prevMi); + } + else { + LiveVariables::VarInfo& varInfo = lv_->getVarInfo(regA); + varInfo.DefInst = prevMi; + } + + // update live variables for regB + if (regBisPhysical) { + lv_->HandlePhysRegUse(regB, prevMi); + } + else { + if (lv_->removeVirtualRegisterKilled(regB, &*mbbi, mi)) + lv_->addVirtualRegisterKilled(regB, &*mbbi, prevMi); + + if (lv_->removeVirtualRegisterDead(regB, &*mbbi, mi)) + lv_->addVirtualRegisterDead(regB, &*mbbi, prevMi); + } + + // replace all occurences of regB with regA + for (unsigned i = 1; i < mi->getNumOperands(); ++i) { + if (mi->getOperand(i).isRegister() && + mi->getOperand(i).getReg() == regB) + mi->SetMachineOperandReg(i, regA); + } + DEBUG(std::cerr << "\t\tmodified original to: "; + mi->print(std::cerr, *tm_)); + assert(mi->getOperand(0).getAllocatedRegNum() == + mi->getOperand(1).getAllocatedRegNum()); + } + } + + return numInstrsAdded != 0; + } From alkis at cs.uiuc.edu Thu Dec 18 07:10:05 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 07:10:05 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/RegAllocLocal.cpp Message-ID: <200312181309.HAA29127@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: RegAllocLocal.cpp updated: 1.34 -> 1.35 --- Log message: Modify local register allocator to use the two-address instruction pass. --- Diffs of the changes: (+5 -18) Index: llvm/lib/CodeGen/RegAllocLocal.cpp diff -u llvm/lib/CodeGen/RegAllocLocal.cpp:1.34 llvm/lib/CodeGen/RegAllocLocal.cpp:1.35 --- llvm/lib/CodeGen/RegAllocLocal.cpp:1.34 Sun Dec 14 07:24:16 2003 +++ llvm/lib/CodeGen/RegAllocLocal.cpp Thu Dec 18 07:08:52 2003 @@ -19,6 +19,7 @@ #include "llvm/CodeGen/SSARegMap.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/LiveVariables.h" +#include "llvm/CodeGen/TwoAddressInstructionPass.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" #include "Support/CommandLine.h" @@ -112,6 +113,7 @@ if (!DisableKill) AU.addRequired(); AU.addRequiredID(PHIEliminationID); + AU.addRequired(); MachineFunctionPass::getAnalysisUsage(AU); } @@ -571,28 +573,13 @@ unsigned DestVirtReg = MI->getOperand(i).getAllocatedRegNum(); unsigned DestPhysReg; - // If DestVirtReg already has a value, forget about it. Why doesn't - // getReg do this right? + // If DestVirtReg already has a value, use it. std::map::iterator DestI = Virt2PhysRegMap.find(DestVirtReg); if (DestI != Virt2PhysRegMap.end()) { - unsigned PhysReg = DestI->second; - Virt2PhysRegMap.erase(DestI); - removePhysReg(PhysReg); + DestPhysReg = DestI->second; } - - if (TM->getInstrInfo().isTwoAddrInstr(MI->getOpcode()) && i == 0) { - // must be same register number as the first operand - // This maps a = b + c into b += c, and saves b into a's spot - assert(MI->getOperand(1).isPhysicalRegister() && - MI->getOperand(1).getAllocatedRegNum() && - MI->getOperand(1).isUse() && - "Two address instruction invalid!"); - DestPhysReg = MI->getOperand(1).getAllocatedRegNum(); - - liberatePhysReg(MBB, I, DestPhysReg); - assignVirtToPhysReg(DestVirtReg, DestPhysReg); - } else { + else { DestPhysReg = getReg(MBB, I, DestVirtReg); } markVirtRegModified(DestVirtReg); From alkis at cs.uiuc.edu Thu Dec 18 07:13:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 07:13:01 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/RegAllocLinearScan.cpp Message-ID: <200312181312.HAA29179@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: RegAllocLinearScan.cpp updated: 1.11 -> 1.12 --- Log message: Fix bug in reserved registers. DH actually aliases DX and EDX which are not reserved registers. --- Diffs of the changes: (+2 -2) Index: llvm/lib/CodeGen/RegAllocLinearScan.cpp diff -u llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.11 llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.12 --- llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.11 Thu Dec 18 02:56:11 2003 +++ llvm/lib/CodeGen/RegAllocLinearScan.cpp Thu Dec 18 07:12:18 2003 @@ -227,14 +227,14 @@ // reserve R32: EDI, EBX, // R16: DI, BX, - // R8: DH, BH, + // R8: BH, BL // RFP: FP5, FP6 reserved_.push_back(19); /* EDI */ reserved_.push_back(17); /* EBX */ reserved_.push_back(12); /* DI */ reserved_.push_back( 7); /* BX */ - reserved_.push_back(11); /* DH */ reserved_.push_back( 4); /* BH */ + reserved_.push_back( 5); /* BL */ reserved_.push_back(28); /* FP5 */ reserved_.push_back(29); /* FP6 */ From alkis at cs.uiuc.edu Thu Dec 18 07:16:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 07:16:01 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/RegAllocLinearScan.cpp LiveIntervals.cpp Message-ID: <200312181315.HAA29233@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: RegAllocLinearScan.cpp updated: 1.12 -> 1.13 LiveIntervals.cpp updated: 1.10 -> 1.11 --- Log message: Modify linear scan register allocator to use the two-address instruction pass. This also fixes all remaining bugs for this new allocator to pass all tests under test/Programs. --- Diffs of the changes: (+39 -76) Index: llvm/lib/CodeGen/RegAllocLinearScan.cpp diff -u llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.12 llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.13 --- llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.12 Thu Dec 18 07:12:18 2003 +++ llvm/lib/CodeGen/RegAllocLinearScan.cpp Thu Dec 18 07:15:02 2003 @@ -84,6 +84,11 @@ /// runOnMachineFunction - register allocate the whole function bool runOnMachineFunction(MachineFunction&); + /// verifyIntervals - verify that we have no inconsistencies + /// in the register assignments we have in active and inactive + /// lists + bool verifyIntervals(); + /// processActiveIntervals - expire old intervals and move /// non-overlapping ones to the incative list void processActiveIntervals(Intervals::const_iterator cur); @@ -245,6 +250,8 @@ DEBUG(printIntervals("\tactive", active_.begin(), active_.end())); DEBUG(printIntervals("\tinactive", inactive_.begin(), inactive_.end())); + assert(verifyIntervals()); + processActiveIntervals(i); // processInactiveIntervals(i); @@ -321,7 +328,7 @@ for (unsigned i = 0, e = (*currentInstr_)->getNumOperands(); i != e; ++i) { MachineOperand& op = (*currentInstr_)->getOperand(i); - if (op.isVirtualRegister() && op.isUse()) { + if (op.isVirtualRegister() && op.isUse() && !op.isDef()) { unsigned virtReg = op.getAllocatedRegNum(); unsigned physReg = v2pMap_[virtReg]; if (!physReg) { @@ -361,81 +368,6 @@ } } - - // if the instruction is a two address instruction and the - // source operands are not identical we need to insert - // extra instructions. - - unsigned opcode = (*currentInstr_)->getOpcode(); - if (tm_->getInstrInfo().isTwoAddrInstr(opcode) && - (*currentInstr_)->getOperand(0).getAllocatedRegNum() != - (*currentInstr_)->getOperand(1).getAllocatedRegNum()) { - assert((*currentInstr_)->getOperand(1).isRegister() && - (*currentInstr_)->getOperand(1).getAllocatedRegNum() && - (*currentInstr_)->getOperand(1).isUse() && - "Two address instruction invalid"); - - unsigned regA = - (*currentInstr_)->getOperand(0).getAllocatedRegNum(); - unsigned regB = - (*currentInstr_)->getOperand(1).getAllocatedRegNum(); - unsigned regC = - ((*currentInstr_)->getNumOperands() > 2 && - (*currentInstr_)->getOperand(2).isRegister()) ? - (*currentInstr_)->getOperand(2).getAllocatedRegNum() : - 0; - - const TargetRegisterClass* rc = mri_->getRegClass(regA); - - // special case: "a = b op a". If b is a temporary - // reserved register rewrite as: "b = b op a; a = b" - // otherwise use a temporary reserved register t and - // rewrite as: "t = b; t = t op a; a = t" - if (regC && regA == regC) { - // b is a temp reserved register - if (find(reserved_.begin(), reserved_.end(), - regB) != reserved_.end()) { - (*currentInstr_)->SetMachineOperandReg(0, regB); - ++currentInstr_; - instrAdded_ += mri_->copyRegToReg(*currentMbb_, - currentInstr_, - regA, - regB, - rc); - --currentInstr_; - } - // b is just a normal register - else { - unsigned tempReg = getFreeTempPhysReg(rc); - assert (tempReg && - "no free temp reserved physical register?"); - instrAdded_ += mri_->copyRegToReg(*currentMbb_, - currentInstr_, - tempReg, - regB, - rc); - (*currentInstr_)->SetMachineOperandReg(0, tempReg); - (*currentInstr_)->SetMachineOperandReg(1, tempReg); - ++currentInstr_; - instrAdded_ += mri_->copyRegToReg(*currentMbb_, - currentInstr_, - regA, - tempReg, - rc); - --currentInstr_; - } - } - // "a = b op c" gets rewritten to "a = b; a = a op c" - else { - instrAdded_ += mri_->copyRegToReg(*currentMbb_, - currentInstr_, - regA, - regB, - rc); - (*currentInstr_)->SetMachineOperandReg(1, regA); - } - } - DEBUG(std::cerr << "\t\tspilling temporarily defined operands " "of this instruction:\n"); ++currentInstr_; // we want to insert after this instruction @@ -452,6 +384,35 @@ } } + return true; +} + +bool RA::verifyIntervals() +{ + std::set assignedRegisters; + for (IntervalPtrs::iterator i = active_.begin(); i != active_.end(); ++i) { + if ((*i)->reg >= MRegisterInfo::FirstVirtualRegister) { + unsigned reg = v2pMap_.find((*i)->reg)->second; + + bool inserted = assignedRegisters.insert(reg).second; + assert(inserted && "registers in active list conflict"); + } + } + + for (IntervalPtrs::iterator i = active_.begin(); i != active_.end(); ++i) { + unsigned reg = (*i)->reg; + if (reg >= MRegisterInfo::FirstVirtualRegister) { + reg = v2pMap_.find((*i)->reg)->second; + } + + for (const unsigned* as = mri_->getAliasSet(reg); *as; ++as) { + assert(assignedRegisters.find(*as) == assignedRegisters.end() && + "registers in active list alias each other"); + } + } + + // TODO: add checks between active and inactive and make sure we + // do not overlap anywhere return true; } Index: llvm/lib/CodeGen/LiveIntervals.cpp diff -u llvm/lib/CodeGen/LiveIntervals.cpp:1.10 llvm/lib/CodeGen/LiveIntervals.cpp:1.11 --- llvm/lib/CodeGen/LiveIntervals.cpp:1.10 Thu Dec 18 02:53:43 2003 +++ llvm/lib/CodeGen/LiveIntervals.cpp Thu Dec 18 07:15:02 2003 @@ -24,6 +24,7 @@ #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/SSARegMap.h" +#include "llvm/CodeGen/TwoAddressInstructionPass.h" #include "llvm/Target/MRegisterInfo.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" @@ -49,6 +50,7 @@ AU.addRequired(); AU.addPreservedID(PHIEliminationID); AU.addRequiredID(PHIEliminationID); + AU.addRequired(); MachineFunctionPass::getAnalysisUsage(AU); } From criswell at cs.uiuc.edu Thu Dec 18 10:42:04 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:42:04 2003 Subject: [llvm-commits] CVS: llvm/autoconf/configure.ac Message-ID: <200312181641.KAA05027@choi.cs.uiuc.edu> Changes in directory llvm/autoconf: configure.ac updated: 1.61 -> 1.62 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+1 -1) Index: llvm/autoconf/configure.ac diff -u llvm/autoconf/configure.ac:1.61 llvm/autoconf/configure.ac:1.62 --- llvm/autoconf/configure.ac:1.61 Fri Dec 12 14:09:33 2003 +++ llvm/autoconf/configure.ac Thu Dec 18 10:41:17 2003 @@ -15,7 +15,7 @@ dnl ************************************************************************** dnl * Initialize dnl ************************************************************************** -AC_INIT([[[LLVM]]],[[[1.0]]],[llvmbugs at cs.uiuc.edu]) +AC_INIT([[[LLVM]]],[[[1.1]]],[llvmbugs at cs.uiuc.edu]) dnl Place all of the extra autoconf files into the config subdirectory AC_CONFIG_AUX_DIR([autoconf]) From criswell at cs.uiuc.edu Thu Dec 18 10:42:12 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:42:12 2003 Subject: [llvm-commits] CVS: llvm/configure Message-ID: <200312181641.KAA05020@choi.cs.uiuc.edu> Changes in directory llvm: configure updated: 1.61 -> 1.62 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+9 -9) Index: llvm/configure diff -u llvm/configure:1.61 llvm/configure:1.62 --- llvm/configure:1.61 Fri Dec 12 14:15:23 2003 +++ llvm/configure Thu Dec 18 10:41:15 2003 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.57 for [LLVM] [1.0]. +# Generated by GNU Autoconf 2.57 for [LLVM] [1.1]. # # Report bugs to . # @@ -422,8 +422,8 @@ # Identity of this package. PACKAGE_NAME='[LLVM]' PACKAGE_TARNAME='--llvm--' -PACKAGE_VERSION='[1.0]' -PACKAGE_STRING='[LLVM] [1.0]' +PACKAGE_VERSION='[1.1]' +PACKAGE_STRING='[LLVM] [1.1]' PACKAGE_BUGREPORT='llvmbugs at cs.uiuc.edu' ac_subdirs_all="$ac_subdirs_all projects/${i}" @@ -954,7 +954,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures [LLVM] [1.0] to adapt to many kinds of systems. +\`configure' configures [LLVM] [1.1] to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1016,7 +1016,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of [LLVM] [1.0]:";; + short | recursive ) echo "Configuration of [LLVM] [1.1]:";; esac cat <<\_ACEOF @@ -1131,7 +1131,7 @@ test -n "$ac_init_help" && exit 0 if $ac_init_version; then cat <<\_ACEOF -[LLVM] configure [1.0] +[LLVM] configure [1.1] generated by GNU Autoconf 2.57 Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002 @@ -1146,7 +1146,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by [LLVM] $as_me [1.0], which was +It was created by [LLVM] $as_me [1.1], which was generated by GNU Autoconf 2.57. Invocation command line was $ $0 $@ @@ -23279,7 +23279,7 @@ } >&5 cat >&5 <<_CSEOF -This file was extended by [LLVM] $as_me [1.0], which was +This file was extended by [LLVM] $as_me [1.1], which was generated by GNU Autoconf 2.57. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -23342,7 +23342,7 @@ cat >>$CONFIG_STATUS <<_ACEOF ac_cs_version="\\ -[LLVM] config.status [1.0] +[LLVM] config.status [1.1] configured by $0, generated by GNU Autoconf 2.57, with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\" From criswell at cs.uiuc.edu Thu Dec 18 10:43:00 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:43:00 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/External/SPEC/Makefile Message-ID: <200312181642.KAA05074@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/External/SPEC: Makefile updated: 1.4 -> 1.5 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/External/SPEC/Makefile diff -u llvm/test/Programs/External/SPEC/Makefile:1.4 llvm/test/Programs/External/SPEC/Makefile:1.5 --- llvm/test/Programs/External/SPEC/Makefile:1.4 Tue Aug 19 16:30:30 2003 +++ llvm/test/Programs/External/SPEC/Makefile Thu Dec 18 10:42:05 2003 @@ -1,3 +1,3 @@ LEVEL = ../../../.. -DIRS := $(sort $(filter-out CVS/, $(wildcard */))) +DIRS := CFP2000 CINT2000 include ${LEVEL}/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Thu Dec 18 10:43:07 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:43:07 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile Message-ID: <200312181642.KAA05094@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/Ptrdist: Makefile updated: 1.3 -> 1.4 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile:1.3 llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile:1.4 --- llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile:1.3 Fri Sep 12 11:02:35 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/Ptrdist/Makefile Thu Dec 18 10:42:06 2003 @@ -1,6 +1,7 @@ # MultiSource/Ptrdist Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := anagram bc ft ks yacr2 + include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Thu Dec 18 10:43:14 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:43:14 2003 Subject: [llvm-commits] CVS: llvm/test/QMTest/expectations.linux.qmr expectations.sunos.qmr Message-ID: <200312181642.KAA05101@choi.cs.uiuc.edu> Changes in directory llvm/test/QMTest: expectations.linux.qmr updated: 1.5 -> 1.6 expectations.sunos.qmr updated: 1.5 -> 1.6 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+2 -2) Index: llvm/test/QMTest/expectations.linux.qmr diff -u llvm/test/QMTest/expectations.linux.qmr:1.5 llvm/test/QMTest/expectations.linux.qmr:1.6 --- llvm/test/QMTest/expectations.linux.qmr:1.5 Thu Dec 11 17:18:33 2003 +++ llvm/test/QMTest/expectations.linux.qmr Thu Dec 18 10:42:06 2003 @@ -3,13 +3,13 @@ qoq}q(U _Result__kindqUtestqU_Result__outcomeqUPASSqU_Result__annotationsq}U _Result__idq U0Regression.Assembler.2002-08-16-ConstExprInlinedq U_Result__contextq (cqm.test.context Context -q o}q (U_Context__propertiesq}U_Context__temporariesq}ubub.(hoq}q(hhhhh}h U(Regression.Transforms.PruneEH.simpletestqh (h o}q(h}h}ubub.(hoq}q(hhhhh}h U/Regression.CBackend.2002-08-19-HardConstantExprqh (h o}q(h}h}ubub.(hoq}q(hhhhh}h URegression.Jello.test-shiftqh (h o}q(h}h}ubub.(hoq}q(hhhUFAILqh}h U.Regression.Transforms.CorrelatedExprs.looptestqh (h o}q (h}h}ubub.(hoq!}q"(hhhhh}h U-Regression.Linker.2003-08-23-GlobalVarLinkingq#h (h o}q$(h}h}ubub.(hoq%}q&(hhhhh}h U?Regression.Transforms.Inline.2003-09-22-PHINodesInExceptionDestq'h (h o}q((h}h}ubub.(hoq)}q*(hhhhh}h U,Regression.CFrontend.2003-02-12-NonlocalGotoq+h (h o}q,(h}h}ubub.(hoq-}q.(hhhhh}h U2Regression.Transforms.FunctionResolve.retmismatch1q/h (h o}q0(h}h}ubub.(hoq1}q2(hhhhh}h U8Regression.Transforms.ADCE.2003-01-22-PredecessorProblemq3h (h o}q4(h}h}ubub.(hoq5}q6(hhhhh}h U=Regression.Transforms.LevelRaise.2002-10-08-! VarArgCallInfLoopq7h (h o}q8(h}h}ubub.(hoq9}q:(hhhhh}h U5Regression.CFrontend.2003-07-22-ArrayAccessTypeSafetyq;h (h o}q<(h}h}ubub.(hoq=}q>(hhhhh}h U8Regression.C++Frontend.2003-09-29-ArgumentNumberMismatchq?h (h o}q@(h}h}ubub.(hoqA}qB(hhhhh}h U+Regression.CFrontend.2002-09-19-StarInLabelqCh (h o}qD(h}h}ubub.(hoqE}qF(hhhhh}h U.Regression.CFrontend.2003-08-23-LocalUnionTestqGh (h o}qH(h}h}ubub.(hoqI}qJ(hhhhh}h U-Regression.C++Frontend.2003-08-28-SaveExprBugqKh (h o}qL(h}h}ubub.(hoqM}qN(hhhhh}h U"Regression.Jello.2003-06-05-PHIBugqOh (h o}qP(h}h}ubub.(hoqQ}qR(hhhhh}h U/Regression.Linker.2003-04-26-NullPtrLinkProblemqSh (h o}qT(h}h}ubub.(hoqU}qV(hhhhh}h U)Regression.Transforms.Reassociate.subtestqWh (h o}qX(h}h}ubub.(hoqY}qZ(hhhhh}h U)Regression.Linker.2002-08-20-ConstantExprq[h (h o}q\(h}h}ubub.(hoq]}q^(hhhhh}h U=Regression.Transforms.Reassociate.2002-05-15-AgressiveSubMoveq_h (h o}q`(h}h}ubub.(! hoqa}qb(hhhhh}h UARegression.Transforms.CorrelatedExprs.2002-10- 07-DominatorProblemqch (h o}qd(h}h}ubub.(hoqe}qf(hhhhh}h U>Regression.Transforms.InstCombine.2003-06-22-ConstantExprCrashqgh (h o}qh(h}h}ubub.(hoqi}qj(hhhhh}h U3Regression.Transforms.PiNodeInserter.substitutetestqkh (h o}ql(h}h}ubub.(hoqm}qn(hhhhh}h U4Regression.Transforms.SCCP.2003-08-26-InvokeHandlingqoh (h o}qp(h}h}ubub.(hoqq}qr(hhhhh}h U$Regression.Jello.2003-01-04-LoopTestqsh (h o}qt(h}h}ubub.(hoqu}qv(hhhhh}h U1Regression.Assembler.2002-04-04-PureVirtMethCall2qwh (h o}qx(h}h}ubub.(hoqy}qz(hhhhh}h U)Regression.CFrontend.2002-07-14-MiscTestsq{h (h o}q|(h}h}ubub.(hoq}}q~(hhhhh}h U(hhhhh}h U8Regression.C++Frontend.2003-09-29-ArgumentNumberMismatchq?h (h o}q@(h}h}ubub.(hoqA}qB(hhhhh}h U+Regression.CFrontend.2002-09-19-StarInLabelqCh (h o}qD(h}h}ubub.(hoqE}qF(hhhhh}h U.Regression.CFrontend.2003-08-23-LocalUnionTestqGh (h o}qH(h}h}ubub.(hoqI}qJ(hhhhh}h U-Regression.C++Frontend.2003-08-28-SaveExprBugqKh (h o}qL(h}h}ubub.(hoqM}qN(hhhhh}h U"Regression.Jello.2003-06-05-PHIBugqOh (h o}qP(h}h}ubub.(hoqQ}qR(hhhhh}h U/Regression.Linker.2003-04-26-NullPtrLinkProblemqSh (h o}qT(h}h}ubub.(hoqU}qV(hhhhh}h U)Regression.Transforms.Reassociate.subtestqWh (h o}qX(h}h}ubub.(hoqY}qZ(hhhhh}h U)Regression.Linker.2002-08-20-ConstantExprq[h (h o}q\(h}h}ubub.(hoq]}q^(hhhhh}h U=Regression.Transforms.Reassociate.2002-05-15-AgressiveSubMoveq_h (h o}q`(h}h}ubub.(hoqa}qb(hhhhh}h! UARegression.Transforms.CorrelatedExprs.2002-10-07-DominatorProblemqc h (h o}qd(h}h}ubub.(hoqe}qf(hhhhh}h U3Regression.Transforms.PiNodeInserter.substitutetestqgh (h o}qh(h}h}ubub.(hoqi}qj(hhhhh}h U4Regression.Transforms.SCCP.2003-08-26-InvokeHandlingqkh (h o}ql(h}h}ubub.(hoqm}qn(hhhhh}h U$Regression.Jello.2003-01-04-LoopTestqoh (h o}qp(h}h}ubub.(hoqq}qr(hhhhh}h U1Regression.Assembler.2002-04-04-PureVirtMethCall2qsh (h o}qt(h}h}ubub.(hoqu}qv(hhhhh}h U)Regression.CFrontend.2002-07-14-MiscTestsqwh (h o}qx(h}h}ubub.(hoqy}qz(hhhhh}h U(hhhhh}h U Regression.Reoptimizer.ticm.ticmq?h (h o}q@(h}h}ubub.(hoqA}qB(hhhhh}h U8Regression.C++Frontend.2003-09-29-ArgumentNumberMismatchqCh (h o}qD(h}h}ubub.(hoqE}qF(hhhhh}h U+Regression.CFrontend.2002-09-19-StarInLabelqGh (h o}qH(h}h}ubub.(hoqI}qJ(hhhhh}h U.Regression.CFrontend.2003-08-23-LocalUnionTestqKh (h o}qL(h}h}ubub.(hoqM}qN(hhhhh}h U/Regression.Linker.2003-04-26-NullPtrLinkProblemqOh (h o}qP(h}h}ubub.(hoqQ}qR(hhhhh}h U)Regression.Transforms.Reassociate.subtestqSh (h o}qT(h}h}ubub.(hoqU}qV(hhhhh}h U)Regression.Linker.2002-08-20-ConstantExprqWh (h o}qX(h}h}ubub.(hoqY}qZ(hhhhh}h U=Regression.Transforms.Reassociate.2002-05-15-AgressiveSubMoveq[h (h o}q\(h}h}ubub.(hoq]}q^(hhhhh}h UARegression.Transforms.CorrelatedExprs.2002-10-07-DominatorProblemq_! h (h o}q`(h}h}ubub.(hoqa}qb(hhhhh}h U3Regression.Transforms.Pi NodeInserter.substitutetestqch (h o}qd(h}h}ubub.(hoqe}qf(hhhhh}h U4Regression.Transforms.SCCP.2003-08-26-InvokeHandlingqgh (h o}qh(h}h}ubub.(hoqi}qj(hhhhh}h U-Regression.CFrontend.2002-02-18-64bitConstantqkh (h o}ql(h}h}ubub.(hoqm}qn(hhhhh}h U1Regression.Assembler.2002-04-04-PureVirtMethCall2qoh (h o}qp(h}h}ubub.(hoqq}qr(hhhhh}h U(Regression.Reoptimizer.BinInterface.testqsh (h o}qt(h}h}ubub.(hoqu}qv(hhhhh}h U(hhhhh}h U8Regression.C++Frontend.2003-09-29-ArgumentNumberMismatchq?h (h o}q@(h}h}ubub.(hoqA}qB(hhhhh}h U+Regression.CFrontend.2002-09-19-StarInLabelqCh (h o}qD(h}h}ubub.(hoqE}qF(hhhhh}h U.Regression.CFrontend.2003-08-23-LocalUnionTestqGh (h o}qH(h}h}ubub.(hoqI}qJ(hhhhh}h U-Regression.C++Frontend.2003-08-28-SaveExprBugqKh (h o}qL(h}h}ubub.(hoqM}qN(hhhhh}h U"Regression.Jello.2003-06-05-PHIBugqOh (h o}qP(h}h}ubub.(hoqQ}qR(hhhhh}h U/Regression.Linker.2003-04-26-NullPtrLinkProblemqSh (h o}qT(h}h}ubub.(hoqU}qV(hhhhh}h U)Regression.Transforms.Reassociate.subtestqWh (h o}qX(h}h}ubub.(hoqY}qZ(hhhhh}h U)Regression.Linker.2002-08-20-ConstantExprq[h (h o}q\(h}h}ubub.(hoq]}q^(hhhhh}h U=Regression.Transforms.Reassociate.2002-05-15-AgressiveSubMoveq_h (h o}q`(h}h}ubub.(hoqa}qb(hhhhh}h! UARegression.Transforms.CorrelatedExprs.2002-10-07-DominatorProblemqc h (h o}qd(h}h}ubub.(hoqe}qf(hhhhh}h U3Regression.Transforms.PiNodeInserter.substitutetestqgh (h o}qh(h}h}ubub.(hoqi}qj(hhhhh}h U4Regression.Transforms.SCCP.2003-08-26-InvokeHandlingqkh (h o}ql(h}h}ubub.(hoqm}qn(hhhhh}h U$Regression.Jello.2003-01-04-LoopTestqoh (h o}qp(h}h}ubub.(hoqq}qr(hhhhh}h U1Regression.Assembler.2002-04-04-PureVirtMethCall2qsh (h o}qt(h}h}ubub.(hoqu}qv(hhhhh}h U)Regression.CFrontend.2002-07-14-MiscTestsqwh (h o}qx(h}h}ubub.(hoqy}qz(hhhhh}h U Changes in directory llvm/test/Programs/MultiSource/Benchmarks/Olden: Makefile updated: 1.3 -> 1.4 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile:1.3 llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile:1.4 --- llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile:1.3 Fri Sep 12 11:02:21 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/Olden/Makefile Thu Dec 18 10:42:06 2003 @@ -1,6 +1,7 @@ # MultiSource/Olden Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := bh em3d mst power tsp bisort health perimeter treeadd voronoi + include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Thu Dec 18 10:43:27 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:43:27 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/External/Makefile Message-ID: <200312181642.KAA05053@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/External: Makefile updated: 1.3 -> 1.4 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/External/Makefile diff -u llvm/test/Programs/External/Makefile:1.3 llvm/test/Programs/External/Makefile:1.4 --- llvm/test/Programs/External/Makefile:1.3 Tue Aug 19 16:30:28 2003 +++ llvm/test/Programs/External/Makefile Thu Dec 18 10:41:58 2003 @@ -8,7 +8,7 @@ # # Create the list of directories to compile # -DIRS := $(sort $(filter-out CVS/, $(wildcard */))) +DIRS := SPEC ifndef USE_SPEC DIRS := $(filter-out SPEC/, $(DIRS)) endif From criswell at cs.uiuc.edu Thu Dec 18 10:43:33 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:43:33 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile Message-ID: <200312181642.KAA05084@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/McCat: Makefile updated: 1.3 -> 1.4 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile:1.3 llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile:1.4 --- llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile:1.3 Fri Sep 12 11:01:59 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/McCat/Makefile Thu Dec 18 10:42:06 2003 @@ -1,6 +1,7 @@ # MultiSource/McCat Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := 01-qbsort 04-bisect 08-main 12-IOtest 17-bintr 03-testtrie 05-eks 09-vor 15-trie 18-imp + include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Thu Dec 18 10:43:40 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:43:40 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile Message-ID: <200312181642.KAA05079@choi.cs.uiuc.edu> Changes in directory llvm/test/Programs/MultiSource/Benchmarks/FreeBench: Makefile updated: 1.1 -> 1.2 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+1 -1) Index: llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile diff -u llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile:1.1 llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile:1.2 --- llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile:1.1 Sat Oct 11 16:18:41 2003 +++ llvm/test/Programs/MultiSource/Benchmarks/FreeBench/Makefile Thu Dec 18 10:42:06 2003 @@ -1,6 +1,6 @@ # MultiSource/Olden Makefile: Build all subdirectories automatically LEVEL = ../../../../.. -PARALLEL_DIRS := $(filter-out %-disabled/, $(sort $(filter-out CVS/, $(wildcard */)))) +PARALLEL_DIRS := distray mason pcompress2 analyzer fourinarow neural pifft include $(LEVEL)/test/Programs/Makefile.programs From criswell at cs.uiuc.edu Thu Dec 18 10:44:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:44:01 2003 Subject: [llvm-commits] CVS: llvm/runtime/GCCLibraries/crtend/listend.ll Message-ID: <200312181643.KAA05236@choi.cs.uiuc.edu> Changes in directory llvm/runtime/GCCLibraries/crtend: listend.ll updated: 1.3 -> 1.4 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+0 -3) Index: llvm/runtime/GCCLibraries/crtend/listend.ll diff -u llvm/runtime/GCCLibraries/crtend/listend.ll:1.3 llvm/runtime/GCCLibraries/crtend/listend.ll:1.4 --- llvm/runtime/GCCLibraries/crtend/listend.ll:1.3 Thu May 22 14:30:11 2003 +++ llvm/runtime/GCCLibraries/crtend/listend.ll Thu Dec 18 10:43:17 2003 @@ -1,9 +1,6 @@ ; global_ctors/global_dtors terminator: this is used to add a terminating null ; value to the initialization list. -target endian = little -target pointersize = 32 - %struct..TorRec = type { int, void ()* } %llvm.global_ctors = appending global [1 x %struct..TorRec] [ From criswell at cs.uiuc.edu Thu Dec 18 10:44:07 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:44:07 2003 Subject: [llvm-commits] CVS: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Message-ID: <200312181643.KAA05243@choi.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/Scalar: IndVarSimplify.cpp updated: 1.45 -> 1.46 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+8 -15) Index: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp diff -u llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.45 llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.46 --- llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.45 Mon Dec 15 11:34:02 2003 +++ llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Thu Dec 18 10:42:57 2003 @@ -15,19 +15,19 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Scalar.h" -#include "llvm/Constants.h" -#include "llvm/Type.h" -#include "llvm/iPHINode.h" -#include "llvm/iOther.h" #include "llvm/Analysis/InductionVariable.h" #include "llvm/Analysis/LoopInfo.h" +#include "llvm/iPHINode.h" +#include "llvm/iOther.h" +#include "llvm/Type.h" +#include "llvm/Constants.h" #include "llvm/Support/CFG.h" -#include "llvm/Transforms/Utils/Local.h" #include "Support/Debug.h" #include "Support/Statistic.h" #include "Support/STLExtras.h" #include -using namespace llvm; + +namespace llvm { namespace { Statistic<> NumRemoved ("indvars", "Number of aux indvars removed"); @@ -141,8 +141,6 @@ DEBUG(IV->print(std::cerr)); - while (isa(AfterPHIIt)) ++AfterPHIIt; - // Don't do math with pointers... const Type *IVTy = IV->Phi->getType(); if (isa(IVTy)) IVTy = Type::ULongTy; @@ -188,12 +186,6 @@ IV->Phi->setName(""); Val->setName(OldName); - // Get the incoming values used by the PHI node - std::vector PHIOps; - PHIOps.reserve(IV->Phi->getNumIncomingValues()); - for (unsigned i = 0, e = IV->Phi->getNumIncomingValues(); i != e; ++i) - PHIOps.push_back(IV->Phi->getIncomingValue(i)); - // Delete the old, now unused, phi node... Header->getInstList().erase(IV->Phi); @@ -250,7 +242,8 @@ "Canonicalize Induction Variables"); } -Pass *llvm::createIndVarSimplifyPass() { +Pass *createIndVarSimplifyPass() { return new InductionVariableSimplify(); } +} // End llvm namespace From criswell at cs.uiuc.edu Thu Dec 18 10:44:14 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 10:44:14 2003 Subject: [llvm-commits] CVS: llvm/docs/CFEBuildInstrs.html GettingStarted.html ReleaseNotes.html Stacker.html Message-ID: <200312181643.KAA05208@choi.cs.uiuc.edu> Changes in directory llvm/docs: CFEBuildInstrs.html updated: 1.10 -> 1.11 GettingStarted.html updated: 1.46 -> 1.47 ReleaseNotes.html updated: 1.87 -> 1.88 Stacker.html updated: 1.6 -> 1.7 --- Log message: Merged in RELEASE_11. --- Diffs of the changes: (+276 -121) Index: llvm/docs/CFEBuildInstrs.html diff -u llvm/docs/CFEBuildInstrs.html:1.10 llvm/docs/CFEBuildInstrs.html:1.11 --- llvm/docs/CFEBuildInstrs.html:1.10 Wed Dec 10 14:04:13 2003 +++ llvm/docs/CFEBuildInstrs.html Thu Dec 18 10:43:11 2003 @@ -14,6 +14,7 @@
            1. A Cautionary Note
            2. Instructions +
            3. License Information
            @@ -114,7 +115,23 @@ --enable-languages=c,c++ --host=sparcv9-sun-solaris2.8 % gmake all-gcc % setenv LLVM_LIB_SEARCH_PATH `pwd`/gcc - % gmake all; gmake install + % gmake all + + +

            +At this point, libstdc++ may fail to build because of wchar errors (look for +errors that reference vfwscanf or wcstof). If that happens, +edit sparcv9-sun-solaris2.8/libstdc++-v3/config.h and comment out the +line that defines _GLIBCXX_USE_WCHAR_T. +

            + +

            +Then, continue as below: +

            + +
            + % gmake all
            + % gmake install
             

            Common Problem: You may get error messages regarding the fact @@ -197,13 +214,55 @@

            + + +
            +

            +The LLVM GCC frontend is licensed to you under the GNU General Public License +and the GNU Lesser General Public License. Please see the files COPYING and +COPYING.LIB for more details. +

            + +

            +The software also has the following additional copyrights: +

            + +
            +Copyright (c) 1994
            +Hewlett-Packard Company
            +
            +Permission to use, copy, modify, distribute and sell this software
            +and its documentation for any purpose is hereby granted without fee,
            +provided that the above copyright notice appear in all copies and
            +that both that copyright notice and this permission notice appear
            +in supporting documentation.  Hewlett-Packard Company makes no
            +representations about the suitability of this software for any
            +purpose.  It is provided "as is" without express or implied warranty.
            +
            +Copyright (c) 1996, 1997, 1998, 1999
            +Silicon Graphics Computer Systems, Inc.
            +
            +Permission to use, copy, modify, distribute and sell this software
            +and its documentation for any purpose is hereby granted without fee,
            +provided that the above copyright notice appear in all copies and
            +that both that copyright notice and this permission notice appear
            +in supporting documentation.  Silicon Graphics makes no
            +representations about the suitability of this software for any
            +purpose.  It is provided "as is" without express or implied warranty.
            +
            +
            + + +
            Index: llvm/docs/GettingStarted.html diff -u llvm/docs/GettingStarted.html:1.46 llvm/docs/GettingStarted.html:1.47 --- llvm/docs/GettingStarted.html:1.46 Fri Nov 21 19:30:01 2003 +++ llvm/docs/GettingStarted.html Thu Dec 18 10:43:11 2003 @@ -129,7 +129,8 @@ header files for the default platform. Useful options include:
            • --with-llvmgccdir=directory -

              Specify where the LLVM GCC frontend is installed.

            • +

              Specify the full pathname of where the LLVM GCC frontend is + installed.

            • --enable-spec2000=directory

              Enable the SPEC2000 benchmarks for testing. The SPEC2000 benchmarks should be available in @@ -181,24 +182,55 @@

            • Linux on x86 (Pentium and above)
                -
              • Approximately 760 MB of Free Disk Space +
              • Approximately 918 MB of Free Disk Space
                  -
                • Source code: 30 MB
                • -
                • Object code: 670 MB
                • -
                • GCC front end: 60 MB
                • +
                • Source code: 28 MB
                • +
                • Object code: 850 MB
                • +
                • GCC front end: 40 MB
              • -
            • +
            + + +

          20. Solaris on SparcV9 (Ultrasparc)
              -
            • Approximately 1.24 GB of Free Disk Space +
            • Approximately 1.52 GB of Free Disk Space +
                +
              • Source code: 28 MB
              • +
              • Object code: 1470 MB
              • +
              • GCC front end: 50 MB
              • +
            • +
            +
          21. + +

            + +
          22. FreeBSD on x86 (Pentium and above) +
              +
            • Approximately 918 MB of Free Disk Space +
                +
              • Source code: 28 MB
              • +
              • Object code: 850 MB
              • +
              • GCC front end: 40 MB
              • +
            • +
            +
          23. + +

            + +
          24. MacOS X on PowerPC +
              +
            • No native code generation +
            • Approximately 1.20 GB of Free Disk Space
                -
              • Source code: 30 MB
              • -
              • Object code: 1000 MB
              • -
              • GCC front end: 210 MB
              • +
              • Source code: 28 MB
              • +
              • Object code: 1160 MB
              • +
              • GCC front end: 40 MB
            • -
          25. + +

            The LLVM suite may compile on other platforms, but it is not @@ -252,7 +284,6 @@ -

            The remainder of this guide is meant to get you up and running with LLVM and to give you some basic information about the LLVM environment. A complete guide to installation is provided in the @@ -347,22 +378,31 @@

            If you have the LLVM distribution, you will need to unpack it before you -can begin to compile it. LLVM is distributed as a set of three files. Each +can begin to compile it. LLVM is distributed as a set of two files: the LLVM +suite and the LLVM GCC front end compiled for your platform. Each file is a TAR archive that is compressed with the gzip program.

            -

            The three files are as follows: +

            The files are as follows:

            -
            llvm.tar.gz +
            llvm-1.1.tar.gz
            This is the source code to the LLVM suite.

            -

            cfrontend.sparc.tar.gz +
            cfrontend-1.1.sparc-sun-solaris2.8.tar.gz
            This is the binary release of the GCC front end for Solaris/Sparc.

            -

            cfrontend.x86.tar.gz +
            cfrontend-1.1.i686-redhat-linux-gnu.tar.gz
            This is the binary release of the GCC front end for Linux/x86. +

            + +

            cfrontend-1.1.i386-unknown-freebsd5.1.tar.gz +
            This is the binary release of the GCC front end for FreeBSD/x86. +

            + +

            cfrontend-1.1.powerpc-apple-darwin7.0.0.tar.gz +
            This is the binary release of the GCC front end for MacOS X/PPC.
            @@ -390,6 +430,20 @@ directory and fully populate it with the LLVM source code, Makefiles, test directories, and local copies of documentation files.

            +

            +If you want to get a specific release (as opposed to the most recent revision), +you can specify a label. The following releases have the following label: +

              +
            • + Release 1.1: RELEASE_11 +
            • + +
            • + Release 1.0: RELEASE_1 +
            • +
            +

            +

            Note that the GCC front end is not included in the CVS repository. You should have downloaded the binary distribution for your platform.

            @@ -411,12 +465,12 @@
            1. cd where-you-want-the-front-end-to-live
            2. -
            3. gunzip --stdout cfrontend.platform.tar.gz | tar -xvf +
            4. gunzip --stdout cfrontend-version.platform.tar.gz | tar -xvf -
            -

            If you are on a Sparc/Solaris machine, you will need to fix the header -files:

            +

            If you are using Solaris/Sparc or MacOS X/PPC, you will need to fix the +header files:

            cd cfrontend/sparc
            ./fixheaders

            @@ -442,7 +496,8 @@

            Once checked out from the CVS repository, the LLVM suite source code must be configured via the configure script. This script sets variables in llvm/Makefile.config and llvm/include/Config/config.h. It -also populates OBJ_ROOT with the Makefiles needed to build LLVM.

            +also populates OBJ_ROOT with the Makefiles needed to begin building +LLVM.

            The following environment variables are used by the configure script to configure the build system:

            @@ -476,7 +531,8 @@
            --with-llvmgccdir=LLVMGCCDIR
            Path to the location where the LLVM C front end binaries and - associated libraries will be installed. + associated libraries were installed. This must be specified as an + absolute pathname.

            --enable-optimized
            @@ -486,7 +542,8 @@

            --enable-jit
            - Compile the Just In Time (JIT) functionality. This is not available + Compile the Just In Time (JIT) compiler functionality. This is not + available on all platforms. The default is dependent on platform, so it is best to explicitly enable it if you want it.

            @@ -519,10 +576,10 @@ LLVM_LIB_SEARCH_PATH environment variable in your startup scripts. This environment variable is used to locate "system" libraries like "-lc" and "-lm" when linking. This variable should be set to -the absolute path for the bytecode-libs subdirectory of the GCC front end -install, or LLVMGCCDIR/bytecode-libs. For example, one might set +the absolute path of the bytecode-libs subdirectory of the GCC front +end, or LLVMGCCDIR/bytecode-libs. For example, one might set LLVM_LIB_SEARCH_PATH to -/home/vadve/lattner/local/x86/llvm-gcc/bytecode-libs for the X86 +/home/vadve/lattner/local/x86/llvm-gcc/bytecode-libs for the x86 version of the GCC front end on our research machines.

            @@ -1089,7 +1146,7 @@
            Chris Lattner
            The LLVM Compiler Infrastructure
            - Last modified: $Date: 2003/11/22 01:30:01 $ + Last modified: $Date: 2003/12/18 16:43:11 $
            Index: llvm/docs/ReleaseNotes.html diff -u llvm/docs/ReleaseNotes.html:1.87 llvm/docs/ReleaseNotes.html:1.88 --- llvm/docs/ReleaseNotes.html:1.87 Thu Dec 18 02:16:25 2003 +++ llvm/docs/ReleaseNotes.html Thu Dec 18 10:43:14 2003 @@ -18,7 +18,6 @@
          26. Installation Instructions
          27. Known Problems
              -
            • Known problems with the LLVM Core
            • Known problems with the C Front-end
            • Known problems with the C++ Front-end @@ -30,7 +29,7 @@
              -

              Written by Chris Lattner

              +

              Written by the LLVM team

              @@ -43,10 +42,10 @@

              This document contains the release notes for the LLVM compiler infrastructure, release 1.2. Here we describe the status of LLVM, including any -known problems, and bug fixes from the previous release. The most up-to-date +known problems and bug fixes from the previous release. The most up-to-date version of this document can be found on the LLVM 1.2 web site. If you are -not reading this on the LLVM web pages, you should probably go there, because +not reading this on the LLVM web pages, you should probably go there because this document may be updated after the release.

              For more information about LLVM, including information about potentially more @@ -70,8 +69,7 @@

              -

              This is the third public release of the LLVM compiler infrastructure. OTHER -OVERVIEW STUFF HERE. +

              This is the third public release of the LLVM compiler infrastructure.

              At this time, LLVM is known to correctly compile and run all non-unwinding C @@ -82,10 +80,10 @@

              -The LLVM native code generators are very stable, but do not currently support +The LLVM native code generators are very stable but do not currently support unwinding (exception throwing or longjmping), which prevent them from working with programs like the 253.perlbmk in SPEC CPU2000. The C -backend and the rest of LLVM does support these programs however, so you can +backend and the rest of LLVM supports these programs, so you can still use LLVM with them. Support for unwinding will be added in a future release.

              @@ -164,11 +162,11 @@

              LLVM has been extensively tested on Intel and AMD machines running Red Hat Linux and FreeBSD. It has also been tested on Sun UltraSPARC workstations running Solaris 8. Additionally, -LLVM works on Mac OS/X 10.3 and above, but only with the C backend or +LLVM works on Mac OS X 10.3 and above, but only with the C backend or interpreter (no native backend for the PowerPC is available yet). The core LLVM infrastructure uses "autoconf" for portability, so hopefully we work on more platforms than that. However, it is likely that we -missed something, and that minor porting is required to get LLVM to work on +missed something and that minor porting is required to get LLVM to work on new platforms. We welcome portability patches and error messages.

              @@ -184,7 +182,7 @@

              This section contains all known problems with the LLVM system, listed by component. As new problems are discovered, they will be added to these sections. If you run into a problem, please check the LLVM bug database, and submit a bug if +href="http://llvm.cs.uiuc.edu/bugs/">LLVM bug database and submit a bug if there isn't already one.

              @@ -219,6 +217,18 @@
            • LLVM cannot handle structures with more than 256 elements.
            • +
            • +The gccld program + +does not link objects/archives in the order specified on the command line. + +
            • + +
            • + +Tail duplication does not update SSA form correctly. + +
            @@ -232,9 +242,7 @@
            Bugs
            - -
            @@ -277,11 +304,11 @@ the following extensions are known to not be supported:
            1. Local Labels: Labels local to a block.
            2. -
            3. Labels as Values: Getting pointers to labels, and computed gotos.
            4. +
            5. Labels as Values: Getting pointers to labels and computed gotos.
            6. Nested Functions: As in Algol and Pascal, lexical scoping of functions.
            7. Constructing Calls: Dispatching a call to another function.
            8. Extended Asm: Assembler instructions with C expressions as operands.
            9. -
            10. Constraints: Constraints for asm operands
            11. +
            12. Constraints: Constraints for asm operands.
            13. Asm Labels: Specifying the assembler name to use for a C symbol.
            14. Explicit Reg Vars: Defining variables residing in specified registers.
            15. Return Address: Getting the return or frame address of a function.
            16. @@ -294,7 +321,7 @@

              The following GCC extensions are partially supported. An ignored attribute means that the LLVM compiler ignores the presence of the attribute, but the code should still work. An unsupported attribute is one which is - ignored by the LLVM compiler, which will cause a different interpretation of + ignored by the LLVM compiler and will cause a different interpretation of the program.

                @@ -304,7 +331,7 @@
              1. Function Attributes: - Declaring that functions have no side effects, or that they can never + Declaring that functions have no side effects or that they can never return.
                Supported: format, format_arg, non_null, @@ -363,7 +390,8 @@
              2. Subscripting: Any array can be subscripted, even if not an lvalue.
              3. Pointer Arith: Arithmetic on void-pointers and function pointers.
              4. Initializers: Non-constant initializers.
              5. -
              6. Compound Literals: Compound literals give structures, unions or arrays as values.
              7. +
              8. Compound Literals: Compound literals give structures, unions, +or arrays as values.
              9. Designated Inits: Labeling elements of initializers.
              10. Cast to Union: Casting to union type from any member of the union.
              11. Case Ranges: `case 1 ... 9' and such.
              12. @@ -395,7 +423,7 @@
                -

                For this release, the C++ front-end is considered to be fully functional, but +

                For this release, the C++ front-end is considered to be fully functional but has not been tested as thoroughly as the C front-end. It has been tested and works for a number of non-trivial programs, but there may be lurking bugs. Please report any bugs or problems.

                @@ -411,9 +439,14 @@
                • The C++ front-end inherits all problems afflicting the C - front-end
                • -
                + front-end. +
              13. + +Code is generated for empty classes. + +
              14. +
                @@ -433,7 +466,7 @@
              15. Destructors for local objects are not always run when a longjmp is performed. In particular, destructors for objects in the longjmping function and in the setjmp receiver function may not be run. - Objects in intervening stack frames will be destroyed however (which is + Objects in intervening stack frames will be destroyed, however (which is better than most compilers).
              16. The LLVM C++ front-end follows the unwind instruction, so code that throws a C++ exception or calls the C longjmp function will abort.
              17. +
              18. + +The llc program can crash on legal code. + +
              19. @@ -522,7 +560,7 @@

                A wide variety of additional information is available on the LLVM web page, -including mailing lists publications describing algorithms and components +including mailing lists and publications describing algorithms and components implemented in LLVM. The web page also contains versions of the API documentation which is up-to-date with the CVS version of the source code. You can access versions of these documents specific to this release by going into @@ -544,7 +582,7 @@ src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /> The LLVM Compiler Infrastructure
                - Last modified: $Date: 2003/12/18 08:16:25 $ + Last modified: $Date: 2003/12/18 16:43:14 $ Index: llvm/docs/Stacker.html diff -u llvm/docs/Stacker.html:1.6 llvm/docs/Stacker.html:1.7 --- llvm/docs/Stacker.html:1.6 Thu Dec 18 00:40:22 2003 +++ llvm/docs/Stacker.html Thu Dec 18 10:43:14 2003 @@ -61,7 +61,7 @@ about LLVM through the experience of creating a simple programming language named Stacker. Stacker was invented specifically as a demonstration of LLVM. The emphasis in this document is not on describing the -intricacies of LLVM itself, but on how to use it to build your own +intricacies of LLVM itself but on how to use it to build your own compiler system.

                @@ -77,11 +77,11 @@ language the author ever created using LLVM. The learning curve is included in that four days.

                The language described here, Stacker, is Forth-like. Programs -are simple collections of word definitions and the only thing definitions +are simple collections of word definitions, and the only thing definitions can do is manipulate a stack or generate I/O. Stacker is not a "real" -programming language; its very simple. Although it is computationally +programming language; it's very simple. Although it is computationally complete, you wouldn't use it for your next big project. However, -the fact that it is complete, its simple, and it doesn't have +the fact that it is complete, it's simple, and it doesn't have a C-like syntax make it useful for demonstration purposes. It shows that LLVM could be applied to a wide variety of languages.

                The basic notions behind stacker is very simple. There's a stack of @@ -95,11 +95,11 @@ : MAIN hello_world ;

                This has two "definitions" (Stacker manipulates words, not functions and words have definitions): MAIN and -hello_world. The MAIN definition is standard, it +hello_world. The MAIN definition is standard; it tells Stacker where to start. Here, MAIN is defined to simply invoke the word hello_world. The hello_world definition tells stacker to push the -"Hello, World!" string onto the stack, print it out +"Hello, World!" string on to the stack, print it out (>s), pop it off the stack (DROP), and finally print a carriage return (CR). Although hello_world uses the stack, its net effect is null. Well @@ -123,7 +123,7 @@

                Although I knew that LLVM uses a Single Static Assignment (SSA) format, it wasn't obvious to me how prevalent this idea was in LLVM until I really started using it. Reading the -Programmer's Manual and Language Reference +Programmer's Manual and Language Reference, I noted that most of the important LLVM IR (Intermediate Representation) C++ classes were derived from the Value class. The full power of that simple design only became fully understood once I started constructing executable @@ -201,7 +201,7 @@

                1. Create your blocks early. While writing your compiler, you will encounter several situations where you know apriori that you will - need several blocks. For example, if-then-else, switch, while and for + need several blocks. For example, if-then-else, switch, while, and for statements in C/C++ all need multiple blocks for expression in LVVM. The rule is, create them early.
                2. Terminate your blocks early. This just reduces the chances @@ -262,7 +262,7 @@ the instructions for the "then" and "else" parts. They would use the third part of the idiom almost exclusively (inserting new instructions before the terminator). Furthermore, they could even recurse back to handle_if -should they encounter another if/then/else statement and it will just work.

                  +should they encounter another if/then/else statement, and it will just work.

                  Note how cleanly this all works out. In particular, the push_back methods on the BasicBlock's instruction list. These are lists of type Instruction (which is also of type Value). To create @@ -271,7 +271,8 @@ BasicBlock objects act like branch labels! This new BranchInst terminates the BasicBlock provided as an argument. To give the caller a way to keep inserting after calling -handle_if we create an exit_bb block which is returned +handle_if, we create an exit_bb block which is +returned to the caller. Note that the exit_bb block is used as the terminator for both the then_bb and the else_bb blocks. This guarantees that no matter what else handle_if @@ -286,7 +287,7 @@ method on the various lists. This is so common that it is worth mentioning. The "push_back" inserts a value into an STL list, vector, array, etc. at the end. The method might have also been named "insert_tail" or "append". -Althought I've used STL quite frequently, my use of push_back wasn't very +Although I've used STL quite frequently, my use of push_back wasn't very high in other programs. In LLVM, you'll use it all the time.

                  @@ -295,17 +296,17 @@

                  It took a little getting used to and several rounds of postings to the LLVM -mail list to wrap my head around this instruction correctly. Even though I had +mailing list to wrap my head around this instruction correctly. Even though I had read the Language Reference and Programmer's Manual a couple times each, I still missed a few very key points:

                    -
                  • GetElementPtrInst gives you back a Value for the last thing indexed +
                  • GetElementPtrInst gives you back a Value for the last thing indexed.
                  • All global variables in LLVM are pointers.
                  • Pointers must also be dereferenced with the GetElementPtrInst instruction.

                  This means that when you look up an element in the global variable (assuming -its a struct or array), you must deference the pointer first! For many +it's a struct or array), you must deference the pointer first! For many things, this leads to the idiom:

                  
                  @@ -322,13 +323,13 @@
                   variable and the address of its first element as the same. That tripped me up
                   for a while until I realized that they really do differ .. by type.
                   Remember that LLVM is strongly typed. Everything has a type.  
                  -The "type" of the global variable is [24 x int]*. That is, its
                  +The "type" of the global variable is [24 x int]*. That is, it's
                   a pointer to an array of 24 ints.  When you dereference that global variable with
                   a single (0) index, you now have a "[24 x int]" type.  Although
                   the pointer value of the dereferenced global and the address of the zero'th element
                   in the array will be the same, they differ in their type. The zero'th element has
                   type "int" while the pointer value has type "[24 x int]".

                  -

                  Get this one aspect of LLVM right in your head and you'll save yourself +

                  Get this one aspect of LLVM right in your head, and you'll save yourself a lot of compiler writing headaches down the road.

                  @@ -337,7 +338,7 @@

                  Linkage types in LLVM can be a little confusing, especially if your compiler writing mind has affixed firm concepts to particular words like "weak", "external", "global", "linkonce", etc. LLVM does not use the precise -definitions of say ELF or GCC even though they share common terms. To be fair, +definitions of, say, ELF or GCC, even though they share common terms. To be fair, the concepts are related and similar but not precisely the same. This can lead you to think you know what a linkage type represents but in fact it is slightly different. I recommend you read the @@ -346,10 +347,10 @@

                  Here are some handy tips that I discovered along the way:

                  • Unitialized means external. That is, the symbol is declared in the current - module and can be used by that module but it is not defined by that module.
                  • + module and can be used by that module, but it is not defined by that module.
                  • Setting an initializer changes a global' linkage type. Setting an initializer changes a global's linkage type from whatever it was to a normal, - defind global (not external). You'll need to call the setLinkage() method to + defined global (not external). You'll need to call the setLinkage() method to reset it if you specify the initializer after the GlobalValue has been constructed. This is important for LinkOnce and Weak linkage types.
                  • Appending linkage can keep track of things. Appending linkage can @@ -368,7 +369,7 @@ functions in the LLVM IR that make things easier. Here's what I learned:

                    • Constants are Values like anything else and can be operands of instructions
                    • -
                    • Integer constants, frequently needed can be created using the static "get" +
                    • Integer constants, frequently needed, can be created using the static "get" methods of the ConstantInt, ConstantSInt, and ConstantUInt classes. The nice thing about these is that you can "get" any kind of integer quickly.
                    • There's a special method on Constant class which allows you to get the null @@ -385,14 +386,14 @@ proceeding, a few words about the stack are in order. The stack is simply a global array of 32-bit integers or pointers. A global index keeps track of the location of the top of the stack. All of this is hidden from the -programmer but it needs to be noted because it is the foundation of the +programmer, but it needs to be noted because it is the foundation of the conceptual programming model for Stacker. When you write a definition, you are, essentially, saying how you want that definition to manipulate the global stack.

                      Manipulating the stack can be quite hazardous. There is no distinction given and no checking for the various types of values that can be placed on the stack. Automatic coercion between types is performed. In many -cases this is useful. For example, a boolean value placed on the stack +cases, this is useful. For example, a boolean value placed on the stack can be interpreted as an integer with good results. However, using a word that interprets that boolean value as a pointer to a string to print out will almost always yield a crash. Stacker simply leaves it @@ -412,9 +413,9 @@

                      So, your typical definition will have the form:

                      : name ... ;

                      The name is up to you but it must start with a letter and contain -only letters numbers and underscore. Names are case sensitive and must not be +only letters, numbers, and underscore. Names are case sensitive and must not be the same as the name of a built-in word. The ... is replaced by -the stack manipulting words that you wish define name as.

                      +the stack manipulating words that you wish to define name as.

                      Comments
                      @@ -435,12 +436,12 @@
                      Literals
                      -

                      There are three kinds of literal values in Stacker. Integer, Strings, +

                      There are three kinds of literal values in Stacker: Integers, Strings, and Booleans. In each case, the stack operation is to simply push the - value onto the stack. So, for example:
                      + value on to the stack. So, for example:
                      42 " is the answer." TRUE
                      - will push three values onto the stack: the integer 42, the - string " is the answer." and the boolean TRUE.

                      + will push three values on to the stack: the integer 42, the + string " is the answer.", and the boolean TRUE.

                      Words
                      @@ -470,21 +471,21 @@

                      The built-in words of the Stacker language are put in several groups depending on what they do. The groups are as follows:

                        -
                      1. LogicalThese words provide the logical operations for +
                      2. Logical: These words provide the logical operations for comparing stack operands.
                        The words are: < > <= >= = <> true false.
                      3. -
                      4. BitwiseThese words perform bitwise computations on +
                      5. Bitwise: These words perform bitwise computations on their operands.
                        The words are: << >> XOR AND NOT
                      6. -
                      7. ArithmeticThese words perform arithmetic computations on +
                      8. Arithmetic: These words perform arithmetic computations on their operands.
                        The words are: ABS NEG + - * / MOD */ ++ -- MIN MAX
                      9. StackThese words manipulate the stack directly by moving its elements around.
                        The words are: DROP DROP2 NIP NIP2 DUP DUP2 SWAP SWAP2 OVER OVER2 ROT ROT2 RROT RROT2 TUCK TUCK2 PICK SELECT ROLL
                      10. -
                      11. MemoryThese words allocate, free and manipulate memory +
                      12. MemoryThese words allocate, free, and manipulate memory areas outside the stack.
                        The words are: MALLOC FREE GET PUT
                      13. -
                      14. ControlThese words alter the normal left to right flow +
                      15. Control: These words alter the normal left to right flow of execution.
                        The words are: IF ELSE ENDIF WHILE END RETURN EXIT RECURSE
                      16. -
                      17. I/O These words perform output on the standard output +
                      18. I/O: These words perform output on the standard output and input on the standard input. No other I/O is possible in Stacker.
                        The words are: SPACE TAB CR >s >d >c <s <d <c.
                      @@ -566,12 +567,12 @@
          28. - + - + @@ -626,75 +627,75 @@ + on to the stack + on to the stack + on to the stack + on to the stack + of w1 by w2 is pushed back on to the stack + divided by w3. The result is pushed back on to the stack. + pushed back on to the stack. + pushed back on to the stack. + on to the stack. + on to the stack. @@ -730,7 +731,7 @@ - @@ -744,7 +745,7 @@ @@ -752,27 +753,27 @@ - @@ -854,7 +855,7 @@ + block is pushed on to the stack. @@ -948,7 +949,7 @@ + resulting string is pushed on to the stack. + resulting value is pushed on to the stack + " %c". The value is converted to an integer and pushed on to the stack. @@ -1030,9 +1031,9 @@

            The following fully documented program highlights many features of both the Stacker language and what is possible with LLVM. The program has two modes -of operations. If you provide numeric arguments to the program, it checks to see +of operation. If you provide numeric arguments to the program, it checks to see if those arguments are prime numbers and prints out the results. Without any -aruments, the program prints out any prime numbers it finds between 1 and one +arguments, the program prints out any prime numbers it finds between 1 and one million (there's a lot of them!). The source code comments below tell the remainder of the story.

            @@ -1057,7 +1058,7 @@ : exit_loop FALSE; ################################################################################ -# This definition tryies an actual division of a candidate prime number. It +# This definition tries an actual division of a candidate prime number. It # determines whether the division loop on this candidate should continue or # not. # STACK<: @@ -1117,7 +1118,7 @@ # STACK<: # p - the prime number to check # STACK>: -# yn - boolean indiating if its a prime or not +# yn - boolean indicating if its a prime or not # p - the prime number checked ################################################################################ : try_harder @@ -1290,7 +1291,7 @@ under the LLVM "projects" directory. You will need to obtain the LLVM sources to find it (either via anonymous CVS or a tarball. See the Getting Started document).

            -

            Under the "projects" directory there is a directory named "stacker". That +

            Under the "projects" directory there is a directory named "Stacker". That directory contains everything, as follows:

            • lib - contains most of the source code @@ -1343,7 +1344,7 @@ definitions, the ROLL word is not implemented. This word was left out of Stacker on purpose so that it can be an exercise for the student. The exercise is to implement the ROLL functionality (in your own workspace) and build a test -program for it. If you can implement ROLL you understand Stacker and probably +program for it. If you can implement ROLL, you understand Stacker and probably a fair amount about LLVM since this is one of the more complicated Stacker operations. The work will almost be completely limited to the compiler. @@ -1374,7 +1375,7 @@ emitted currently is somewhat wasteful. It gets cleaned up a lot by existing passes but more could be done.
            • Add -O -O1 -O2 and -O3 optimization switches to the compiler driver to - allow LLVM optimization without using "opt"
            • + allow LLVM optimization without using "opt."
            • Make the compiler driver use the LLVM linking facilities (with IPO) before depending on GCC to do the final link.
            • Clean up parsing. It doesn't handle errors very well.
            • @@ -1394,6 +1395,6 @@ +
              Last modified: $Date: 2003/12/18 16:43:14 $
            From criswell at cs.uiuc.edu Thu Dec 18 11:20:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:20:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Message-ID: <200312181719.LAA09598@choi.cs.uiuc.edu> Changes in directory llvm/lib/Transforms/Scalar: IndVarSimplify.cpp updated: 1.46 -> 1.47 --- Log message: Reverted back to previous revision - this was previously merged according to the CVS log messages. --- Diffs of the changes: (+15 -8) Index: llvm/lib/Transforms/Scalar/IndVarSimplify.cpp diff -u llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.46 llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.47 --- llvm/lib/Transforms/Scalar/IndVarSimplify.cpp:1.46 Thu Dec 18 10:42:57 2003 +++ llvm/lib/Transforms/Scalar/IndVarSimplify.cpp Thu Dec 18 11:19:19 2003 @@ -15,19 +15,19 @@ //===----------------------------------------------------------------------===// #include "llvm/Transforms/Scalar.h" -#include "llvm/Analysis/InductionVariable.h" -#include "llvm/Analysis/LoopInfo.h" +#include "llvm/Constants.h" +#include "llvm/Type.h" #include "llvm/iPHINode.h" #include "llvm/iOther.h" -#include "llvm/Type.h" -#include "llvm/Constants.h" +#include "llvm/Analysis/InductionVariable.h" +#include "llvm/Analysis/LoopInfo.h" #include "llvm/Support/CFG.h" +#include "llvm/Transforms/Utils/Local.h" #include "Support/Debug.h" #include "Support/Statistic.h" #include "Support/STLExtras.h" #include - -namespace llvm { +using namespace llvm; namespace { Statistic<> NumRemoved ("indvars", "Number of aux indvars removed"); @@ -141,6 +141,8 @@ DEBUG(IV->print(std::cerr)); + while (isa(AfterPHIIt)) ++AfterPHIIt; + // Don't do math with pointers... const Type *IVTy = IV->Phi->getType(); if (isa(IVTy)) IVTy = Type::ULongTy; @@ -186,6 +188,12 @@ IV->Phi->setName(""); Val->setName(OldName); + // Get the incoming values used by the PHI node + std::vector PHIOps; + PHIOps.reserve(IV->Phi->getNumIncomingValues()); + for (unsigned i = 0, e = IV->Phi->getNumIncomingValues(); i != e; ++i) + PHIOps.push_back(IV->Phi->getIncomingValue(i)); + // Delete the old, now unused, phi node... Header->getInstList().erase(IV->Phi); @@ -242,8 +250,7 @@ "Canonicalize Induction Variables"); } -Pass *createIndVarSimplifyPass() { +Pass *llvm::createIndVarSimplifyPass() { return new InductionVariableSimplify(); } -} // End llvm namespace From criswell at cs.uiuc.edu Thu Dec 18 11:25:00 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:25:00 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181724.LAA21396@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.4 -> 1.5 --- Log message: Re-enabling logging. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.4 llvm-www/releases/testregister.cgi:1.5 --- llvm-www/releases/testregister.cgi:1.4 Thu Dec 18 11:24:21 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 11:24:49 2003 @@ -181,7 +181,7 @@ # # Log the information provided by the form. # -#LogForm (form) +LogForm (form) # # Subscribe the user the LLVM Announcements list (if they so desire) From criswell at cs.uiuc.edu Thu Dec 18 11:25:08 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:25:08 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181724.LAA21040@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.3 -> 1.4 --- Log message: Testing logging functionality. --- Diffs of the changes: (+13 -6) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.3 llvm-www/releases/testregister.cgi:1.4 --- llvm-www/releases/testregister.cgi:1.3 Tue Dec 16 15:11:53 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 11:24:21 2003 @@ -10,6 +10,9 @@ # List of email addresses that want to know when people download notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] +# Full pathname of the logfile +logfilename='/var/tmp/LLVMDownloads' + # # Function: Subscribe() # @@ -144,6 +147,16 @@ except: pass mailer.quit () + + # + # Open the logfile, lock it, and write a new entry. + # + logfile = file (logfilename, 'ra') + os.lockf (logfile, os.LOCK_EX) + logfile.write (email + ':' + lastname + ':' + firstname + '\n') + logfile.flush () + logfile.close () + return # @@ -175,12 +188,6 @@ # #Subscribe (form) -# -# Create a cookie so that the user does not need to register again. -# -usercookie = Cookie.SmartCookie() -usercookie["LLVM"] = "Yes" -print usercookie # # Send the user to the download page. From criswell at cs.uiuc.edu Thu Dec 18 11:26:00 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:26:00 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181725.LAA22683@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.5 -> 1.6 --- Log message: Don't bother Chris and Vikram while testing. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.5 llvm-www/releases/testregister.cgi:1.6 --- llvm-www/releases/testregister.cgi:1.5 Thu Dec 18 11:24:49 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 11:25:18 2003 @@ -8,7 +8,7 @@ import Cookie # List of email addresses that want to know when people download -notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] +notifylist=['criswell at uiuc.edu] # Full pathname of the logfile logfilename='/var/tmp/LLVMDownloads' From criswell at cs.uiuc.edu Thu Dec 18 11:27:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:27:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181726.LAA22877@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.6 -> 1.7 --- Log message: Fixed syntax error. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.6 llvm-www/releases/testregister.cgi:1.7 --- llvm-www/releases/testregister.cgi:1.6 Thu Dec 18 11:25:18 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 11:26:37 2003 @@ -8,7 +8,7 @@ import Cookie # List of email addresses that want to know when people download -notifylist=['criswell at uiuc.edu] +notifylist=['criswell at uiuc.edu'] # Full pathname of the logfile logfilename='/var/tmp/LLVMDownloads' From criswell at cs.uiuc.edu Thu Dec 18 11:32:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:32:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181731.LAA23015@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.7 -> 1.8 --- Log message: Fixed errors. --- Diffs of the changes: (+3 -3) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.7 llvm-www/releases/testregister.cgi:1.8 --- llvm-www/releases/testregister.cgi:1.7 Thu Dec 18 11:26:37 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 11:31:42 2003 @@ -4,8 +4,8 @@ import urllib import smtplib import os +import fcntl import sys -import Cookie # List of email addresses that want to know when people download notifylist=['criswell at uiuc.edu'] @@ -151,8 +151,8 @@ # # Open the logfile, lock it, and write a new entry. # - logfile = file (logfilename, 'ra') - os.lockf (logfile, os.LOCK_EX) + logfile = file (logfilename, 'a') + fcntl.lockf (logfile, fcntl.LOCK_EX) logfile.write (email + ':' + lastname + ':' + firstname + '\n') logfile.flush () logfile.close () From criswell at cs.uiuc.edu Thu Dec 18 11:36:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:36:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312181735.LAA23148@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.7 -> 1.8 --- Log message: Added logging support. --- Diffs of the changes: (+13 -0) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.7 llvm-www/releases/register.cgi:1.8 --- llvm-www/releases/register.cgi:1.7 Tue Dec 16 15:06:04 2003 +++ llvm-www/releases/register.cgi Thu Dec 18 11:35:09 2003 @@ -10,6 +10,9 @@ # List of email addresses that want to know when people download notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] +# Full pathname of the logfile +logfilename='/var/tmp/LLVMDownloads' + # # Function: Subscribe() # @@ -144,6 +147,16 @@ except: pass mailer.quit () + + # + # Open the logfile, lock it, and write a new entry. + # + logfile = file (logfilename, 'a') + fcntl.lockf (logfile, fcntl.LOCK_EX) + logfile.write (email + ':' + lastname + ':' + firstname + '\n') + logfile.flush () + logfile.close () + return # From criswell at cs.uiuc.edu Thu Dec 18 11:39:03 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:39:03 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312181738.LAA23270@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.8 -> 1.9 --- Log message: Fix script for person trying to download as I speak. --- Diffs of the changes: (+5 -5) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.8 llvm-www/releases/register.cgi:1.9 --- llvm-www/releases/register.cgi:1.8 Thu Dec 18 11:35:09 2003 +++ llvm-www/releases/register.cgi Thu Dec 18 11:38:05 2003 @@ -151,11 +151,11 @@ # # Open the logfile, lock it, and write a new entry. # - logfile = file (logfilename, 'a') - fcntl.lockf (logfile, fcntl.LOCK_EX) - logfile.write (email + ':' + lastname + ':' + firstname + '\n') - logfile.flush () - logfile.close () + #logfile = file (logfilename, 'a') + #fcntl.lockf (logfile, fcntl.LOCK_EX) + #logfile.write (email + ':' + lastname + ':' + firstname + '\n') + #logfile.flush () + #logfile.close () return From criswell at cs.uiuc.edu Thu Dec 18 11:50:03 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 11:50:03 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181749.LAA23406@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.8 -> 1.9 --- Log message: Add code to unlock the file when done. Added code that helps to ensure that we return successfully even if writing to the logfile fails. --- Diffs of the changes: (+11 -8) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.8 llvm-www/releases/testregister.cgi:1.9 --- llvm-www/releases/testregister.cgi:1.8 Thu Dec 18 11:31:42 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 11:48:56 2003 @@ -151,11 +151,15 @@ # # Open the logfile, lock it, and write a new entry. # - logfile = file (logfilename, 'a') - fcntl.lockf (logfile, fcntl.LOCK_EX) - logfile.write (email + ':' + lastname + ':' + firstname + '\n') - logfile.flush () - logfile.close () + try: + logfile = file (logfilename, 'a') + fcntl.lockf (logfile, fcntl.LOCK_EX) + logfile.write (email + ':' + lastname + ':' + firstname + '\n') + logfile.flush () + fcntl.lockf (logfile, fcntl.LOCK_UN) + logfile.close () + except: + pass return @@ -167,8 +171,7 @@ # # Verify that everything in the form is correct. # -#error = ValidateForm (form) -error = '' +error = ValidateForm (form) if (error != ''): print ('Content-type: text/html') print ('Status: 400 Bad Request') @@ -186,7 +189,7 @@ # # Subscribe the user the LLVM Announcements list (if they so desire) # -#Subscribe (form) +Subscribe (form) # From criswell at cs.uiuc.edu Thu Dec 18 12:02:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 12:02:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181801.MAA23542@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.9 -> 1.10 --- Log message: Added extra fields to logfile. --- Diffs of the changes: (+2 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.9 llvm-www/releases/testregister.cgi:1.10 --- llvm-www/releases/testregister.cgi:1.9 Thu Dec 18 11:48:56 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 12:00:52 2003 @@ -8,6 +8,7 @@ import sys # List of email addresses that want to know when people download +#notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] notifylist=['criswell at uiuc.edu'] # Full pathname of the logfile @@ -154,7 +155,7 @@ try: logfile = file (logfilename, 'a') fcntl.lockf (logfile, fcntl.LOCK_EX) - logfile.write (email + ':' + lastname + ':' + firstname + '\n') + logfile.write (email + ':' + firstname + ':' + lastname + ':' + organization + ':' + title + '\n') logfile.flush () fcntl.lockf (logfile, fcntl.LOCK_UN) logfile.close () From criswell at cs.uiuc.edu Thu Dec 18 13:09:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:09:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181908.NAA23751@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.10 -> 1.11 --- Log message: Check fields for colons. --- Diffs of the changes: (+37 -4) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.10 llvm-www/releases/testregister.cgi:1.11 --- llvm-www/releases/testregister.cgi:1.10 Thu Dec 18 12:00:52 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:08:28 2003 @@ -15,6 +15,20 @@ logfilename='/var/tmp/LLVMDownloads' # +# Function: checkForColon() +# +# Description: +# This function checks a string to see if it contains a colon. +# +def checkForColon (item): + length = len (item) - 1 + while (length != 0): + if (item[length] == ':'): + return true + length=length - 1 + return false + +# # Function: Subscribe() # # Description: @@ -68,10 +82,11 @@ # # Verify if the required fields have been supplied. # - firstname = form.getfirst ('firstname', '') - lastname = form.getfirst ('lastname', '') - email = form.getfirst ('email', '') - announce = form.getfirst ('announce','yes') + firstname = form.getfirst ('firstname', '') + lastname = form.getfirst ('lastname', '') + email = form.getfirst ('email', '') + title = form.getfirst ('title','') + organization = form.getfirst ('organization', '') # # Verify that the name and email fields have been filled in. @@ -103,6 +118,24 @@ length=length - 1 else: return 'Email address has no periods' + + # + # Verify that there are no colons in fields placed in the logfile. + # + if (checkForColon (email)): + return 'Email address has a colon' + + if (checkForColon (firstname)): + return 'First name has a colon' + + if (checkForColon (lastname)): + return 'Last name has a colon' + + if (checkForColon (organization)): + return 'Organization has a colon' + + if (checkForColon (title)): + return 'Title has a colon' return '' From criswell at cs.uiuc.edu Thu Dec 18 13:12:08 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:12:08 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181912.NAA23872@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.11 -> 1.12 --- Log message: Fixed the check for colons for zero length strings. --- Diffs of the changes: (+2 -0) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.11 llvm-www/releases/testregister.cgi:1.12 --- llvm-www/releases/testregister.cgi:1.11 Thu Dec 18 13:08:28 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:11:55 2003 @@ -21,6 +21,8 @@ # This function checks a string to see if it contains a colon. # def checkForColon (item): + if (len (item) == 0): + return false length = len (item) - 1 while (length != 0): if (item[length] == ':'): From criswell at cs.uiuc.edu Thu Dec 18 13:14:03 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:14:03 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181913.NAA23986@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.12 -> 1.13 --- Log message: Modified truth/false values. --- Diffs of the changes: (+3 -3) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.12 llvm-www/releases/testregister.cgi:1.13 --- llvm-www/releases/testregister.cgi:1.12 Thu Dec 18 13:11:55 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:13:14 2003 @@ -22,13 +22,13 @@ # def checkForColon (item): if (len (item) == 0): - return false + return False length = len (item) - 1 while (length != 0): if (item[length] == ':'): - return true + return True length=length - 1 - return false + return False # # Function: Subscribe() From criswell at cs.uiuc.edu Thu Dec 18 13:16:00 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:16:00 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181915.NAA24104@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.13 -> 1.14 --- Log message: Removing code segments for debugging. --- Diffs of the changes: (+2 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.13 llvm-www/releases/testregister.cgi:1.14 --- llvm-www/releases/testregister.cgi:1.13 Thu Dec 18 13:13:14 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:14:58 2003 @@ -21,7 +21,7 @@ # This function checks a string to see if it contains a colon. # def checkForColon (item): - if (len (item) == 0): + if ((len (item)) == 0): return False length = len (item) - 1 while (length != 0): @@ -121,6 +121,7 @@ else: return 'Email address has no periods' + return '' # # Verify that there are no colons in fields placed in the logfile. # From criswell at cs.uiuc.edu Thu Dec 18 13:19:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:19:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181918.NAA24226@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.14 -> 1.15 --- Log message: Modified boolean values again. --- Diffs of the changes: (+3 -3) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.14 llvm-www/releases/testregister.cgi:1.15 --- llvm-www/releases/testregister.cgi:1.14 Thu Dec 18 13:14:58 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:18:24 2003 @@ -22,13 +22,13 @@ # def checkForColon (item): if ((len (item)) == 0): - return False + return 0 length = len (item) - 1 while (length != 0): if (item[length] == ':'): - return True + return 1 length=length - 1 - return False + return 0 # # Function: Subscribe() From criswell at cs.uiuc.edu Thu Dec 18 13:21:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:21:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181920.NAA24343@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.15 -> 1.16 --- Log message: Added new CGI headers so that I can see the output. --- Diffs of the changes: (+3 -0) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.15 llvm-www/releases/testregister.cgi:1.16 --- llvm-www/releases/testregister.cgi:1.15 Thu Dec 18 13:18:24 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:20:05 2003 @@ -200,6 +200,9 @@ return +print ('Content-type: text/plain\n\n') +print ('') + # # Parse the CGI input # From criswell at cs.uiuc.edu Thu Dec 18 13:22:06 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:22:06 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181921.NAA24457@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.16 -> 1.17 --- Log message: Fixed indentation problem. --- Diffs of the changes: (+2 -2) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.16 llvm-www/releases/testregister.cgi:1.17 --- llvm-www/releases/testregister.cgi:1.16 Thu Dec 18 13:20:05 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:21:13 2003 @@ -21,8 +21,8 @@ # This function checks a string to see if it contains a colon. # def checkForColon (item): - if ((len (item)) == 0): - return 0 + if ((len (item)) == 0): + return 0 length = len (item) - 1 while (length != 0): if (item[length] == ':'): From criswell at cs.uiuc.edu Thu Dec 18 13:24:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:24:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181923.NAA24576@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.17 -> 1.18 --- Log message: Fixed more indentation issues. --- Diffs of the changes: (+0 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.17 llvm-www/releases/testregister.cgi:1.18 --- llvm-www/releases/testregister.cgi:1.17 Thu Dec 18 13:21:13 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:23:08 2003 @@ -121,7 +121,6 @@ else: return 'Email address has no periods' - return '' # # Verify that there are no colons in fields placed in the logfile. # From criswell at cs.uiuc.edu Thu Dec 18 13:48:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:48:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312181947.NAA24712@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.18 -> 1.19 --- Log message: Get the program to check for a colon in the first character of the string. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.18 llvm-www/releases/testregister.cgi:1.19 --- llvm-www/releases/testregister.cgi:1.18 Thu Dec 18 13:23:08 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 13:46:59 2003 @@ -24,7 +24,7 @@ if ((len (item)) == 0): return 0 length = len (item) - 1 - while (length != 0): + while (length != -1): if (item[length] == ':'): return 1 length=length - 1 From criswell at cs.uiuc.edu Thu Dec 18 13:50:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:50:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312181949.NAA24742@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.9 -> 1.10 --- Log message: Second attempt at adding logging and required validity checking of form fields for logging. --- Diffs of the changes: (+54 -17) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.9 llvm-www/releases/register.cgi:1.10 --- llvm-www/releases/register.cgi:1.9 Thu Dec 18 11:38:05 2003 +++ llvm-www/releases/register.cgi Thu Dec 18 13:49:34 2003 @@ -4,16 +4,33 @@ import urllib import smtplib import os +import fcntl import sys -import Cookie # List of email addresses that want to know when people download -notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] +#notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] +notifylist=['criswell at uiuc.edu'] # Full pathname of the logfile logfilename='/var/tmp/LLVMDownloads' # +# Function: checkForColon() +# +# Description: +# This function checks a string to see if it contains a colon. +# +def checkForColon (item): + if ((len (item)) == 0): + return 0 + length = len (item) - 1 + while (length != -1): + if (item[length] == ':'): + return 1 + length=length - 1 + return 0 + +# # Function: Subscribe() # # Description: @@ -67,10 +84,11 @@ # # Verify if the required fields have been supplied. # - firstname = form.getfirst ('firstname', '') - lastname = form.getfirst ('lastname', '') - email = form.getfirst ('email', '') - announce = form.getfirst ('announce','yes') + firstname = form.getfirst ('firstname', '') + lastname = form.getfirst ('lastname', '') + email = form.getfirst ('email', '') + title = form.getfirst ('title','') + organization = form.getfirst ('organization', '') # # Verify that the name and email fields have been filled in. @@ -103,6 +121,24 @@ else: return 'Email address has no periods' + # + # Verify that there are no colons in fields placed in the logfile. + # + if (checkForColon (email)): + return 'Email address has a colon' + + if (checkForColon (firstname)): + return 'First name has a colon' + + if (checkForColon (lastname)): + return 'Last name has a colon' + + if (checkForColon (organization)): + return 'Organization has a colon' + + if (checkForColon (title)): + return 'Title has a colon' + return '' # @@ -151,14 +187,21 @@ # # Open the logfile, lock it, and write a new entry. # - #logfile = file (logfilename, 'a') - #fcntl.lockf (logfile, fcntl.LOCK_EX) - #logfile.write (email + ':' + lastname + ':' + firstname + '\n') - #logfile.flush () - #logfile.close () + try: + logfile = file (logfilename, 'a') + fcntl.lockf (logfile, fcntl.LOCK_EX) + logfile.write (email + ':' + firstname + ':' + lastname + ':' + organization + ':' + title + '\n') + logfile.flush () + fcntl.lockf (logfile, fcntl.LOCK_UN) + logfile.close () + except: + pass return +#print ('Content-type: text/plain\n\n') +#print ('') + # # Parse the CGI input # @@ -187,12 +230,6 @@ # Subscribe (form) -# -# Create a cookie so that the user does not need to register again. -# -#usercookie = Cookie.SimpleCookie() -#usercookie['LLVM Download'] = 'Yes' -#usercookie.output() # # Send the user to the download page. From criswell at cs.uiuc.edu Thu Dec 18 13:52:03 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 13:52:03 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312181951.NAA24860@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.10 -> 1.11 --- Log message: Put Vikram and Chris back into the loop. --- Diffs of the changes: (+1 -2) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.10 llvm-www/releases/register.cgi:1.11 --- llvm-www/releases/register.cgi:1.10 Thu Dec 18 13:49:34 2003 +++ llvm-www/releases/register.cgi Thu Dec 18 13:50:55 2003 @@ -8,8 +8,7 @@ import sys # List of email addresses that want to know when people download -#notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] -notifylist=['criswell at uiuc.edu'] +notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] # Full pathname of the logfile logfilename='/var/tmp/LLVMDownloads' From lattner at cs.uiuc.edu Thu Dec 18 14:26:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 14:26:01 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/RegAllocLinearScan.cpp Message-ID: <200312182025.OAA04377@zion.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: RegAllocLinearScan.cpp updated: 1.13 -> 1.14 --- Log message: Prune some #includes Add a statistic for # reloads --- Diffs of the changes: (+2 -3) Index: llvm/lib/CodeGen/RegAllocLinearScan.cpp diff -u llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.13 llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.14 --- llvm/lib/CodeGen/RegAllocLinearScan.cpp:1.13 Thu Dec 18 07:15:02 2003 +++ llvm/lib/CodeGen/RegAllocLinearScan.cpp Thu Dec 18 14:25:31 2003 @@ -22,18 +22,16 @@ #include "llvm/Target/MRegisterInfo.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" -#include "llvm/Target/TargetRegInfo.h" #include "llvm/Support/CFG.h" #include "Support/Debug.h" #include "Support/DepthFirstIterator.h" #include "Support/Statistic.h" #include "Support/STLExtras.h" -#include - using namespace llvm; namespace { Statistic<> numSpilled ("ra-linearscan", "Number of registers spilled"); + Statistic<> numReloaded("ra-linearscan", "Number of registers reloaded"); class RA : public MachineFunctionPass { public: @@ -762,6 +760,7 @@ const TargetRegisterClass* rc = mf_->getSSARegMap()->getRegClass(virtReg); int frameIndex = getStackSlot(virtReg); DEBUG(std::cerr << " from stack slot #" << frameIndex << '\n'); + ++numReloaded; instrAdded_ += mri_->loadRegFromStackSlot(*currentMbb_, currentInstr_, physReg, frameIndex, rc); assignVirt2PhysReg(virtReg, physReg); From gaeke at cs.uiuc.edu Thu Dec 18 14:58:01 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Thu Dec 18 14:58:01 2003 Subject: [llvm-commits] CVS: llvm/Makefile.rules Message-ID: <200312182057.OAA16084@gally.cs.uiuc.edu> Changes in directory llvm: Makefile.rules updated: 1.165 -> 1.166 --- Log message: Add install target for libraries. --- Diffs of the changes: (+24 -6) Index: llvm/Makefile.rules diff -u llvm/Makefile.rules:1.165 llvm/Makefile.rules:1.166 --- llvm/Makefile.rules:1.165 Tue Dec 9 18:26:28 2003 +++ llvm/Makefile.rules Thu Dec 18 14:57:48 2003 @@ -71,12 +71,13 @@ ifdef SHARED_LIBRARY # if SHARED_LIBRARY is specified, the default is to build the dynamic lib all:: dynamic +install:: install-dynamic endif ifdef BYTECODE_LIBRARY # if BYTECODE_LIBRARY is specified, the default is to build the bytecode lib all:: bytecodelib -install:: bytecodelib-install +install:: install-bytecode-library endif # Default Rule: Make sure it's also a :: rule @@ -116,7 +117,7 @@ # slightly since GNU Make will not try to find implicit rules for targets # which are marked as Phony. # -.PHONY: all dynamic bytecodelib bytecodelib-install +.PHONY: all dynamic bytecodelib install-bytecode-library .PHONY: clean distclean install test bytecode prdirs ########################################################################### @@ -462,23 +463,27 @@ LIBNAME_O := $(DESTLIBRELEASE)/lib$(LIBRARYNAME).so LIBNAME_P := $(DESTLIBPROFILE)/lib$(LIBRARYNAME).so LIBNAME_G := $(DESTLIBDEBUG)/lib$(LIBRARYNAME).so +LIBNAME_CUR := $(DESTLIBCURRENT)/lib$(LIBRARYNAME).so LIBNAME_AO := $(DESTLIBRELEASE)/lib$(LIBRARYNAME).a LIBNAME_AP := $(DESTLIBPROFILE)/lib$(LIBRARYNAME).a LIBNAME_AG := $(DESTLIBDEBUG)/lib$(LIBRARYNAME).a +LIBNAME_ACUR := $(DESTLIBCURRENT)/lib$(LIBRARYNAME).a LIBNAME_OBJO := $(DESTLIBRELEASE)/$(LIBRARYNAME).o LIBNAME_OBJP := $(DESTLIBPROFILE)/$(LIBRARYNAME).o LIBNAME_OBJG := $(DESTLIBDEBUG)/$(LIBRARYNAME).o +LIBNAME_OBJCUR := $(DESTLIBCURRENT)/$(LIBRARYNAME).o LIBNAME_BC := $(DESTLIBBYTECODE)/lib$(LIBRARYNAME).bc + #-------------------------------------------------------------------- # Library Targets # Modify the top level targets to build the desired libraries. #-------------------------------------------------------------------- # dynamic target builds a shared object version of the library... -dynamic:: $(DESTLIBCURRENT)/lib$(LIBRARYNAME).so +dynamic:: $(LIBNAME_CUR) bytecodelib:: $(LIBNAME_BC) -bytecodelib-install:: $(LLVMGCCDIR)/bytecode-libs/lib$(LIBRARYNAME).bc +install-bytecode-library:: $(LLVMGCCDIR)/bytecode-libs/lib$(LIBRARYNAME).bc $(LLVMGCCDIR)/bytecode-libs/lib$(LIBRARYNAME).bc: $(LIBNAME_BC) @${ECHO} ======= Installing $(LIBRARYNAME) bytecode library ======= @@ -486,12 +491,14 @@ # Does the library want a .o version built? ifndef DONT_BUILD_RELINKED -all:: $(DESTLIBCURRENT)/$(LIBRARYNAME).o +all:: $(LIBNAME_OBJCUR) +install:: install-single-object-library endif # Does the library want an archive version built? ifdef BUILD_ARCHIVE -all:: $(DESTLIBCURRENT)/lib$(LIBRARYNAME).a +all:: $(LIBNAME_ACUR) +install:: install-archive-library endif #-------------------------------------------------------------------- @@ -536,6 +543,10 @@ $(VERB) $(LIBTOOL) --mode=install $(INSTALL) $*.la $(DESTLIBCURRENT) @${ECHO} ======= Finished building $(LIBRARYNAME) dynamic debug library ======= +install-dynamic-library: $(LIBNAME_CUR) + $(MKDIR) $(libdir) + $(VERB) $(LIBTOOL) --mode=install $(INSTALL) $(LIBNAME_CUR) $(libdir)/lib$(LIBRARYNAME).so + # # Rules for building static archive libraries. # @@ -557,6 +568,9 @@ $(VERB) $(Link) -g $(STRIP) -o $@ $(ObjectsG) $(LibSubDirs) -static @${ECHO} ======= Finished building $(LIBRARYNAME) archive debug library ======= +install-archive-library: $(LIBNAME_ACUR) + $(MKDIR) $(libdir) + $(VERB) $(LIBTOOL) --mode=install $(INSTALL) $(LIBNAME_ACUR) $(libdir)/lib$(LIBRARYNAME).a # # Rules for building .o libraries. @@ -583,6 +597,10 @@ $(LIBNAME_OBJG): $(ObjectsG) $(LibSubDirs) $(DESTLIBDEBUG)/.dir @${ECHO} "Linking `basename $@`" $(VERB) $(Relink) -o $@ $(RObjectsG) $(LibSubDirs) + +install-single-object-library: $(LIBNAME_OBJCUR) + $(MKDIR) $(libdir) + $(VERB) $(LIBTOOL) --mode=install $(INSTALL) $(LIBNAME_OBJCUR) $(libdir)/$(LIBRARYNAME).o endif From criswell at cs.uiuc.edu Thu Dec 18 14:59:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 14:59:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312182058.OAA25270@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.19 -> 1.20 --- Log message: Try using pickling. --- Diffs of the changes: (+5 -4) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.19 llvm-www/releases/testregister.cgi:1.20 --- llvm-www/releases/testregister.cgi:1.19 Thu Dec 18 13:46:59 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 14:58:08 2003 @@ -6,13 +6,14 @@ import os import fcntl import sys +import pickle # List of email addresses that want to know when people download #notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] notifylist=['criswell at uiuc.edu'] # Full pathname of the logfile -logfilename='/var/tmp/LLVMDownloads' +logfilename='/var/tmp/testLLVMDownloads' # # Function: checkForColon() @@ -190,7 +191,7 @@ try: logfile = file (logfilename, 'a') fcntl.lockf (logfile, fcntl.LOCK_EX) - logfile.write (email + ':' + firstname + ':' + lastname + ':' + organization + ':' + title + '\n') + pickle.dump ((email, firstname, lastname, organization, title), logfile) logfile.flush () fcntl.lockf (logfile, fcntl.LOCK_UN) logfile.close () @@ -199,8 +200,8 @@ return -print ('Content-type: text/plain\n\n') -print ('') +#print ('Content-type: text/plain\n\n') +#print ('') # # Parse the CGI input From criswell at cs.uiuc.edu Thu Dec 18 15:02:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:02:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312182101.PAA25396@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.11 -> 1.12 --- Log message: Use Python's pickling abilities to save all of the registration information. --- Diffs of the changes: (+2 -1) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.11 llvm-www/releases/register.cgi:1.12 --- llvm-www/releases/register.cgi:1.11 Thu Dec 18 13:50:55 2003 +++ llvm-www/releases/register.cgi Thu Dec 18 15:01:03 2003 @@ -6,6 +6,7 @@ import os import fcntl import sys +import pickle # List of email addresses that want to know when people download notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] @@ -189,7 +190,7 @@ try: logfile = file (logfilename, 'a') fcntl.lockf (logfile, fcntl.LOCK_EX) - logfile.write (email + ':' + firstname + ':' + lastname + ':' + organization + ':' + title + '\n') + pickle.dump ((email, firstname, lastname, organization, title, plans), logfile) logfile.flush () fcntl.lockf (logfile, fcntl.LOCK_UN) logfile.close () From criswell at cs.uiuc.edu Thu Dec 18 15:19:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:19:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312182118.PAA25533@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.20 -> 1.21 --- Log message: Attempt at implementing skipping the registration process. --- Diffs of the changes: (+59 -7) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.20 llvm-www/releases/testregister.cgi:1.21 --- llvm-www/releases/testregister.cgi:1.20 Thu Dec 18 14:58:08 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 15:18:19 2003 @@ -76,6 +76,42 @@ return # +# Function: checkEmail() +# +# Description: +# This function searches through the database to see if the email address +# has already been registered. +#pickle.dump ((email, firstname, lastname, organization, title), logfile) +# +def checkEmail (email): + + # + # Assume we haven't found a matching entry. + # + foundentry = ('','','','','') + try: + # + # Open the logfile read only. + # + logfile = file (logfilename, 'r') + + found = 0 + while (found == 0): + entry = pickle.load (logfile) + if (entry[0] == email): + entry = foundentry + break + except: + pass + + try: + logfile.close () + except: + pass + + return foundentry + +# # Function: ValidateForm () # # Description: @@ -92,14 +128,8 @@ organization = form.getfirst ('organization', '') # - # Verify that the name and email fields have been filled in. + # Verify the email address first. # - if (firstname == ''): - return 'First name is empty.' - - if (lastname == ''): - return 'Last name is empty.' - if (email == ''): return 'Email address is empty.' @@ -123,6 +153,23 @@ return 'Email address has no periods' # + # Determine if the email address has been used in a previous + # registration. + # + entry = checkEmail (email) + if (entry[0] == email): + return 'registered' + + # + # Verify that the name fields have been filled in. + # + if (firstname == ''): + return 'First name is empty.' + + if (lastname == ''): + return 'Last name is empty.' + + # # Verify that there are no colons in fields placed in the logfile. # if (checkForColon (email)): @@ -212,6 +259,11 @@ # Verify that everything in the form is correct. # error = ValidateForm (form) +if (error == 'registered'): + print ('Location: /releases/download.html') + print ('') + sys.exit (0) + if (error != ''): print ('Content-type: text/html') print ('Status: 400 Bad Request') From criswell at cs.uiuc.edu Thu Dec 18 15:26:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:26:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/testregister.cgi Message-ID: <200312182125.PAA25656@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: testregister.cgi updated: 1.21 -> 1.22 --- Log message: The lvalue goes on the left side of the equals sign. :) --- Diffs of the changes: (+2 -2) Index: llvm-www/releases/testregister.cgi diff -u llvm-www/releases/testregister.cgi:1.21 llvm-www/releases/testregister.cgi:1.22 --- llvm-www/releases/testregister.cgi:1.21 Thu Dec 18 15:18:19 2003 +++ llvm-www/releases/testregister.cgi Thu Dec 18 15:25:29 2003 @@ -99,7 +99,7 @@ while (found == 0): entry = pickle.load (logfile) if (entry[0] == email): - entry = foundentry + foundentry = entry break except: pass @@ -157,7 +157,7 @@ # registration. # entry = checkEmail (email) - if (entry[0] == email): + if (entry[0] != ''): return 'registered' # From criswell at cs.uiuc.edu Thu Dec 18 15:28:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:28:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.cgi Message-ID: <200312182127.PAA25780@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.cgi updated: 1.12 -> 1.13 --- Log message: Attempt to accept only the email address if the user has already registered. --- Diffs of the changes: (+60 -8) Index: llvm-www/releases/register.cgi diff -u llvm-www/releases/register.cgi:1.12 llvm-www/releases/register.cgi:1.13 --- llvm-www/releases/register.cgi:1.12 Thu Dec 18 15:01:03 2003 +++ llvm-www/releases/register.cgi Thu Dec 18 15:26:59 2003 @@ -75,6 +75,42 @@ return # +# Function: checkEmail() +# +# Description: +# This function searches through the database to see if the email address +# has already been registered. +#pickle.dump ((email, firstname, lastname, organization, title), logfile) +# +def checkEmail (email): + + # + # Assume we haven't found a matching entry. + # + foundentry = ('','','','','') + try: + # + # Open the logfile read only. + # + logfile = file (logfilename, 'r') + + found = 0 + while (found == 0): + entry = pickle.load (logfile) + if (entry[0] == email): + foundentry = entry + break + except: + pass + + try: + logfile.close () + except: + pass + + return foundentry + +# # Function: ValidateForm () # # Description: @@ -91,14 +127,8 @@ organization = form.getfirst ('organization', '') # - # Verify that the name and email fields have been filled in. + # Verify the email address first. # - if (firstname == ''): - return 'First name is empty.' - - if (lastname == ''): - return 'Last name is empty.' - if (email == ''): return 'Email address is empty.' @@ -122,6 +152,23 @@ return 'Email address has no periods' # + # Determine if the email address has been used in a previous + # registration. + # + entry = checkEmail (email) + if (entry[0] != ''): + return 'registered' + + # + # Verify that the name fields have been filled in. + # + if (firstname == ''): + return 'First name is empty.' + + if (lastname == ''): + return 'Last name is empty.' + + # # Verify that there are no colons in fields placed in the logfile. # if (checkForColon (email)): @@ -190,7 +237,7 @@ try: logfile = file (logfilename, 'a') fcntl.lockf (logfile, fcntl.LOCK_EX) - pickle.dump ((email, firstname, lastname, organization, title, plans), logfile) + pickle.dump ((email, firstname, lastname, organization, title), logfile) logfile.flush () fcntl.lockf (logfile, fcntl.LOCK_UN) logfile.close () @@ -211,6 +258,11 @@ # Verify that everything in the form is correct. # error = ValidateForm (form) +if (error == 'registered'): + print ('Location: /releases/download.html') + print ('') + sys.exit (0) + if (error != ''): print ('Content-type: text/html') print ('Status: 400 Bad Request') From criswell at cs.uiuc.edu Thu Dec 18 15:40:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:40:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.html Message-ID: <200312182139.PAA25910@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.html updated: 1.1 -> 1.2 --- Log message: Added a "Quick Download" link. --- Diffs of the changes: (+20 -1) Index: llvm-www/releases/register.html diff -u llvm-www/releases/register.html:1.1 llvm-www/releases/register.html:1.2 --- llvm-www/releases/register.html:1.1 Fri Dec 12 16:09:41 2003 +++ llvm-www/releases/register.html Thu Dec 18 15:39:15 2003 @@ -16,7 +16,26 @@

            We'd like to collect some information about people and organizations who are interested in LLVM. Please complete the following form below to download a copy -of the LLVM software. +of the LLVM software, or use the Quick Download if you have registered since +December 19, 2003. + + +
            Definition Of Operation Of Built In Words
            LOGICAL OPERATIONS
            WordNameOperationDescription
            <LTw1 w2 -- bTwo values (w1 and w2) are popped off the stack and compared. If w1 is less than w2, TRUE is pushed back on the stack, otherwise FALSE is pushed back on the stack.
            >GTw1 w2 -- bTwo values (w1 and w2) are popped off the stack and +
            >GTw1 w2 -- bTwo values (w1 and w2) are popped off the stack and compared. If w1 is greater than w2, TRUE is pushed back on the stack, otherwise FALSE is pushed back on the stack.
            >=GEw1 w2 -- bTwo values (w1 and w2) are popped off the stack and +
            >=GEw1 w2 -- bTwo values (w1 and w2) are popped off the stack and compared. If w1 is greater than or equal to w2, TRUE is pushed back on the stack, otherwise FALSE is pushed back on the stack.
            <=LEw1 w2 -- bTwo values (w1 and w2) are popped off the stack and +
            <=LEw1 w2 -- bTwo values (w1 and w2) are popped off the stack and compared. If w1 is less than or equal to w2, TRUE is pushed back on the stack, otherwise FALSE is pushed back on the stack.
            =EQw1 w2 -- bTwo values (w1 and w2) are popped off the stack and +
            =EQw1 w2 -- bTwo values (w1 and w2) are popped off the stack and compared. If w1 is equal to w2, TRUE is pushed back on the stack, otherwise FALSE is pushed back
            <>NEw1 w2 -- bTwo values (w1 and w2) are popped off the stack and +
            <>NEw1 w2 -- bTwo values (w1 and w2) are popped off the stack and compared. If w1 is equal to w2, TRUE is pushed back on the stack, otherwise FALSE is pushed back
            FALSEFALSE -- bThe boolean value FALSE (0) is pushed onto the stack.
            TRUETRUE -- bThe boolean value TRUE (-1) is pushed onto the stack.
            BITWISE OPERATIONS
            WordNameOperationDescription
            <<SHLw1 w2 -- w1<<w2Two values (w1 and w2) are popped off the stack. The w2 +
            FALSEFALSE -- bThe boolean value FALSE (0) is pushed onto the stack.
            TRUETRUE -- bThe boolean value TRUE (-1) is pushed onto the stack.
            BITWISE OPERATORS
            WordNameOperationDescription
            <<SHLw1 w2 -- w1<<w2Two values (w1 and w2) are popped off the stack. The w2 operand is shifted left by the number of bits given by the w1 operand. The result is pushed back to the stack.
            >>SHRw1 w2 -- w1>>w2Two values (w1 and w2) are popped off the stack. The w2 +
            >>SHRw1 w2 -- w1>>w2Two values (w1 and w2) are popped off the stack. The w2 operand is shifted right by the number of bits given by the w1 operand. The result is pushed back to the stack.
            ORORw1 w2 -- w2|w1Two values (w1 and w2) are popped off the stack. The values +
            ORORw1 w2 -- w2|w1Two values (w1 and w2) are popped off the stack. The values are bitwise OR'd together and pushed back on the stack. This is not a logical OR. The sequence 1 2 OR yields 3 not 1.
            ANDANDw1 w2 -- w2&w1Two values (w1 and w2) are popped off the stack. The values +
            ANDANDw1 w2 -- w2&w1Two values (w1 and w2) are popped off the stack. The values are bitwise AND'd together and pushed back on the stack. This is not a logical AND. The sequence 1 2 AND yields 0 not 1.
            XORXORw1 w2 -- w2^w1Two values (w1 and w2) are popped off the stack. The values +
            XORXORw1 w2 -- w2^w1Two values (w1 and w2) are popped off the stack. The values are bitwise exclusive OR'd together and pushed back on the stack. For example, The sequence 1 3 XOR yields 2.
            ARITHMETIC OPERATIONS
            WordNameOperationDescription
            ABSABSw -- |w|One value s popped off the stack; its absolute value is computed +
            ARITHMETIC OPERATORS
            WordNameOperationDescription
            ABSABSw -- |w|One value s popped off the stack; its absolute value is computed and then pushed onto the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is also 1.
            NEGNEGw -- -wOne value is popped off the stack which is negated and then +
            NEGNEGw -- -wOne value is popped off the stack which is negated and then pushed back onto the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is -1.
            + ADDw1 w2 -- w2+w1Two values are popped off the stack. Their sum is pushed back +
            + ADDw1 w2 -- w2+w1Two values are popped off the stack. Their sum is pushed back onto the stack
            - SUBw1 w2 -- w2-w1Two values are popped off the stack. Their difference is pushed back +
            - SUBw1 w2 -- w2-w1Two values are popped off the stack. Their difference is pushed back onto the stack
            * MULw1 w2 -- w2*w1Two values are popped off the stack. Their product is pushed back +
            * MULw1 w2 -- w2*w1Two values are popped off the stack. Their product is pushed back onto the stack
            / DIVw1 w2 -- w2/w1Two values are popped off the stack. Their quotient is pushed back +
            / DIVw1 w2 -- w2/w1Two values are popped off the stack. Their quotient is pushed back onto the stack
            MODMODw1 w2 -- w2%w1Two values are popped off the stack. Their remainder after division +
            MODMODw1 w2 -- w2%w1Two values are popped off the stack. Their remainder after division of w1 by w2 is pushed back onto the stack
            */ STAR_SLAHw1 w2 w3 -- (w3*w2)/w1Three values are popped off the stack. The product of w1 and w2 is +
            */ STAR_SLAHw1 w2 w3 -- (w3*w2)/w1Three values are popped off the stack. The product of w1 and w2 is divided by w3. The result is pushed back onto the stack.
            ++ INCRw -- w+1One value is popped off the stack. It is incremented by one and then +
            ++ INCRw -- w+1One value is popped off the stack. It is incremented by one and then pushed back onto the stack.
            -- DECRw -- w-1One value is popped off the stack. It is decremented by one and then +
            -- DECRw -- w-1One value is popped off the stack. It is decremented by one and then pushed back onto the stack.
            MINMINw1 w2 -- (w2<w1?w2:w1)Two values are popped off the stack. The larger one is pushed back +
            MINMINw1 w2 -- (w2<w1?w2:w1)Two values are popped off the stack. The larger one is pushed back onto the stack.
            MAXMAXw1 w2 -- (w2>w1?w2:w1)Two values are popped off the stack. The larger value is pushed back +
            MAXMAXw1 w2 -- (w2>w1?w2:w1)Two values are popped off the stack. The larger value is pushed back onto the stack.
            STACK MANIPULATION OPERATIONS
            WordNameOperationDescription
            DROPDROPw -- One value is popped off the stack.
            DROP2DROP2w1 w2 -- Two values are popped off the stack.
            NIPNIPw1 w2 -- w2The second value on the stack is removed from the stack. That is, +
            STACK MANIPULATION OPERATORS
            WordNameOperationDescription
            DROPDROPw -- One value is popped off the stack.
            DROP2DROP2w1 w2 -- Two values are popped off the stack.
            NIPNIPw1 w2 -- w2The second value on the stack is removed from the stack. That is, a value is popped off the stack and retained. Then a second value is popped and the retained value is pushed.
            NIP2NIP2w1 w2 w3 w4 -- w3 w4The third and fourth values on the stack are removed from it. That is, +
            NIP2NIP2w1 w2 w3 w4 -- w3 w4The third and fourth values on the stack are removed from it. That is, two values are popped and retained. Then two more values are popped and the two retained values are pushed back on.
            DUPDUPw1 -- w1 w1One value is popped off the stack. That value is then pushed onto +
            DUPDUPw1 -- w1 w1One value is popped off the stack. That value is then pushed onto the stack twice to duplicate the top stack vaue.
            DUP2DUP2w1 w2 -- w1 w2 w1 w2The top two values on the stack are duplicated. That is, two vaues +
            DUP2DUP2w1 w2 -- w1 w2 w1 w2The top two values on the stack are duplicated. That is, two vaues are popped off the stack. They are alternately pushed back on the stack twice each.
            SWAPSWAPw1 w2 -- w2 w1The top two stack items are reversed in their order. That is, two +
            SWAPSWAPw1 w2 -- w2 w1The top two stack items are reversed in their order. That is, two values are popped off the stack and pushed back onto the stack in the opposite order they were popped.
            SWAP2SWAP2w1 w2 w3 w4 -- w3 w4 w2 w1The top four stack items are swapped in pairs. That is, two values +
            SWAP2SWAP2w1 w2 w3 w4 -- w3 w4 w2 w1The top four stack items are swapped in pairs. That is, two values are popped and retained. Then, two more values are popped and retained. The values are pushed back onto the stack in the reverse order but in pairs.

            OVEROVERw1 w2-- w1 w2 w1Two values are popped from the stack. They are pushed back +
            OVEROVERw1 w2-- w1 w2 w1Two values are popped from the stack. They are pushed back onto the stack in the order w1 w2 w1. This seems to cause the top stack element to be duplicated "over" the next value.
            OVER2OVER2w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2The third and fourth values on the stack are replicated onto the +
            OVER2OVER2w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2The third and fourth values on the stack are replicated onto the top of the stack
            ROTROTw1 w2 w3 -- w2 w3 w1The top three values are rotated. That is, three value are popped +
            ROTROTw1 w2 w3 -- w2 w3 w1The top three values are rotated. That is, three value are popped off the stack. They are pushed back onto the stack in the order w1 w3 w2.
            ROT2ROT2w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2Like ROT but the rotation is done using three pairs instead of +
            ROT2ROT2w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2Like ROT but the rotation is done using three pairs instead of three singles.
            RROTRROTw1 w2 w3 -- w2 w3 w1Reverse rotation. Like ROT, but it rotates the other way around. +
            RROTRROTw1 w2 w3 -- w2 w3 w1Reverse rotation. Like ROT, but it rotates the other way around. Essentially, the third element on the stack is moved to the top of the stack.
            RROT2RROT2w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2Double reverse rotation. Like RROT but the rotation is done using +
            RROT2RROT2w1 w2 w3 w4 w5 w6 -- w3 w4 w5 w6 w1 w2Double reverse rotation. Like RROT but the rotation is done using three pairs instead of three singles. The fifth and sixth stack elements are moved to the first and second positions
            TUCKTUCKw1 w2 -- w2 w1 w2Similar to OVER except that the second operand is being +
            TUCKTUCKw1 w2 -- w2 w1 w2Similar to OVER except that the second operand is being replicated. Essentially, the first operand is being "tucked" in between two instances of the second operand. Logically, two values are popped off the stack. They are placed back on the stack in the order w2 w1 w2.
            TUCK2TUCK2w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4Like TUCK but a pair of elements is tucked over two pairs. +
            TUCK2TUCK2w1 w2 w3 w4 -- w3 w4 w1 w2 w3 w4Like TUCK but a pair of elements is tucked over two pairs. That is, the top two elements of the stack are duplicated and inserted into the stack at the fifth and positions.
            PICKPICKx0 ... Xn n -- x0 ... Xn x0The top of the stack is used as an index into the remainder of +
            PICKPICKx0 ... Xn n -- x0 ... Xn x0The top of the stack is used as an index into the remainder of the stack. The element at the nth position replaces the index (top of stack). This is useful for cycling through a set of values. Note that indexing is zero based. So, if n=0 then you get the second item on the stack. If n=1 you get the third, etc. Note also that the index is replaced by the n'th value.
            SELECTSELECTm n X0..Xm Xm+1 .. Xn -- XmThis is like PICK but the list is removed and you need to specify +
            SELECTSELECTm n X0..Xm Xm+1 .. Xn -- XmThis is like PICK but the list is removed and you need to specify both the index and the size of the list. Careful with this one, the wrong value for n can blow away a huge amount of the stack.
            ROLLROLLx0 x1 .. xn n -- x1 .. xn x0Not Implemented. This one has been left as an exercise to +
            ROLLROLLx0 x1 .. xn n -- x1 .. xn x0Not Implemented. This one has been left as an exercise to the student. See Exercise. ROLL requires a value, "n", to be on the top of the stack. This value specifies how far into the stack to "roll". The n'th value is moved (not @@ -814,20 +841,25 @@ how much to rotate. That is, ROLL with n=1 is the same as ROT and ROLL with n=2 is the same as ROT2.
            MEMORY OPERATIONS
            WordNameOperationDescription
            MALLOCMALLOCw1 -- pOne value is popped off the stack. The value is used as the size +
            MEMORY OPERATORS
            WordNameOperationDescription
            MALLOCMALLOCw1 -- pOne value is popped off the stack. The value is used as the size of a memory block to allocate. The size is in bytes, not words. The memory allocation is completed and the address of the memory block is pushed onto the stack.
            FREEFREEp -- One pointer value is popped off the stack. The value should be +
            FREEFREEp -- One pointer value is popped off the stack. The value should be the address of a memory block created by the MALLOC operation. The associated memory block is freed. Nothing is pushed back on the stack. Many bugs can be created by attempting to FREE something @@ -839,20 +871,20 @@ the stack (for the FREE at the end) and that every use of the pointer is preceded by a DUP to retain the copy for FREE.
            GETGETw1 p -- w2 pAn integer index and a pointer to a memory block are popped of +
            GETGETw1 p -- w2 pAn integer index and a pointer to a memory block are popped of the block. The index is used to index one byte from the memory block. That byte value is retained, the pointer is pushed again and the retained value is pushed. Note that the pointer value s essentially retained in its position so this doesn't count as a "use ptr" in the FREE idiom.
            PUTPUTw1 w2 p -- p An integer value is popped of the stack. This is the value to +
            PUTPUTw1 w2 p -- p An integer value is popped of the stack. This is the value to be put into a memory block. Another integer value is popped of the stack. This is the indexed byte in the memory block. A pointer to the memory block is popped off the stack. The @@ -862,28 +894,33 @@ pushed back on the stack so this doesn't count as a "use ptr" in the FREE idiom.
            CONTROL FLOW OPERATIONS
            WordNameOperationDescription
            RETURNRETURN -- The currently executing definition returns immediately to its caller. +
            CONTROL FLOW OPERATORS
            WordNameOperationDescription
            RETURNRETURN -- The currently executing definition returns immediately to its caller. Note that there is an implicit RETURN at the end of each definition, logically located at the semi-colon. The sequence RETURN ; is valid but redundant.
            EXITEXITw1 -- A return value for the program is popped off the stack. The program is +
            EXITEXITw1 -- A return value for the program is popped off the stack. The program is then immediately terminated. This is normally an abnormal exit from the program. For a normal exit (when MAIN finishes), the exit code will always be zero in accordance with UNIX conventions.
            RECURSERECURSE -- The currently executed definition is called again. This operation is +
            RECURSERECURSE -- The currently executed definition is called again. This operation is needed since the definition of a word doesn't exist until the semi colon is reacher. Attempting something like:
            : recurser recurser ;
            will yield and error saying that @@ -891,24 +928,24 @@ to:
            : recurser RECURSE ;
            IF (words...) ENDIFIF (words...) ENDIFb -- A boolean value is popped of the stack. If it is non-zero then the "words..." +
            IF (words...) ENDIFIF (words...) ENDIFb -- A boolean value is popped of the stack. If it is non-zero then the "words..." are executed. Otherwise, execution continues immediately following the ENDIF.
            IF (words...) ELSE (words...) ENDIFIF (words...) ELSE (words...) ENDIFb -- A boolean value is popped of the stack. If it is non-zero then the "words..." +
            IF (words...) ELSE (words...) ENDIFIF (words...) ELSE (words...) ENDIFb -- A boolean value is popped of the stack. If it is non-zero then the "words..." between IF and ELSE are executed. Otherwise the words between ELSE and ENDIF are executed. In either case, after the (words....) have executed, execution continues immediately following the ENDIF.
            WHILE (words...) ENDWHILE (words...) ENDb -- b The boolean value on the top of the stack is examined. If it is non-zero then the +
            WHILE (words...) ENDWHILE (words...) ENDb -- b The boolean value on the top of the stack is examined. If it is non-zero then the "words..." between WHILE and END are executed. Execution then begins again at the WHILE where another boolean is popped off the stack. To prevent this operation from eating up the entire stack, you should push onto the stack (just before the END) a boolean value that indicates @@ -924,60 +961,65 @@ the top of stack is decremented to 0 at which the WHILE test fails and control is transfered to the word after the END.
            INPUT & OUTPUT OPERATIONS
            WordNameOperationDescription
            SPACESPACE -- A space character is put out. There is no stack effect.
            TABTAB -- A tab character is put out. There is no stack effect.
            CRCR -- A carriage return character is put out. There is no stack effect.
            >sOUT_STR -- A string pointer is popped from the stack. It is put out.
            >dOUT_STR -- A value is popped from the stack. It is put out as a decimal integer.
            >cOUT_CHR -- A value is popped from the stack. It is put out as an ASCII character.
            <sIN_STR -- s A string is read from the input via the scanf(3) format string " %as". The +
            INPUT & OUTPUT OPERATORS
            WordNameOperationDescription
            SPACESPACE -- A space character is put out. There is no stack effect.
            TABTAB -- A tab character is put out. There is no stack effect.
            CRCR -- A carriage return character is put out. There is no stack effect.
            >sOUT_STR -- A string pointer is popped from the stack. It is put out.
            >dOUT_STR -- A value is popped from the stack. It is put out as a decimal integer.
            >cOUT_CHR -- A value is popped from the stack. It is put out as an ASCII character.
            <sIN_STR -- s A string is read from the input via the scanf(3) format string " %as". The resulting string is pushed onto the stack.
            <dIN_STR -- w An integer is read from the input via the scanf(3) format string " %d". The +
            <dIN_STR -- w An integer is read from the input via the scanf(3) format string " %d". The resulting value is pushed onto the stack
            <cIN_CHR -- w A single character is read from the input via the scanf(3) format string +
            <cIN_CHR -- w A single character is read from the input via the scanf(3) format string " %c". The value is converted to an integer and pushed onto the stack.
            DUMPDUMP -- The stack contents are dumped to standard output. This is useful for +
            DUMPDUMP -- The stack contents are dumped to standard output. This is useful for debugging your definitions. Put DUMP at the beginning and end of a definition to see instantly the net effect of the definition.
            FALSE FALSE -- bThe boolean value FALSE (0) is pushed onto the stack.The boolean value FALSE (0) is pushed on to the stack.
            TRUE TRUE -- bThe boolean value TRUE (-1) is pushed onto the stack.The boolean value TRUE (-1) is pushed on to the stack.
            BITWISE OPERATORS
            ABS w -- |w| One value s popped off the stack; its absolute value is computed - and then pushed onto the stack. If w1 is -1 then w2 is 1. If w1 is + and then pushed on to the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is also 1.
            NEG NEG w -- -w One value is popped off the stack which is negated and then - pushed back onto the stack. If w1 is -1 then w2 is 1. If w1 is + pushed back on to the stack. If w1 is -1 then w2 is 1. If w1 is 1 then w2 is -1.
            + ADD w1 w2 -- w2+w1 Two values are popped off the stack. Their sum is pushed back - onto the stack
            - SUB w1 w2 -- w2-w1 Two values are popped off the stack. Their difference is pushed back - onto the stack
            * MUL w1 w2 -- w2*w1 Two values are popped off the stack. Their product is pushed back - onto the stack
            / DIV w1 w2 -- w2/w1 Two values are popped off the stack. Their quotient is pushed back - onto the stack
            MOD MOD w1 w2 -- w2%w1 Two values are popped off the stack. Their remainder after division - of w1 by w2 is pushed back onto the stack
            */ STAR_SLAH w1 w2 w3 -- (w3*w2)/w1 Three values are popped off the stack. The product of w1 and w2 is - divided by w3. The result is pushed back onto the stack.
            ++ INCR w -- w+1 One value is popped off the stack. It is incremented by one and then - pushed back onto the stack.
            -- DECR w -- w-1 One value is popped off the stack. It is decremented by one and then - pushed back onto the stack.
            MIN MIN w1 w2 -- (w2<w1?w2:w1) Two values are popped off the stack. The larger one is pushed back - onto the stack.
            MAX MAX w1 w2 -- (w2>w1?w2:w1) Two values are popped off the stack. The larger value is pushed back - onto the stack.
            STACK MANIPULATION OPERATORS
            DUP DUP w1 -- w1 w1One value is popped off the stack. That value is then pushed onto + One value is popped off the stack. That value is then pushed on to the stack twice to duplicate the top stack vaue.
            DUP2SWAP w1 w2 -- w2 w1 The top two stack items are reversed in their order. That is, two - values are popped off the stack and pushed back onto the stack in + values are popped off the stack and pushed back on to the stack in the opposite order they were popped.
            SWAP2w1 w2 w3 w4 -- w3 w4 w2 w1 The top four stack items are swapped in pairs. That is, two values are popped and retained. Then, two more values are popped and retained. - The values are pushed back onto the stack in the reverse order but + The values are pushed back on to the stack in the reverse order but in pairs.

            OVER OVER w1 w2-- w1 w2 w1 Two values are popped from the stack. They are pushed back - onto the stack in the order w1 w2 w1. This seems to cause the + on to the stack in the order w1 w2 w1. This seems to cause the top stack element to be duplicated "over" the next value.
            OVER2 OVER2 w1 w2 w3 w4 -- w1 w2 w3 w4 w1 w2The third and fourth values on the stack are replicated onto the + The third and fourth values on the stack are replicated on to the top of the stack
            ROT ROT w1 w2 w3 -- w2 w3 w1 The top three values are rotated. That is, three value are popped - off the stack. They are pushed back onto the stack in the order + off the stack. They are pushed back on to the stack in the order w1 w3 w2.
            ROT2One value is popped off the stack. The value is used as the size of a memory block to allocate. The size is in bytes, not words. The memory allocation is completed and the address of the memory - block is pushed onto the stack.
            FREE FREEThe boolean value on the top of the stack is examined. If it is non-zero then the "words..." between WHILE and END are executed. Execution then begins again at the WHILE where another boolean is popped off the stack. To prevent this operation from eating up the entire - stack, you should push onto the stack (just before the END) a boolean value that indicates + stack, you should push on to the stack (just before the END) a boolean value that indicates whether to terminate. Note that since booleans and integers can be coerced you can use the following "for loop" idiom:
            (push count) WHILE (words...) -- END
            @@ -1002,19 +1003,19 @@
            IN_STR -- s A string is read from the input via the scanf(3) format string " %as". The - resulting string is pushed onto the stack.
            <d IN_STR -- w An integer is read from the input via the scanf(3) format string " %d". The - resulting value is pushed onto the stack
            <c IN_CHR -- w A single character is read from the input via the scanf(3) format string - " %c". The value is converted to an integer and pushed onto the stack.
            DUMP DUMP
            + +
            Quick Download
            + +
            + +
            + + + + + + + +
            Email Address (required):
            +
            From criswell at cs.uiuc.edu Thu Dec 18 15:42:02 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:42:02 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.html Message-ID: <200312182141.PAA26029@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.html updated: 1.2 -> 1.3 --- Log message: Give the Quick Download section its own form. --- Diffs of the changes: (+2 -0) Index: llvm-www/releases/register.html diff -u llvm-www/releases/register.html:1.2 llvm-www/releases/register.html:1.3 --- llvm-www/releases/register.html:1.2 Thu Dec 18 15:39:15 2003 +++ llvm-www/releases/register.html Thu Dec 18 15:41:18 2003 @@ -36,6 +36,8 @@
            + +
            From criswell at cs.uiuc.edu Thu Dec 18 15:52:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:52:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/quickreg.cgi Message-ID: <200312182151.PAA26178@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: quickreg.cgi added (r1.1) --- Log message: Script used to do quick registration. --- Diffs of the changes: (+130 -0) Index: llvm-www/releases/quickreg.cgi diff -c /dev/null llvm-www/releases/quickreg.cgi:1.1 *** /dev/null Thu Dec 18 15:51:43 2003 --- llvm-www/releases/quickreg.cgi Thu Dec 18 15:51:33 2003 *************** *** 0 **** --- 1,130 ---- + #!/usr/dcs/software/supported/bin/python + + import cgi + import urllib + import smtplib + import os + import fcntl + import sys + import pickle + + # List of email addresses that want to know when people download + notifylist=['vadve at cs.uiuc.edu', 'criswell at uiuc.edu', 'sabre at nondot.org'] + + # Full pathname of the logfile + logfilename='/var/tmp/LLVMDownloads' + + # + # Function: checkEmail() + # + # Description: + # This function searches through the database to see if the email address + # has already been registered. + #pickle.dump ((email, firstname, lastname, organization, title), logfile) + # + def checkEmail (email): + + # + # Assume we haven't found a matching entry. + # + foundentry = ('','','','','') + try: + # + # Open the logfile read only. + # + logfile = file (logfilename, 'r') + + found = 0 + while (found == 0): + entry = pickle.load (logfile) + if (entry[0] == email): + foundentry = entry + break + except: + pass + + try: + logfile.close () + except: + pass + + return foundentry + + # + # Function: ValidateForm () + # + # Description: + # Make sure that the input to the CGI script is valid. + # + def ValidateForm (form): + # + # Verify if the required fields have been supplied. + # + firstname = form.getfirst ('firstname', '') + lastname = form.getfirst ('lastname', '') + email = form.getfirst ('email', '') + title = form.getfirst ('title','') + organization = form.getfirst ('organization', '') + + # + # Verify the email address first. + # + if (email == ''): + return 'Email address is empty.' + + # + # Verify that the email address has an at sign and some periods. + # + length = len (email) - 1 + while (length != 0): + if (email[length] == '@'): + break + length=length - 1 + else: + return 'Email address has no at sign' + + length = len (email) - 1 + while (length != 0): + if (email[length] == '.'): + break + length=length - 1 + else: + return 'Email address has no periods' + + # + # Determine if the email address has been used in a previous + # registration. + # + entry = checkEmail (email) + if (entry[0] != ''): + return 'registered' + return 'unregistered' + + # + # Parse the CGI input + # + form = cgi.FieldStorage () + + # + # Verify that everything in the form is correct. + # + error = ValidateForm (form) + if (error == 'registered'): + print ('Location: /releases/download.html') + print ('') + sys.exit (0) + + # + # Send the user to the download page. + # + print ('Content-type: text/html') + print ('') + + print ('

            Sorry; not registered

            ') + print ('

            ') + print ('We are sorry, but we cannot find your email address in our database.') + print ('Please use the normal registration system.') + print ('

            ') + + sys.exit (0) + From criswell at cs.uiuc.edu Thu Dec 18 15:53:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Thu Dec 18 15:53:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.html Message-ID: <200312182152.PAA26295@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.html updated: 1.3 -> 1.4 --- Log message: Use a different script for quick registration. --- Diffs of the changes: (+1 -1) Index: llvm-www/releases/register.html diff -u llvm-www/releases/register.html:1.3 llvm-www/releases/register.html:1.4 --- llvm-www/releases/register.html:1.3 Thu Dec 18 15:41:18 2003 +++ llvm-www/releases/register.html Thu Dec 18 15:52:44 2003 @@ -26,7 +26,7 @@
            -
            +
            From gaeke at cs.uiuc.edu Thu Dec 18 16:36:02 2003 From: gaeke at cs.uiuc.edu (Brian Gaeke) Date: Thu Dec 18 16:36:02 2003 Subject: [llvm-commits] CVS: reopt/lib/LightWtProfiling/UnpackTraceFunction.cpp Message-ID: <200312182235.QAA18321@seraph.cs.uiuc.edu> Changes in directory reopt/lib/LightWtProfiling: UnpackTraceFunction.cpp updated: 1.22 -> 1.23 --- Log message: Remove the bitrot induced by Misha's recent changes. --- Diffs of the changes: (+7 -6) Index: reopt/lib/LightWtProfiling/UnpackTraceFunction.cpp diff -u reopt/lib/LightWtProfiling/UnpackTraceFunction.cpp:1.22 reopt/lib/LightWtProfiling/UnpackTraceFunction.cpp:1.23 --- reopt/lib/LightWtProfiling/UnpackTraceFunction.cpp:1.22 Wed Nov 19 16:51:49 2003 +++ reopt/lib/LightWtProfiling/UnpackTraceFunction.cpp Thu Dec 18 16:35:09 2003 @@ -8,7 +8,8 @@ #include "TraceToFunction.h" #include "../../../../lib/CodeGen/RegAlloc/AllocInfo.h" #include "../../../../lib/CodeGen/RegAlloc/PhyRegAlloc.h" -#include "../../../../lib/Target/Sparc/SparcInternals.h" +#include "../../../../lib/Target/Sparc/SparcTargetMachine.h" +#include "../../../../lib/Target/Sparc/SparcRegInfo.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/CodeGen/MachineInstr.h" #include "llvm/Support/InstIterator.h" @@ -23,17 +24,17 @@ /// void insertCopyMachineInstrs (AllocInfo &Source, AllocInfo &Target, MachineBasicBlock &B, const Type *Ty) { - UltraSparc TM; + SparcTargetMachine TM; const TargetRegInfo &TRI = TM.getRegInfo (); std::vector mvec; int RegType; // Guess what kind of reg the register was allocated to. if (Ty == Type::FloatTy) - RegType = UltraSparcRegInfo::FPSingleRegType; + RegType = SparcRegInfo::FPSingleRegType; else if (Ty == Type::DoubleTy) - RegType = UltraSparcRegInfo::FPDoubleRegType; + RegType = SparcRegInfo::FPDoubleRegType; else - RegType = UltraSparcRegInfo::IntRegType; + RegType = SparcRegInfo::IntRegType; const unsigned FramePtrReg = TRI.getFramePointer (); const unsigned StackPtrReg = TRI.getStackPointer (); if (Source.AllocState == AllocInfo::Spilled @@ -53,7 +54,7 @@ } else if (Source.AllocState == AllocInfo::Spilled && Target.AllocState == AllocInfo::Spilled) { const unsigned TempReg = - TRI.getUnifiedRegNum (UltraSparcRegInfo::IntRegClassID, + TRI.getUnifiedRegNum (SparcRegInfo::IntRegClassID, SparcIntRegClass::g1); // just pick one? // Emit load instruction from stack loc. Source into register TempReg TRI.cpMem2RegMI (mvec, FramePtrReg, Source.Placement, TempReg, RegType); From alkis at cs.uiuc.edu Thu Dec 18 16:41:01 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 16:41:01 2003 Subject: [llvm-commits] CVS: llvm/lib/CodeGen/TwoAddressInstructionPass.cpp RegAllocLocal.cpp LiveIntervals.cpp Message-ID: <200312182240.QAA00303@morpheus.cs.uiuc.edu> Changes in directory llvm/lib/CodeGen: TwoAddressInstructionPass.cpp updated: 1.1 -> 1.2 RegAllocLocal.cpp updated: 1.35 -> 1.36 LiveIntervals.cpp updated: 1.11 -> 1.12 --- Log message: Remove TwoAddressInstruction from the public headers and add an ID instead, since this pass doesn't expose any state to its users. --- Diffs of the changes: (+21 -6) Index: llvm/lib/CodeGen/TwoAddressInstructionPass.cpp diff -u llvm/lib/CodeGen/TwoAddressInstructionPass.cpp:1.1 llvm/lib/CodeGen/TwoAddressInstructionPass.cpp:1.2 --- llvm/lib/CodeGen/TwoAddressInstructionPass.cpp:1.1 Thu Dec 18 07:06:03 2003 +++ llvm/lib/CodeGen/TwoAddressInstructionPass.cpp Thu Dec 18 16:40:23 2003 @@ -16,7 +16,6 @@ //===----------------------------------------------------------------------===// #define DEBUG_TYPE "twoaddrinstr" -#include "llvm/CodeGen/TwoAddressInstructionPass.h" #include "llvm/Function.h" #include "llvm/CodeGen/LiveVariables.h" #include "llvm/CodeGen/MachineFrameInfo.h" @@ -36,7 +35,23 @@ using namespace llvm; namespace { - RegisterAnalysis X( + class TwoAddressInstructionPass : public MachineFunctionPass + { + private: + MachineFunction* mf_; + const TargetMachine* tm_; + const MRegisterInfo* mri_; + LiveVariables* lv_; + + public: + virtual void getAnalysisUsage(AnalysisUsage &AU) const; + + private: + /// runOnMachineFunction - pass entry point + bool runOnMachineFunction(MachineFunction&); + }; + + RegisterPass X( "twoaddressinstruction", "Two-Address instruction pass"); Statistic<> numTwoAddressInstrs("twoaddressinstruction", @@ -44,6 +59,8 @@ Statistic<> numInstrsAdded("twoaddressinstruction", "Number of instructions added"); }; + +const PassInfo *llvm::TwoAddressInstructionPassID = X.getPassInfo(); void TwoAddressInstructionPass::getAnalysisUsage(AnalysisUsage &AU) const { Index: llvm/lib/CodeGen/RegAllocLocal.cpp diff -u llvm/lib/CodeGen/RegAllocLocal.cpp:1.35 llvm/lib/CodeGen/RegAllocLocal.cpp:1.36 --- llvm/lib/CodeGen/RegAllocLocal.cpp:1.35 Thu Dec 18 07:08:52 2003 +++ llvm/lib/CodeGen/RegAllocLocal.cpp Thu Dec 18 16:40:23 2003 @@ -19,7 +19,6 @@ #include "llvm/CodeGen/SSARegMap.h" #include "llvm/CodeGen/MachineFrameInfo.h" #include "llvm/CodeGen/LiveVariables.h" -#include "llvm/CodeGen/TwoAddressInstructionPass.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" #include "Support/CommandLine.h" @@ -113,7 +112,7 @@ if (!DisableKill) AU.addRequired(); AU.addRequiredID(PHIEliminationID); - AU.addRequired(); + AU.addRequiredID(TwoAddressInstructionPassID); MachineFunctionPass::getAnalysisUsage(AU); } Index: llvm/lib/CodeGen/LiveIntervals.cpp diff -u llvm/lib/CodeGen/LiveIntervals.cpp:1.11 llvm/lib/CodeGen/LiveIntervals.cpp:1.12 --- llvm/lib/CodeGen/LiveIntervals.cpp:1.11 Thu Dec 18 07:15:02 2003 +++ llvm/lib/CodeGen/LiveIntervals.cpp Thu Dec 18 16:40:24 2003 @@ -24,7 +24,6 @@ #include "llvm/CodeGen/MachineInstr.h" #include "llvm/CodeGen/Passes.h" #include "llvm/CodeGen/SSARegMap.h" -#include "llvm/CodeGen/TwoAddressInstructionPass.h" #include "llvm/Target/MRegisterInfo.h" #include "llvm/Target/TargetInstrInfo.h" #include "llvm/Target/TargetMachine.h" @@ -50,7 +49,7 @@ AU.addRequired(); AU.addPreservedID(PHIEliminationID); AU.addRequiredID(PHIEliminationID); - AU.addRequired(); + AU.addRequiredID(TwoAddressInstructionPassID); MachineFunctionPass::getAnalysisUsage(AU); } From alkis at cs.uiuc.edu Thu Dec 18 16:41:09 2003 From: alkis at cs.uiuc.edu (Alkis Evlogimenos) Date: Thu Dec 18 16:41:09 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/CodeGen/Passes.h TwoAddressInstructionPass.h Message-ID: <200312182240.QAA00293@morpheus.cs.uiuc.edu> Changes in directory llvm/include/llvm/CodeGen: Passes.h updated: 1.10 -> 1.11 TwoAddressInstructionPass.h (r1.1) removed --- Log message: Remove TwoAddressInstruction from the public headers and add an ID instead, since this pass doesn't expose any state to its users. --- Diffs of the changes: (+5 -0) Index: llvm/include/llvm/CodeGen/Passes.h diff -u llvm/include/llvm/CodeGen/Passes.h:1.10 llvm/include/llvm/CodeGen/Passes.h:1.11 --- llvm/include/llvm/CodeGen/Passes.h:1.10 Wed Nov 19 21:32:25 2003 +++ llvm/include/llvm/CodeGen/Passes.h Thu Dec 18 16:40:24 2003 @@ -28,6 +28,11 @@ // extern const PassInfo *PHIEliminationID; +// TwoAddressInstruction pass - This pass reduces two-address +// instructions to use two operands. This destroys SSA information but +// it is desired by register allocators. +extern const PassInfo *TwoAddressInstructionPassID; + /// Creates a register allocator as the user specified on the command /// line. FunctionPass *createRegisterAllocator(); From lattner at cs.uiuc.edu Thu Dec 18 21:07:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:07:01 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/GenerateReport.pl Message-ID: <200312190306.VAA11307@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: GenerateReport.pl updated: 1.15 -> 1.16 --- Log message: Hack off repeated prefixes from the first column if a variable is set. This allows us to get rid of the External/SPEC/CINT2000 prefix, for example. --- Diffs of the changes: (+35 -6) Index: llvm/test/Programs/GenerateReport.pl diff -u llvm/test/Programs/GenerateReport.pl:1.15 llvm/test/Programs/GenerateReport.pl:1.16 --- llvm/test/Programs/GenerateReport.pl:1.15 Sun Sep 21 11:56:55 2003 +++ llvm/test/Programs/GenerateReport.pl Thu Dec 18 21:06:37 2003 @@ -42,6 +42,10 @@ my $SortReverse = 0; my $SortNumeric = 0; # Sort numerically or textually? +# If the report wants us to trim repeated path prefixes off of the start of the +# strings in the first column of the report, we can do that. +my $TrimRepeatedPrefix = 0; + # Helper functions which may be called by the report description files... sub SumCols { my ($Cols, $Col, $NumRows) = @_; @@ -92,26 +96,27 @@ my @RowValues; my $Col = 0; for $Row (@Fields) { + my $Val = "*"; if (scalar(@$Row)) { # An actual value to read? if (ref ($Row->[1])) { # Code to be executed? - push @RowValues, &{$Row->[1]}(\@RowValues, $Col); + $Val = &{$Row->[1]}(\@RowValues, $Col); } else { # Field to be read... $Record =~ m/$Row->[1]/; if (!defined($1)) { - push @RowValues, "*"; + $Val = "*"; } else { # If there is a formatting function, run it now... - my $Val = $1; + $Val = $1; if (scalar(@$Row) > 2) { $Val = &{$Row->[2]}($Val); } - - push @RowValues, $Val; } } } else { # Just add a seperator... - push @RowValues, "|"; + $Val = "|"; } + + push @RowValues, $Val; $Col++; } @@ -122,6 +127,30 @@ } push @RowValues, $Assert if (!$HTML); push @Values, [@RowValues]; +} + + +# If the report wants it, we can trim excess cruft off of the beginning of the +# first column (which is often a path). +if ($TrimRepeatedPrefix and scalar(@Values)) { + OuterLoop: while (1) { + # Figure out what the first path prefix is: + $Values[0]->[0] =~ m|([^/]+/).|; + last OuterLoop if (!defined($1)); + + # Now that we have the prefix, check to see if all of the entries in the + # table start with this prefix. + foreach $Row (@Values) { + last OuterLoop if ((substr $Row->[0], 0, length $1) ne $1); + } + + # If we get here, then all of the entries have the prefix. Remove it now. + foreach $Row (@Values) { + $Row->[0] = substr $Row->[0], length $1; + } + + print "FOUND PREFIX: $1\n"; + } } # From lattner at cs.uiuc.edu Thu Dec 18 21:08:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:08:02 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/TEST.nightly.report Message-ID: <200312190307.VAA11318@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: TEST.nightly.report updated: 1.18 -> 1.19 --- Log message: Hack off repeated prefixes from the first column if a variable is set. This allows us to get rid of the External/SPEC/CINT2000 prefix, for example. --- Diffs of the changes: (+1 -0) Index: llvm/test/Programs/TEST.nightly.report diff -u llvm/test/Programs/TEST.nightly.report:1.18 llvm/test/Programs/TEST.nightly.report:1.19 --- llvm/test/Programs/TEST.nightly.report:1.18 Thu Sep 18 10:27:11 2003 +++ llvm/test/Programs/TEST.nightly.report Thu Dec 18 21:06:58 2003 @@ -6,6 +6,7 @@ # Sort by program name $SortCol = 0; +$TrimRepeatedPrefix = 1; my $WallTimeRE = "[A-Za-z0-9.: ]+\\(([0-9.]+) wall clock"; From lattner at cs.uiuc.edu Thu Dec 18 21:21:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:21:01 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/GenerateReport.pl Message-ID: <200312190320.VAA12487@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: GenerateReport.pl updated: 1.16 -> 1.17 --- Log message: Err, yeah, I have a clue, really. --- Diffs of the changes: (+0 -2) Index: llvm/test/Programs/GenerateReport.pl diff -u llvm/test/Programs/GenerateReport.pl:1.16 llvm/test/Programs/GenerateReport.pl:1.17 --- llvm/test/Programs/GenerateReport.pl:1.16 Thu Dec 18 21:06:37 2003 +++ llvm/test/Programs/GenerateReport.pl Thu Dec 18 21:20:04 2003 @@ -148,8 +148,6 @@ foreach $Row (@Values) { $Row->[0] = substr $Row->[0], length $1; } - - print "FOUND PREFIX: $1\n"; } } From lattner at cs.uiuc.edu Thu Dec 18 21:33:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:33:02 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/External/SPEC/Makefile.spec Message-ID: <200312190332.VAA13939@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs/External/SPEC: Makefile.spec updated: 1.20 -> 1.21 --- Log message: Add llc-ls target for testing the linear scan allocator, for use by alkis --- Diffs of the changes: (+8 -0) Index: llvm/test/Programs/External/SPEC/Makefile.spec diff -u llvm/test/Programs/External/SPEC/Makefile.spec:1.20 llvm/test/Programs/External/SPEC/Makefile.spec:1.21 --- llvm/test/Programs/External/SPEC/Makefile.spec:1.20 Wed Dec 10 09:16:33 2003 +++ llvm/test/Programs/External/SPEC/Makefile.spec Thu Dec 18 21:32:09 2003 @@ -94,6 +94,14 @@ -(cd Output/llc-$(RUN_TYPE); cat $(LOCAL_OUTPUTS)) > $@ -cp Output/llc-$(RUN_TYPE)/$(STDOUT_FILENAME).time $@.time +$(PROGRAMS_TO_TEST:%=Output/%.out-llc-ls): \ +Output/%.out-llc-ls: Output/%.llc-ls + $(SPEC_SANDBOX) llc-ls-$(RUN_TYPE) $@ $(REF_IN_DIR) \ + $(RUNSAFELY) $(STDIN_FILENAME) $(STDOUT_FILENAME) \ + ../../$< $(RUN_OPTIONS) + -(cd Output/llc-ls-$(RUN_TYPE); cat $(LOCAL_OUTPUTS)) > $@ + -cp Output/llc-ls-$(RUN_TYPE)/$(STDOUT_FILENAME).time $@.time + $(PROGRAMS_TO_TEST:%=Output/%.out-cbe): \ Output/%.out-cbe: Output/%.cbe $(SPEC_SANDBOX) cbe-$(RUN_TYPE) $@ $(REF_IN_DIR) \ From lattner at cs.uiuc.edu Thu Dec 18 21:34:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:34:01 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/TEST.nightly.report Message-ID: <200312190333.VAA14182@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: TEST.nightly.report updated: 1.19 -> 1.20 --- Log message: Add a llc-ls column, which will only do stuff on the X86 tester, but oh well. --- Diffs of the changes: (+2 -1) Index: llvm/test/Programs/TEST.nightly.report diff -u llvm/test/Programs/TEST.nightly.report:1.19 llvm/test/Programs/TEST.nightly.report:1.20 --- llvm/test/Programs/TEST.nightly.report:1.19 Thu Dec 18 21:06:58 2003 +++ llvm/test/Programs/TEST.nightly.report Thu Dec 18 21:33:36 2003 @@ -59,5 +59,6 @@ ["LLC" , 'TEST-RESULT-llc-time: real\s*([.0-9m:]+)', \&FormatTime], ["JIT" , 'TEST-RESULT-jit-time: real\s*([.0-9m:]+)', \&FormatTime], ["GCC/LLC" , \&GCCLLCRatio], - ["GCC/CBE" , \&GCCCBERatio] + ["GCC/CBE" , \&GCCCBERatio], + ["LLC-LS" , 'TEST-RESULT-llc-ls-time: real\s*([.0-9m:]+)', \&FormatTime] ); From lattner at cs.uiuc.edu Thu Dec 18 21:34:09 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:34:09 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/Makefile.programs Message-ID: <200312190333.VAA14102@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: Makefile.programs updated: 1.104 -> 1.105 --- Log message: Add llc-ls target for testing the linear scan allocator, for use by alkis --- Diffs of the changes: (+29 -3) Index: llvm/test/Programs/Makefile.programs diff -u llvm/test/Programs/Makefile.programs:1.104 llvm/test/Programs/Makefile.programs:1.105 --- llvm/test/Programs/Makefile.programs:1.104 Wed Dec 10 09:08:59 2003 +++ llvm/test/Programs/Makefile.programs Thu Dec 18 21:32:59 2003 @@ -85,8 +85,8 @@ # Completed bytecode for a program BYTECODE := $(addsuffix .llvm.bc, $(PREFIXED_PROGRAMS_TO_TEST)) -# Generated code for llc (which does not require the target platform) LLCCODEGEN := $(addsuffix .llc.s, $(PREFIXED_PROGRAMS_TO_TEST)) +LLCLSCODEGEN := $(addsuffix .llc-ls.s, $(PREFIXED_PROGRAMS_TO_TEST)) CBECODEGEN := $(addsuffix .cbe, $(PREFIXED_PROGRAMS_TO_TEST)) # Output produced by programs run @@ -95,21 +95,23 @@ LLIOUTPUT := $(addsuffix .out-lli, $(PREFIXED_PROGRAMS_TO_TEST)) JITOUTPUT := $(addsuffix .out-jit, $(PREFIXED_PROGRAMS_TO_TEST)) LLCOUTPUT := $(addsuffix .out-llc, $(PREFIXED_PROGRAMS_TO_TEST)) +LLCLSOUTPUT := $(addsuffix .out-llc-ls, $(PREFIXED_PROGRAMS_TO_TEST)) CBEOUTPUT := $(addsuffix .out-cbe, $(PREFIXED_PROGRAMS_TO_TEST)) # Diffs of program runs vs the native program LLIDIFFS := $(addsuffix .diff-lli, $(PREFIXED_PROGRAMS_TO_TEST)) JITDIFFS := $(addsuffix .diff-jit, $(PREFIXED_PROGRAMS_TO_TEST)) LLCDIFFS := $(addsuffix .diff-llc, $(PREFIXED_PROGRAMS_TO_TEST)) +LLCLSDIFFS := $(addsuffix .diff-llc-ls, $(PREFIXED_PROGRAMS_TO_TEST)) CBEDIFFS := $(addsuffix .diff-cbe, $(PREFIXED_PROGRAMS_TO_TEST)) # Build Program outputs: -.PRECIOUS: Output/%.out-lli Output/%.out-jit Output/%.out-llc +.PRECIOUS: Output/%.out-lli Output/%.out-jit Output/%.out-llc Output/%.out-llc-ls .PRECIOUS: Output/%.out-nat Output/%.out-cbe # Build diffs from the output... .PRECIOUS: Output/%.diff-lli Output/%.diff-jit -.PRECIOUS: Output/%.diff-llc Output/%.diff-cbe +.PRECIOUS: Output/%.diff-llc Output/%.diff-llc-ls Output/%.diff-cbe # Regardless of what other options are specified, build the program's bytecode @@ -176,6 +178,10 @@ endif endif +ifdef ENABLE_LINEARSCAN +all:: $(LLCLSDIFFS) +endif + ifdef ENABLE_LLI all:: $(LLIDIFFS) endif @@ -240,6 +246,10 @@ Output/%.llc.s: Output/%.llvm.bc $(LLC) -$(LLC) $(LLCFLAGS) -f $< -o $@ +$(PROGRAMS_TO_TEST:%=Output/%.llc-ls.s): \ +Output/%.llc-ls.s: Output/%.llvm.bc $(LLC) + -$(LLC) $(LLCFLAGS) -f -regalloc=linearscan $< -o $@ + ## Alternative command to run llc remotely on another machine: ## This is very useful when debugging: @@ -251,6 +261,10 @@ Output/%.llc: Output/%.llc.s -$(CC) $(CFLAGS) $< $(LLCLIBS) $(LDFLAGS) -o $@ +$(PROGRAMS_TO_TEST:%=Output/%.llc-ls): \ +Output/%.llc-ls: Output/%.llc-ls.s + -$(CC) $(CFLAGS) $< $(LLCLIBS) $(LDFLAGS) -o $@ + # # Rules to execute the program @@ -290,6 +304,10 @@ Output/%.out-llc: Output/%.llc -$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS) +$(PROGRAMS_TO_TEST:%=Output/%.out-llc-ls): \ +Output/%.out-llc-ls: Output/%.llc-ls + -$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS) + $(PROGRAMS_TO_TEST:%=Output/%.out-cbe): \ Output/%.out-cbe: Output/%.cbe -$(RUNSAFELY) $(STDIN_FILENAME) $@ $< $(RUN_OPTIONS) @@ -340,6 +358,10 @@ Output/%.diff-llc: Output/%.out-nat Output/%.out-llc -$(DIFFPROG) llc $* $(HIDEDIFF) +$(PROGRAMS_TO_TEST:%=Output/%.diff-llc-ls): \ +Output/%.diff-llc-ls: Output/%.out-nat Output/%.out-llc-ls + -$(DIFFPROG) llc-ls $* $(HIDEDIFF) + $(PROGRAMS_TO_TEST:%=Output/%.diff-cbe): \ Output/%.diff-cbe: Output/%.out-nat Output/%.out-cbe -$(DIFFPROG) cbe $* $(HIDEDIFF) @@ -355,6 +377,10 @@ $(PROGRAMS_TO_TEST:%=Output/%.exe-llc): \ Output/%.exe-llc: Output/%.diff-llc + -cp $< $@ + +$(PROGRAMS_TO_TEST:%=Output/%.exe-llc-ls): \ +Output/%.exe-llc-ls: Output/%.diff-llc-ls -cp $< $@ $(PROGRAMS_TO_TEST:%=Output/%.exe-cbe): \ From lattner at cs.uiuc.edu Thu Dec 18 21:35:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:35:01 2003 Subject: [llvm-commits] CVS: llvm/utils/NightlyTestTemplate.html Message-ID: <200312190334.VAA14383@zion.cs.uiuc.edu> Changes in directory llvm/utils: NightlyTestTemplate.html updated: 1.22 -> 1.23 --- Log message: Update template --- Diffs of the changes: (+3 -0) Index: llvm/utils/NightlyTestTemplate.html diff -u llvm/utils/NightlyTestTemplate.html:1.22 llvm/utils/NightlyTestTemplate.html:1.23 --- llvm/utils/NightlyTestTemplate.html:1.22 Sat Nov 8 14:48:39 2003 +++ llvm/utils/NightlyTestTemplate.html Thu Dec 18 21:34:46 2003 @@ -199,6 +199,9 @@ GCC output: greater than 1 is a speedup, less than 1 is a slowdown.
          29. GCC/CBE - The speed-up of the CBE output vs the native GCC output: greater than 1 is a speedup, less than 1 is a slowdown.
          30. +
          31. LLC-LS - How long does the program generated by the static + backend LLC take to execute the program, when compiled with the linear scan + register allocator. This is temporary, for tuning.
          32. A complete log of testing From lattner at cs.uiuc.edu Thu Dec 18 21:36:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:36:02 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/TEST.nightly.Makefile Message-ID: <200312190335.VAA14682@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: TEST.nightly.Makefile updated: 1.25 -> 1.26 --- Log message: add linear scan tests if ENABLE_LINEARSCAN is defined --- Diffs of the changes: (+24 -1) Index: llvm/test/Programs/TEST.nightly.Makefile diff -u llvm/test/Programs/TEST.nightly.Makefile:1.25 llvm/test/Programs/TEST.nightly.Makefile:1.26 --- llvm/test/Programs/TEST.nightly.Makefile:1.25 Sun Aug 17 23:08:47 2003 +++ llvm/test/Programs/TEST.nightly.Makefile Thu Dec 18 21:35:27 2003 @@ -1,4 +1,4 @@ -##===- test/Programs/TEST.nightly.Makefile --*- Makefile -*-=======- vim:ft=make +##===- test/Programs/TEST.nightly.Makefile --*- Makefile -*- vim:ft=make --===## # # This test is used in conjunction with the llvm/utils/NightlyTest* stuff to # generate information about program status for the nightly report. @@ -11,8 +11,12 @@ CFLAGS := -O3 REPORTS_TO_GEN := compile nat llc cbe jit +ifdef ENABLE_LINEARSCAN +REPORTS_TO_GEN += llc-ls +endif REPORTS_SUFFIX := $(addsuffix .report.txt, $(REPORTS_TO_GEN)) + TIMEOPT = -time-passes -stats -info-output-file=$(CURDIR)/$@.info EXTRA_LLI_OPTS = $(TIMEOPT) @@ -61,6 +65,25 @@ else \ echo "TEST-FAIL: llc $(RELDIR)/$*" >> $@;\ fi + +# LLC-linearscan tests +$(PROGRAMS_TO_TEST:%=Output/%.nightly.llc-ls.report.txt): \ +Output/%.nightly.llc-ls.report.txt: Output/%.llvm.bc Output/%.exe-llc-ls $(LLC) + @echo > $@ + -head -n 100 Output/$*.exe-llc-ls >> $@ + @-if test -f Output/$*.exe-llc-ls; then \ + echo "TEST-PASS: llc-ls $(RELDIR)/$*" >> $@;\ + $(LLC) $< -o /dev/null -f $(TIMEOPT) >> $@ 2>&1; \ + printf "TEST-RESULT-llc-ls: " >> $@;\ + grep "Total Execution Time" $@.info >> $@;\ + printf "TEST-RESULT-llc-ls-time: " >> $@;\ + grep "^real" Output/$*.out-llc-ls.time >> $@;\ + echo >> $@;\ + else \ + echo "TEST-FAIL: llc-ls $(RELDIR)/$*" >> $@;\ + fi + + # CBE tests $(PROGRAMS_TO_TEST:%=Output/%.nightly.cbe.report.txt): \ From lattner at cs.uiuc.edu Thu Dec 18 21:48:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:48:01 2003 Subject: [llvm-commits] CVS: llvm/utils/NightlyTest.pl Message-ID: <200312190347.VAA15301@zion.cs.uiuc.edu> Changes in directory llvm/utils: NightlyTest.pl updated: 1.40 -> 1.41 --- Log message: If -enable-linscan is specified, add ENABLE_LINEARSCAN=1 to the make commandline --- Diffs of the changes: (+6 -3) Index: llvm/utils/NightlyTest.pl diff -u llvm/utils/NightlyTest.pl:1.40 llvm/utils/NightlyTest.pl:1.41 --- llvm/utils/NightlyTest.pl:1.40 Sun Nov 30 23:31:12 2003 +++ llvm/utils/NightlyTest.pl Thu Dec 18 21:47:31 2003 @@ -18,6 +18,8 @@ # -norunningtests Do not run the Olden benchmark suite with # LARGE_PROBLEM_SIZE enabled. # -parallel Run two parallel jobs with GNU Make. +# -enable-linscan Enable linearscan tests +# # CVSROOT is the CVS repository from which the tree will be checked out, # specified either in the full :method:user at host:/dir syntax, or # just /dir if using a local repo. @@ -117,7 +119,7 @@ my $NOTEST = 0; my $NORUNNINGTESTS = 0; my $MAKEOPTS = ""; - +my $ENABLELINEARSCAN = ""; # Parse arguments... while (scalar(@ARGV) and ($_ = $ARGV[0], /^[-+]/)) { @@ -130,6 +132,7 @@ if (/^-notest$/) { $NOTEST = 1; $NORUNNINGTESTS = 1; next; } if (/^-norunningtests$/) { $NORUNNINGTESTS = 1; next; } if (/^-parallel$/) { $MAKEOPTS = "-j2 -l3.0"; next; } + if (/^-enable-linscan$/) { $ENABLELINEARSCAN = "ENABLE_LINEARSCAN=1"; } print "Unknown option: $_ : ignoring!\n"; } @@ -323,8 +326,8 @@ # Run the programs tests... creating a report.nightly.html file if (!$NOTEST) { - system "gmake -k $MAKEOPTS report.nightly.html TEST=nightly " - . "> $Prefix-$SubDir-ProgramTest.txt 2>&1"; + system "gmake -k $MAKEOPTS $ENABLELINEARSCAN report.nightly.html " + . "TEST=nightly > $Prefix-$SubDir-ProgramTest.txt 2>&1"; } else { system "gunzip $Prefix-$SubDir-ProgramTest.txt.gz"; } From lattner at cs.uiuc.edu Thu Dec 18 21:49:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 21:49:01 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/TEST.jit.report Message-ID: <200312190348.VAA15322@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs: TEST.jit.report updated: 1.2 -> 1.3 --- Log message: Cleanup report a bit --- Diffs of the changes: (+1 -0) Index: llvm/test/Programs/TEST.jit.report diff -u llvm/test/Programs/TEST.jit.report:1.2 llvm/test/Programs/TEST.jit.report:1.3 --- llvm/test/Programs/TEST.jit.report:1.2 Mon Jun 16 10:52:02 2003 +++ llvm/test/Programs/TEST.jit.report Thu Dec 18 21:48:48 2003 @@ -6,6 +6,7 @@ # Sort by total execution time $SortCol = 2; +$TrimRepeatedPrefix = 1; # Sort in descending order $SortReverse = 1; From lattner at cs.uiuc.edu Thu Dec 18 23:15:04 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 23:15:04 2003 Subject: [llvm-commits] CVS: llvm-www/Publications.html Message-ID: <200312190514.XAA27886@zion.cs.uiuc.edu> Changes in directory llvm-www: Publications.html updated: 1.1 -> 1.2 --- Log message: Note that this paper will be publicshed in CGO --- Diffs of the changes: (+1 -1) Index: llvm-www/Publications.html diff -u llvm-www/Publications.html:1.1 llvm-www/Publications.html:1.2 --- llvm-www/Publications.html:1.1 Tue Nov 18 17:04:53 2003 +++ llvm-www/Publications.html Thu Dec 18 23:13:58 2003 @@ -16,7 +16,7 @@ Analysis & Transformation", Chris Lattner & Vikram Adve.
            Technical Report #UIUCDCS-R-2003-2380, Computer Science - Dept., Univ. of Illinois, Sep. 2003. + Dept., Univ. of Illinois, Sep. 2003. (to appear in CGO'04)

          33. " Memory Safety Without Runtime Checks or Garbage Collection"
            From lattner at cs.uiuc.edu Thu Dec 18 23:17:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Thu Dec 18 23:17:01 2003 Subject: [llvm-commits] CVS: llvm-www/pubs/2003-09-30-LifelongOptimizationTR.html Message-ID: <200312190516.XAA28141@zion.cs.uiuc.edu> Changes in directory llvm-www/pubs: 2003-09-30-LifelongOptimizationTR.html updated: 1.3 -> 1.4 --- Log message: add note --- Diffs of the changes: (+2 -0) Index: llvm-www/pubs/2003-09-30-LifelongOptimizationTR.html diff -u llvm-www/pubs/2003-09-30-LifelongOptimizationTR.html:1.3 llvm-www/pubs/2003-09-30-LifelongOptimizationTR.html:1.4 --- llvm-www/pubs/2003-09-30-LifelongOptimizationTR.html:1.3 Tue Oct 21 19:26:00 2003 +++ llvm-www/pubs/2003-09-30-LifelongOptimizationTR.html Thu Dec 18 23:15:51 2003 @@ -49,6 +49,8 @@ Illinois, Sep. 2003. +

            This paper is the submitted version of a paper to appear in CGO'04.

            +

            Download:

          34. From criswell at cs.uiuc.edu Fri Dec 19 11:24:01 2003 From: criswell at cs.uiuc.edu (John Criswell) Date: Fri Dec 19 11:24:01 2003 Subject: [llvm-commits] CVS: llvm-www/releases/register.html Message-ID: <200312191723.LAA03354@choi.cs.uiuc.edu> Changes in directory llvm-www/releases: register.html updated: 1.5 -> 1.6 --- Log message: Added clarification. --- Diffs of the changes: (+2 -1) Index: llvm-www/releases/register.html diff -u llvm-www/releases/register.html:1.5 llvm-www/releases/register.html:1.6 --- llvm-www/releases/register.html:1.5 Fri Dec 19 11:22:25 2003 +++ llvm-www/releases/register.html Fri Dec 19 11:23:13 2003 @@ -16,7 +16,8 @@

            We'd like to collect some information about people and organizations who are interested in LLVM. Please complete the following form below to download a copy -of the LLVM software, or use the Quick Download if you have already registered. +of the LLVM software, or use the Quick Download if you have already registered +previously.
            From lattner at cs.uiuc.edu Fri Dec 19 13:49:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 13:49:02 2003 Subject: [llvm-commits] CVS: llvm/utils/NightlyTest.pl Message-ID: <200312191948.NAA18843@zion.cs.uiuc.edu> Changes in directory llvm/utils: NightlyTest.pl updated: 1.41 -> 1.42 --- Log message: Eliminate a spurious warning --- Diffs of the changes: (+1 -1) Index: llvm/utils/NightlyTest.pl diff -u llvm/utils/NightlyTest.pl:1.41 llvm/utils/NightlyTest.pl:1.42 --- llvm/utils/NightlyTest.pl:1.41 Thu Dec 18 21:47:31 2003 +++ llvm/utils/NightlyTest.pl Fri Dec 19 13:48:43 2003 @@ -132,7 +132,7 @@ if (/^-notest$/) { $NOTEST = 1; $NORUNNINGTESTS = 1; next; } if (/^-norunningtests$/) { $NORUNNINGTESTS = 1; next; } if (/^-parallel$/) { $MAKEOPTS = "-j2 -l3.0"; next; } - if (/^-enable-linscan$/) { $ENABLELINEARSCAN = "ENABLE_LINEARSCAN=1"; } + if (/^-enable-linscan$/) { $ENABLELINEARSCAN = "ENABLE_LINEARSCAN=1"; next; } print "Unknown option: $_ : ignoring!\n"; } From lattner at cs.uiuc.edu Fri Dec 19 17:26:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 17:26:01 2003 Subject: [llvm-commits] CVS: llvm/test/Programs/SingleSource/CustomChecked/Makefile Message-ID: <200312192325.RAA32562@zion.cs.uiuc.edu> Changes in directory llvm/test/Programs/SingleSource/CustomChecked: Makefile updated: 1.9 -> 1.10 --- Log message: Add linear scan targets --- Diffs of the changes: (+10 -1) Index: llvm/test/Programs/SingleSource/CustomChecked/Makefile diff -u llvm/test/Programs/SingleSource/CustomChecked/Makefile:1.9 llvm/test/Programs/SingleSource/CustomChecked/Makefile:1.10 --- llvm/test/Programs/SingleSource/CustomChecked/Makefile:1.9 Thu Oct 23 10:12:18 2003 +++ llvm/test/Programs/SingleSource/CustomChecked/Makefile Fri Dec 19 17:25:15 2003 @@ -12,8 +12,9 @@ LLI_RUN := $(addsuffix .run-lli, $(PREFIXED_PROGRAMS_TO_TEST)) JIT_RUN := $(addsuffix .run-jit, $(PREFIXED_PROGRAMS_TO_TEST)) LLC_RUN := $(addsuffix .run-llc, $(PREFIXED_PROGRAMS_TO_TEST)) +LLCLS_RUN := $(addsuffix .run-llc-ls, $(PREFIXED_PROGRAMS_TO_TEST)) CBE_RUN := $(addsuffix .run-cbe, $(PREFIXED_PROGRAMS_TO_TEST)) -.PRECIOUS: $(LLI_RUN) $(JIT_RUN) $(LLC_RUN) $(CBE_RUN) +.PRECIOUS: $(LLI_RUN) $(JIT_RUN) $(LLC_RUN) $(LLCLS_RUN) $(CBE_RUN) ifndef DISABLE_LLC_DIFFS all:: $(LLC_RUN) @@ -45,6 +46,10 @@ Output/%.run-llc: Output/%.llc -$(TESTRUNR) $(SourceDir)/$(filter $*.%, $(Source)) "$< $(RUN_OPTIONS)" $@ +$(PROGRAMS_TO_TEST:%=Output/%.run-llc-ls): \ +Output/%.run-llc-ls: Output/%.llc-ls + -$(TESTRUNR) $(SourceDir)/$(filter $*.%, $(Source)) "$< $(RUN_OPTIONS)" $@ + $(PROGRAMS_TO_TEST:%=Output/%.run-cbe): \ Output/%.run-cbe: Output/%.cbe -$(TESTRUNR) $(SourceDir)/$(filter $*.%, $(Source)) "$< $(RUN_OPTIONS)" $@ @@ -60,6 +65,10 @@ $(PROGRAMS_TO_TEST:%=Output/%.exe-llc): \ Output/%.exe-llc: Output/%.run-llc + -cp $< $@ + +$(PROGRAMS_TO_TEST:%=Output/%.exe-llc-ls): \ +Output/%.exe-llc-ls: Output/%.run-llc-ls -cp $< $@ $(PROGRAMS_TO_TEST:%=Output/%.exe-cbe): \ From vnc61ut at bigfoot.com Fri Dec 19 17:54:02 2003 From: vnc61ut at bigfoot.com (Sheri Peoples) Date: Fri Dec 19 17:54:02 2003 Subject: [llvm-commits] speed up low carb weight loss 9b kzjmvlsyla g Message-ID: <0a4-0hh-71g-sr@on843r> An HTML attachment was scrubbed... URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20031219/8058f635/attachment.html From b366rtc at lycos.de Fri Dec 19 18:13:02 2003 From: b366rtc at lycos.de (Viola Self) Date: Fri Dec 19 18:13:02 2003 Subject: [llvm-commits] guaranteed Weight loss program xjjuwmnp ept Message-ID: An HTML attachment was scrubbed... URL: http://lists.cs.uiuc.edu/pipermail/llvm-commits/attachments/20031219/1354c676/attachment.html From lattner at cs.uiuc.edu Fri Dec 19 19:22:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 19:22:01 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/Target/TargetJITInfo.h TargetMachine.h Message-ID: <200312200121.TAA24509@zion.cs.uiuc.edu> Changes in directory llvm/include/llvm/Target: TargetJITInfo.h added (r1.1) TargetMachine.h updated: 1.40 -> 1.41 --- Log message: Rip JIT specific stuff out of TargetMachine, as per PR176 --- Diffs of the changes: (+62 -25) Index: llvm/include/llvm/Target/TargetJITInfo.h diff -c /dev/null llvm/include/llvm/Target/TargetJITInfo.h:1.1 *** /dev/null Fri Dec 19 19:21:48 2003 --- llvm/include/llvm/Target/TargetJITInfo.h Fri Dec 19 19:21:37 2003 *************** *** 0 **** --- 1,54 ---- + //===- Target/TargetJITInfo.h - Target Information for JIT ------*- C++ -*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file exposes an abstract interface used by the Just-In-Time code + // generator to perform target-specific activities, such as emitting stubs. If + // a TargetMachine supports JIT code generation, it should provide one of these + // objects through the getJITInfo() method. + // + //===----------------------------------------------------------------------===// + + #ifndef LLVM_TARGET_TARGETJITINFO_H + #define LLVM_TARGET_TARGETJITINFO_H + + namespace llvm { + class Function; + class FunctionPassManager; + class MachineCodeEmitter; + + /// TargetJITInfo - Target specific information required by the Just-In-Time + /// code generator. + struct TargetJITInfo { + virtual ~TargetJITInfo() {} + + /// addPassesToJITCompile - Add passes to the specified pass manager to + /// implement a fast code generator for this target. + /// + virtual void addPassesToJITCompile(FunctionPassManager &PM) = 0; + + /// replaceMachineCodeForFunction - Make it so that calling the function + /// whose machine code is at OLD turns into a call to NEW, perhaps by + /// overwriting OLD with a branch to NEW. This is used for self-modifying + /// code. + /// + virtual void replaceMachineCodeForFunction (void *Old, void *New) = 0; + + /// getJITStubForFunction - Create or return a stub for the specified + /// function. This stub acts just like the specified function, except that + /// it allows the "address" of the function to be taken without having to + /// generate code for it. Targets do not need to implement this method, but + /// doing so will allow for faster startup of the JIT. + /// + virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE) { + return 0; + } + }; + } // End llvm namespace + + #endif Index: llvm/include/llvm/Target/TargetMachine.h diff -u llvm/include/llvm/Target/TargetMachine.h:1.40 llvm/include/llvm/Target/TargetMachine.h:1.41 --- llvm/include/llvm/Target/TargetMachine.h:1.40 Fri Dec 12 01:10:32 2003 +++ llvm/include/llvm/Target/TargetMachine.h Fri Dec 19 19:21:37 2003 @@ -21,6 +21,7 @@ class TargetInstrInfo; class TargetInstrDescriptor; +class TargetJITInfo; class TargetSchedInfo; class TargetRegInfo; class TargetFrameInfo; @@ -79,16 +80,16 @@ /// virtual const MRegisterInfo* getRegisterInfo() const { return 0; } - // Data storage information + /// getJITInfo - If this target supports a JIT, return information for it, + /// otherwise return null. + /// + virtual TargetJITInfo *getJITInfo() { return 0; } + + // Data storage information. FIXME, this should be moved out to sparc + // specific code. // virtual unsigned findOptimalStorageSize(const Type* ty) const; - /// addPassesToJITCompile - Add passes to the specified pass manager to - /// implement a fast dynamic compiler for this target. Return true if this is - /// not supported for this target. - /// - virtual bool addPassesToJITCompile(FunctionPassManager &PM) { return true; } - /// addPassesToEmitAssembly - Add passes to the specified pass manager to get /// assembly langage code emitted. Typically this will involve several steps /// of code generation. This method should return true if assembly emission @@ -107,24 +108,6 @@ virtual bool addPassesToEmitMachineCode(FunctionPassManager &PM, MachineCodeEmitter &MCE) { return true; - } - - /// replaceMachineCodeForFunction - Make it so that calling the - /// function whose machine code is at OLD turns into a call to NEW, - /// perhaps by overwriting OLD with a branch to NEW. - /// - /// FIXME: this is JIT-specific. - /// - virtual void replaceMachineCodeForFunction (void *Old, void *New) { - assert (0 && "Current target cannot replace machine code for functions"); - } - - /// getJITStubForFunction - Create or return a stub for the specified - /// function. This stub acts just like the specified function, except that it - /// allows the "address" of the function to be taken without having to - /// generate code for it. - virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE) { - return 0; } }; From lattner at cs.uiuc.edu Fri Dec 19 19:23:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 19:23:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86JITInfo.h X86CodeEmitter.cpp X86InstrInfo.h X86TargetMachine.cpp X86TargetMachine.h Message-ID: <200312200122.TAA24548@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/X86: X86JITInfo.h added (r1.1) X86CodeEmitter.cpp updated: 1.42 -> 1.43 X86InstrInfo.h updated: 1.28 -> 1.29 X86TargetMachine.cpp updated: 1.39 -> 1.40 X86TargetMachine.h updated: 1.18 -> 1.19 --- Log message: Rip JIT specific stuff out of TargetMachine, as per PR176 --- Diffs of the changes: (+74 -38) Index: llvm/lib/Target/X86/X86JITInfo.h diff -c /dev/null llvm/lib/Target/X86/X86JITInfo.h:1.1 *** /dev/null Fri Dec 19 19:22:15 2003 --- llvm/lib/Target/X86/X86JITInfo.h Fri Dec 19 19:22:04 2003 *************** *** 0 **** --- 1,47 ---- + //===- X86JITInfo.h - X86 implementation of the JIT interface --*- C++ -*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file contains the X86 implementation of the TargetJITInfo class. + // + //===----------------------------------------------------------------------===// + + #ifndef X86JITINFO_H + #define X86JITINFO_H + + #include "llvm/Target/TargetJITInfo.h" + + namespace llvm { + class TargetMachine; + class X86JITInfo : public TargetJITInfo { + TargetMachine &TM; + public: + X86JITInfo(TargetMachine &tm) : TM(tm) {} + + /// addPassesToJITCompile - Add passes to the specified pass manager to + /// implement a fast dynamic compiler for this target. Return true if this + /// is not supported for this target. + /// + virtual void addPassesToJITCompile(FunctionPassManager &PM); + + /// replaceMachineCodeForFunction - Make it so that calling the function + /// whose machine code is at OLD turns into a call to NEW, perhaps by + /// overwriting OLD with a branch to NEW. This is used for self-modifying + /// code. + /// + virtual void replaceMachineCodeForFunction (void *Old, void *New); + + /// getJITStubForFunction - Create or return a stub for the specified + /// function. This stub acts just like the specified function, except that + /// it allows the "address" of the function to be taken without having to + /// generate code for it. + virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE); + }; + } + + #endif Index: llvm/lib/Target/X86/X86CodeEmitter.cpp diff -u llvm/lib/Target/X86/X86CodeEmitter.cpp:1.42 llvm/lib/Target/X86/X86CodeEmitter.cpp:1.43 --- llvm/lib/Target/X86/X86CodeEmitter.cpp:1.42 Fri Dec 12 13:57:48 2003 +++ llvm/lib/Target/X86/X86CodeEmitter.cpp Fri Dec 19 19:22:04 2003 @@ -53,11 +53,19 @@ JITResolver *TheJITResolver; } -void *X86TargetMachine::getJITStubForFunction(Function *F, - MachineCodeEmitter &MCE) { +void *X86JITInfo::getJITStubForFunction(Function *F, MachineCodeEmitter &MCE) { if (TheJITResolver == 0) TheJITResolver = new JITResolver(MCE); return (void*)((unsigned long)TheJITResolver->getLazyResolver(F)); +} + +void X86JITInfo::replaceMachineCodeForFunction (void *Old, void *New) { + char *OldByte = (char *) Old; + *OldByte++ = 0xE9; // Emit JMP opcode. + int32_t *OldWord = (int32_t *) OldByte; + int32_t NewAddr = (intptr_t) New; + int32_t OldAddr = (intptr_t) OldWord; + *OldWord = NewAddr - OldAddr - 4; // Emit PC-relative addr of New code. } /// addFunctionReference - This method is called when we need to emit the Index: llvm/lib/Target/X86/X86InstrInfo.h diff -u llvm/lib/Target/X86/X86InstrInfo.h:1.28 llvm/lib/Target/X86/X86InstrInfo.h:1.29 --- llvm/lib/Target/X86/X86InstrInfo.h:1.28 Tue Nov 11 16:41:33 2003 +++ llvm/lib/Target/X86/X86InstrInfo.h Fri Dec 19 19:22:04 2003 @@ -1,4 +1,4 @@ -//===- X86InstructionInfo.h - X86 Instruction Information ---------*-C++-*-===// +//===- X86InstrInfo.h - X86 Instruction Information ------------*- C++ -*- ===// // // The LLVM Compiler Infrastructure // Index: llvm/lib/Target/X86/X86TargetMachine.cpp diff -u llvm/lib/Target/X86/X86TargetMachine.cpp:1.39 llvm/lib/Target/X86/X86TargetMachine.cpp:1.40 --- llvm/lib/Target/X86/X86TargetMachine.cpp:1.39 Fri Dec 12 23:36:19 2003 +++ llvm/lib/Target/X86/X86TargetMachine.cpp Fri Dec 19 19:22:04 2003 @@ -21,8 +21,7 @@ #include "llvm/Transforms/Scalar.h" #include "Support/CommandLine.h" #include "Support/Statistic.h" - -namespace llvm { +using namespace llvm; namespace { cl::opt PrintCode("print-machineinstrs", @@ -36,7 +35,7 @@ // allocateX86TargetMachine - Allocate and return a subclass of TargetMachine // that implements the X86 backend. // -TargetMachine *allocateX86TargetMachine(const Module &M) { +TargetMachine *llvm::allocateX86TargetMachine(const Module &M) { return new X86TargetMachine(M); } @@ -45,7 +44,8 @@ /// X86TargetMachine::X86TargetMachine(const Module &M) : TargetMachine("X86", true, 4, 4, 4, 4, 4), - FrameInfo(TargetFrameInfo::StackGrowsDown, 8/*16 for SSE*/, 4) { + FrameInfo(TargetFrameInfo::StackGrowsDown, 8/*16 for SSE*/, 4), + JITInfo(*this) { } @@ -108,7 +108,7 @@ /// implement a fast dynamic compiler for this target. Return true if this is /// not supported for this target. /// -bool X86TargetMachine::addPassesToJITCompile(FunctionPassManager &PM) { +void X86JITInfo::addPassesToJITCompile(FunctionPassManager &PM) { // FIXME: Implement the switch instruction in the instruction selector! PM.add(createLowerSwitchPass()); @@ -120,9 +120,9 @@ PM.add(createCFGSimplificationPass()); if (NoPatternISel) - PM.add(createX86SimpleInstructionSelector(*this)); + PM.add(createX86SimpleInstructionSelector(TM)); else - PM.add(createX86PatternInstructionSelector(*this)); + PM.add(createX86PatternInstructionSelector(TM)); // Run optional SSA-based machine code optimizations next... if (!NoSSAPeephole) @@ -156,18 +156,6 @@ PM.add(createX86PeepholeOptimizerPass()); if (PrintCode) // Print the register-allocated code - PM.add(createX86CodePrinterPass(std::cerr, *this)); - return false; // success! -} - -void X86TargetMachine::replaceMachineCodeForFunction (void *Old, void *New) { - // FIXME: This code could perhaps live in a more appropriate place. - char *OldByte = (char *) Old; - *OldByte++ = 0xE9; // Emit JMP opcode. - int32_t *OldWord = (int32_t *) OldByte; - int32_t NewAddr = (intptr_t) New; - int32_t OldAddr = (intptr_t) OldWord; - *OldWord = NewAddr - OldAddr - 4; // Emit PC-relative addr of New code. + PM.add(createX86CodePrinterPass(std::cerr, TM)); } -} // End llvm namespace Index: llvm/lib/Target/X86/X86TargetMachine.h diff -u llvm/lib/Target/X86/X86TargetMachine.h:1.18 llvm/lib/Target/X86/X86TargetMachine.h:1.19 --- llvm/lib/Target/X86/X86TargetMachine.h:1.18 Fri Dec 12 01:11:18 2003 +++ llvm/lib/Target/X86/X86TargetMachine.h Fri Dec 19 19:22:04 2003 @@ -18,12 +18,14 @@ #include "llvm/Target/TargetFrameInfo.h" #include "llvm/PassManager.h" #include "X86InstrInfo.h" +#include "X86JITInfo.h" namespace llvm { class X86TargetMachine : public TargetMachine { - X86InstrInfo InstrInfo; + X86InstrInfo InstrInfo; TargetFrameInfo FrameInfo; + X86JITInfo JITInfo; public: X86TargetMachine(const Module &M); @@ -33,16 +35,15 @@ return &InstrInfo.getRegisterInfo(); } + virtual TargetJITInfo *getJITInfo() { + return &JITInfo; + } + + virtual const TargetSchedInfo &getSchedInfo() const { abort(); } virtual const TargetRegInfo &getRegInfo() const { abort(); } virtual const TargetCacheInfo &getCacheInfo() const { abort(); } - /// addPassesToJITCompile - Add passes to the specified pass manager to - /// implement a fast dynamic compiler for this target. Return true if this is - /// not supported for this target. - /// - virtual bool addPassesToJITCompile(FunctionPassManager &PM); - /// addPassesToEmitMachineCode - Add passes to the specified pass manager to /// get machine code emitted. This uses a MachineCodeEmitter object to handle /// actually outputting the machine code and resolving things like the address @@ -53,14 +54,6 @@ MachineCodeEmitter &MCE); virtual bool addPassesToEmitAssembly(PassManager &PM, std::ostream &Out); - - virtual void replaceMachineCodeForFunction (void *Old, void *New); - - /// getJITStubForFunction - Create or return a stub for the specified - /// function. This stub acts just like the specified function, except that it - /// allows the "address" of the function to be taken without having to - /// generate code for it. - virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE); }; } // End llvm namespace From lattner at cs.uiuc.edu Fri Dec 19 19:23:10 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 19:23:10 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/Sparc/SparcJITInfo.h SparcTargetMachine.cpp SparcTargetMachine.h SparcV9CodeEmitter.cpp Message-ID: <200312200122.TAA24530@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/Sparc: SparcJITInfo.h added (r1.1) SparcTargetMachine.cpp updated: 1.92 -> 1.93 SparcTargetMachine.h updated: 1.1 -> 1.2 SparcV9CodeEmitter.cpp updated: 1.47 -> 1.48 --- Log message: Rip JIT specific stuff out of TargetMachine, as per PR176 --- Diffs of the changes: (+61 -25) Index: llvm/lib/Target/Sparc/SparcJITInfo.h diff -c /dev/null llvm/lib/Target/Sparc/SparcJITInfo.h:1.1 *** /dev/null Fri Dec 19 19:22:09 2003 --- llvm/lib/Target/Sparc/SparcJITInfo.h Fri Dec 19 19:21:59 2003 *************** *** 0 **** --- 1,47 ---- + //===- SparcJITInfo.h - Sparc implementation of the JIT interface -*-C++-*-===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file contains the Sparc implementation of the TargetJITInfo class. + // + //===----------------------------------------------------------------------===// + + #ifndef SPARCJITINFO_H + #define SPARCJITINFO_H + + #include "llvm/Target/TargetJITInfo.h" + + namespace llvm { + class TargetMachine; + class SparcJITInfo : public TargetJITInfo { + TargetMachine &TM; + public: + SparcJITInfo(TargetMachine &tm) : TM(tm) {} + + /// addPassesToJITCompile - Add passes to the specified pass manager to + /// implement a fast dynamic compiler for this target. Return true if this + /// is not supported for this target. + /// + virtual void addPassesToJITCompile(FunctionPassManager &PM); + + /// replaceMachineCodeForFunction - Make it so that calling the function + /// whose machine code is at OLD turns into a call to NEW, perhaps by + /// overwriting OLD with a branch to NEW. This is used for self-modifying + /// code. + /// + virtual void replaceMachineCodeForFunction (void *Old, void *New); + + /// getJITStubForFunction - Create or return a stub for the specified + /// function. This stub acts just like the specified function, except that + /// it allows the "address" of the function to be taken without having to + /// generate code for it. + //virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE); + }; + } + + #endif Index: llvm/lib/Target/Sparc/SparcTargetMachine.cpp diff -u llvm/lib/Target/Sparc/SparcTargetMachine.cpp:1.92 llvm/lib/Target/Sparc/SparcTargetMachine.cpp:1.93 --- llvm/lib/Target/Sparc/SparcTargetMachine.cpp:1.92 Wed Dec 17 16:04:00 2003 +++ llvm/lib/Target/Sparc/SparcTargetMachine.cpp Fri Dec 19 19:21:59 2003 @@ -73,7 +73,8 @@ schedInfo(*this), regInfo(*this), frameInfo(*this), - cacheInfo(*this) { + cacheInfo(*this), + jitInfo(*this) { } // addPassesToEmitAssembly - This method controls the entire code generation @@ -152,8 +153,8 @@ // addPassesToJITCompile - This method controls the JIT method of code // generation for the UltraSparc. // -bool SparcTargetMachine::addPassesToJITCompile(FunctionPassManager &PM) { - const TargetData &TD = getTargetData(); +void SparcJITInfo::addPassesToJITCompile(FunctionPassManager &PM) { + const TargetData &TD = TM.getTargetData(); PM.add(new TargetData("lli", TD.isLittleEndian(), TD.getPointerSize(), TD.getPointerAlignment(), TD.getDoubleAlignment())); @@ -173,11 +174,11 @@ PM.add(createDecomposeMultiDimRefsPass()); // Construct and initialize the MachineFunction object for this fn. - PM.add(createMachineCodeConstructionPass(*this)); + PM.add(createMachineCodeConstructionPass(TM)); // Specialize LLVM code for this target machine and then // run basic dataflow optimizations on LLVM code. - PM.add(createPreSelectionPass(*this)); + PM.add(createPreSelectionPass(TM)); // Run basic dataflow optimizations on LLVM code PM.add(createReassociatePass()); @@ -185,15 +186,13 @@ //PM.add(createLICMPass()); //PM.add(createGCSEPass()); - PM.add(createInstructionSelectionPass(*this)); + PM.add(createInstructionSelectionPass(TM)); - PM.add(getRegisterAllocator(*this)); + PM.add(getRegisterAllocator(TM)); PM.add(createPrologEpilogInsertionPass()); if (!DisablePeephole) - PM.add(createPeepholeOptsPass(*this)); - - return false; // success! + PM.add(createPeepholeOptsPass(TM)); } //---------------------------------------------------------------------------- @@ -201,10 +200,6 @@ // that implements the Sparc backend. (the llvm/CodeGen/Sparc.h interface) //---------------------------------------------------------------------------- -namespace llvm { - -TargetMachine *allocateSparcTargetMachine(const Module &M) { +TargetMachine *llvm::allocateSparcTargetMachine(const Module &M) { return new SparcTargetMachine(); -} - } Index: llvm/lib/Target/Sparc/SparcTargetMachine.h diff -u llvm/lib/Target/Sparc/SparcTargetMachine.h:1.1 llvm/lib/Target/Sparc/SparcTargetMachine.h:1.2 --- llvm/lib/Target/Sparc/SparcTargetMachine.h:1.1 Wed Dec 17 16:04:00 2003 +++ llvm/lib/Target/Sparc/SparcTargetMachine.h Fri Dec 19 19:21:59 2003 @@ -22,6 +22,7 @@ #include "SparcInternals.h" #include "SparcRegInfo.h" #include "SparcFrameInfo.h" +#include "SparcJITInfo.h" namespace llvm { @@ -31,6 +32,7 @@ SparcRegInfo regInfo; SparcFrameInfo frameInfo; SparcCacheInfo cacheInfo; + SparcJITInfo jitInfo; public: SparcTargetMachine(); @@ -39,19 +41,11 @@ virtual const TargetRegInfo &getRegInfo() const { return regInfo; } virtual const TargetFrameInfo &getFrameInfo() const { return frameInfo; } virtual const TargetCacheInfo &getCacheInfo() const { return cacheInfo; } + virtual TargetJITInfo *getJITInfo() { return &jitInfo; } virtual bool addPassesToEmitAssembly(PassManager &PM, std::ostream &Out); - virtual bool addPassesToJITCompile(FunctionPassManager &PM); virtual bool addPassesToEmitMachineCode(FunctionPassManager &PM, MachineCodeEmitter &MCE); - virtual void replaceMachineCodeForFunction(void *Old, void *New); - - /// getJITStubForFunction - Create or return a stub for the specified - /// function. This stub acts just like the specified function, except that it - /// allows the "address" of the function to be taken without having to - /// generate code for it. - /// - ///virtual void *getJITStubForFunction(Function *F, MachineCodeEmitter &MCE); }; } // End llvm namespace Index: llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp diff -u llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp:1.47 llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp:1.48 --- llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp:1.47 Wed Dec 17 16:04:00 2003 +++ llvm/lib/Target/Sparc/SparcV9CodeEmitter.cpp Fri Dec 19 19:21:59 2003 @@ -582,7 +582,7 @@ } } -void SparcTargetMachine::replaceMachineCodeForFunction (void *Old, void *New) { +void SparcJITInfo::replaceMachineCodeForFunction (void *Old, void *New) { assert (TheJITResolver && "Can only call replaceMachineCodeForFunction from within JIT"); uint64_t Target = (uint64_t)(intptr_t)New; From lattner at cs.uiuc.edu Fri Dec 19 19:23:19 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 19:23:19 2003 Subject: [llvm-commits] CVS: llvm/lib/ExecutionEngine/JIT/JIT.cpp VM.cpp VM.h Message-ID: <200312200122.TAA24562@zion.cs.uiuc.edu> Changes in directory llvm/lib/ExecutionEngine/JIT: JIT.cpp updated: 1.26 -> 1.27 VM.cpp updated: 1.16 -> 1.17 VM.h updated: 1.18 -> 1.19 --- Log message: Rip JIT specific stuff out of TargetMachine, as per PR176 --- Diffs of the changes: (+16 -15) Index: llvm/lib/ExecutionEngine/JIT/JIT.cpp diff -u llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.26 llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.27 --- llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.26 Mon Dec 8 02:06:28 2003 +++ llvm/lib/ExecutionEngine/JIT/JIT.cpp Fri Dec 19 19:22:19 2003 @@ -80,19 +80,20 @@ // Allocate a target... TargetMachine *Target = TargetMachineAllocator(*MP->getModule()); assert(Target && "Could not allocate target machine!"); - - // Create the virtual machine object... - return new VM(MP, Target); + + // If the target supports JIT code generation, return a new JIT now. + if (TargetJITInfo *TJ = Target->getJITInfo()) + return new VM(MP, *Target, *TJ); + return 0; } -VM::VM(ModuleProvider *MP, TargetMachine *tm) : ExecutionEngine(MP), TM(*tm), - PM(MP) -{ +VM::VM(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji) + : ExecutionEngine(MP), TM(tm), TJI(tji), PM(MP) { setTargetData(TM.getTargetData()); // Initialize MCE MCE = createEmitter(*this); - + setupPassManager(); emitGlobals(); Index: llvm/lib/ExecutionEngine/JIT/VM.cpp diff -u llvm/lib/ExecutionEngine/JIT/VM.cpp:1.16 llvm/lib/ExecutionEngine/JIT/VM.cpp:1.17 --- llvm/lib/ExecutionEngine/JIT/VM.cpp:1.16 Fri Dec 12 01:12:02 2003 +++ llvm/lib/ExecutionEngine/JIT/VM.cpp Fri Dec 19 19:22:19 2003 @@ -18,6 +18,7 @@ #include "llvm/CodeGen/MachineCodeEmitter.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/Target/TargetMachine.h" +#include "llvm/Target/TargetJITInfo.h" using namespace llvm; VM::~VM() { @@ -30,11 +31,7 @@ /// void VM::setupPassManager() { // Compile LLVM Code down to machine code in the intermediate representation - if (TM.addPassesToJITCompile(PM)) { - std::cerr << "lli: target '" << TM.getName() - << "' doesn't support JIT compilation!\n"; - abort(); - } + TJI.addPassesToJITCompile(PM); // Turn the machine code intermediate representation into bytes in memory that // may be executed. @@ -87,7 +84,7 @@ if (I != GlobalAddress.end()) return I->second; // If the target supports "stubs" for functions, get a stub now. - if (void *Ptr = TM.getJITStubForFunction(F, *MCE)) + if (void *Ptr = TJI.getJITStubForFunction(F, *MCE)) return Ptr; // Otherwise, if the target doesn't support it, just codegen the function. @@ -112,6 +109,6 @@ MachineFunction::destruct(F); runJITOnFunction(F); assert(Addr && "Code generation didn't add function to GlobalAddress table!"); - TM.replaceMachineCodeForFunction(OldAddr, Addr); + TJI.replaceMachineCodeForFunction(OldAddr, Addr); return Addr; } Index: llvm/lib/ExecutionEngine/JIT/VM.h diff -u llvm/lib/ExecutionEngine/JIT/VM.h:1.18 llvm/lib/ExecutionEngine/JIT/VM.h:1.19 --- llvm/lib/ExecutionEngine/JIT/VM.h:1.18 Fri Dec 12 01:12:02 2003 +++ llvm/lib/ExecutionEngine/JIT/VM.h Fri Dec 19 19:22:19 2003 @@ -24,15 +24,18 @@ class GlobalValue; class Constant; class TargetMachine; +class TargetJITInfo; class MachineCodeEmitter; class VM : public ExecutionEngine { TargetMachine &TM; // The current target we are compiling to + TargetJITInfo &TJI; // The JITInfo for the target we are compiling to + FunctionPassManager PM; // Passes to compile a function MachineCodeEmitter *MCE; // MCE object + VM(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji); public: - VM(ModuleProvider *MP, TargetMachine *tm); ~VM(); /// create - Create an return a new JIT compiler if there is one available From lattner at cs.uiuc.edu Fri Dec 19 19:46:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 19:46:01 2003 Subject: [llvm-commits] CVS: llvm/lib/ExecutionEngine/ExecutionEngine.cpp Message-ID: <200312200145.TAA27517@zion.cs.uiuc.edu> Changes in directory llvm/lib/ExecutionEngine: ExecutionEngine.cpp updated: 1.39 -> 1.40 --- Log message: Update for changes in the JIT --- Diffs of the changes: (+2 -2) Index: llvm/lib/ExecutionEngine/ExecutionEngine.cpp diff -u llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.39 llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.40 --- llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.39 Mon Dec 8 02:22:48 2003 +++ llvm/lib/ExecutionEngine/ExecutionEngine.cpp Fri Dec 19 19:45:17 2003 @@ -14,7 +14,7 @@ #define DEBUG_TYPE "jit" #include "Interpreter/Interpreter.h" -#include "JIT/VM.h" +#include "JIT/JIT.h" #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" #include "llvm/Module.h" @@ -55,7 +55,7 @@ // Unless the interpreter was explicitly selected, make a JIT. if (!ForceInterpreter) - EE = VM::create(MP); + EE = JIT::create(MP); // If we can't make a JIT, make an interpreter instead. try { From lattner at cs.uiuc.edu Fri Dec 19 19:47:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 19:47:01 2003 Subject: [llvm-commits] CVS: llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp Emitter.cpp Intercept.cpp JIT.cpp JIT.h VM.cpp VM.h Message-ID: <200312200146.TAA27541@zion.cs.uiuc.edu> Changes in directory llvm/lib/ExecutionEngine/JIT: TargetSelect.cpp added (r1.1) Emitter.cpp updated: 1.36 -> 1.37 Intercept.cpp updated: 1.11 -> 1.12 JIT.cpp updated: 1.27 -> 1.28 JIT.h updated: 1.19 -> 1.20 VM.cpp (r1.17) removed VM.h (r1.19) removed --- Log message: Cleanup the JIT as per PR176. This renames the VM class to JIT, and merges the VM.cpp and JIT.cpp files into JIT.cpp. This also splits some nasty code out into TargetSelect.cpp so that people hopefully won't notice it. :) --- Diffs of the changes: (+217 -107) Index: llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp diff -c /dev/null llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp:1.1 *** /dev/null Fri Dec 19 19:46:37 2003 --- llvm/lib/ExecutionEngine/JIT/TargetSelect.cpp Fri Dec 19 19:46:27 2003 *************** *** 0 **** --- 1,92 ---- + //===-- TargetSelect.cpp - Target Chooser Code ----------------------------===// + // + // The LLVM Compiler Infrastructure + // + // This file was developed by the LLVM research group and is distributed under + // the University of Illinois Open Source License. See LICENSE.TXT for details. + // + //===----------------------------------------------------------------------===// + // + // This file contains the hideously gross code that is currently used to select + // a particular TargetMachine for the JIT to use. This should obviously be + // improved in the future, probably by having the TargetMachines register + // themselves with the runtime, and then have them choose themselves if they + // match the current machine. + // + //===----------------------------------------------------------------------===// + + #include "JIT.h" + #include "llvm/Module.h" + #include "llvm/ModuleProvider.h" + #include "llvm/Target/TargetMachine.h" + #include "llvm/Target/TargetMachineImpls.h" + #include "Support/CommandLine.h" + using namespace llvm; + + #if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT) + #define NO_JITS_ENABLED + #endif + + namespace { + enum ArchName { x86, Sparc }; + + #ifndef NO_JITS_ENABLED + cl::opt + Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix, + cl::values( + #ifdef ENABLE_X86_JIT + clEnumVal(x86, " IA-32 (Pentium and above)"), + #endif + #ifdef ENABLE_SPARC_JIT + clEnumValN(Sparc, "sparc", " Sparc-V9"), + #endif + 0), + #if defined(ENABLE_X86_JIT) + cl::init(x86) + #elif defined(ENABLE_SPARC_JIT) + cl::init(Sparc) + #endif + ); + #endif /* NO_JITS_ENABLED */ + } + + /// create - Create an return a new JIT compiler if there is one available + /// for the current target. Otherwise, return null. + /// + ExecutionEngine *JIT::create(ModuleProvider *MP) { + TargetMachine* (*TargetMachineAllocator)(const Module &) = 0; + + // Allow a command-line switch to override what *should* be the default target + // machine for this platform. This allows for debugging a Sparc JIT on X86 -- + // our X86 machines are much faster at recompiling LLVM and linking LLI. + #ifndef NO_JITS_ENABLED + + switch (Arch) { + #ifdef ENABLE_X86_JIT + case x86: + TargetMachineAllocator = allocateX86TargetMachine; + break; + #endif + #ifdef ENABLE_SPARC_JIT + case Sparc: + TargetMachineAllocator = allocateSparcTargetMachine; + break; + #endif + default: + assert(0 && "-march flag not supported on this host!"); + } + #else + return 0; + #endif + + // Allocate a target... + TargetMachine *Target = TargetMachineAllocator(*MP->getModule()); + assert(Target && "Could not allocate target machine!"); + + // If the target supports JIT code generation, return a new JIT now. + if (TargetJITInfo *TJ = Target->getJITInfo()) + return new JIT(MP, *Target, *TJ); + return 0; + } + + Index: llvm/lib/ExecutionEngine/JIT/Emitter.cpp diff -u llvm/lib/ExecutionEngine/JIT/Emitter.cpp:1.36 llvm/lib/ExecutionEngine/JIT/Emitter.cpp:1.37 --- llvm/lib/ExecutionEngine/JIT/Emitter.cpp:1.36 Mon Dec 8 02:06:28 2003 +++ llvm/lib/ExecutionEngine/JIT/Emitter.cpp Fri Dec 19 19:46:27 2003 @@ -16,7 +16,7 @@ #ifndef _POSIX_MAPPED_FILES #define _POSIX_MAPPED_FILES #endif -#include "VM.h" +#include "JIT.h" #include "llvm/Constant.h" #include "llvm/Module.h" #include "llvm/CodeGen/MachineCodeEmitter.h" @@ -31,7 +31,7 @@ namespace { Statistic<> NumBytes("jit", "Number of bytes of machine code compiled"); - VM *TheVM = 0; + JIT *TheJIT = 0; /// JITMemoryManager - Manage memory for the JIT code generation in a logical, /// sane way. This splits a large block of MAP_NORESERVE'd memory into two @@ -142,7 +142,7 @@ // constant pool. std::vector ConstantPoolAddresses; public: - Emitter(VM &vm) { TheVM = &vm; } + Emitter(JIT &jit) { TheJIT = &jit; } virtual void startFunction(MachineFunction &F); virtual void finishFunction(MachineFunction &F); @@ -166,13 +166,13 @@ }; } -MachineCodeEmitter *VM::createEmitter(VM &V) { - return new Emitter(V); +MachineCodeEmitter *JIT::createEmitter(JIT &jit) { + return new Emitter(jit); } void Emitter::startFunction(MachineFunction &F) { CurByte = CurBlock = MemMgr.startFunctionBody(); - TheVM->addGlobalMapping(F.getFunction(), CurBlock); + TheJIT->addGlobalMapping(F.getFunction(), CurBlock); } void Emitter::finishFunction(MachineFunction &F) { @@ -197,8 +197,8 @@ unsigned TotalSize = 0; for (unsigned i = 0, e = Constants.size(); i != e; ++i) { const Type *Ty = Constants[i]->getType(); - unsigned Size = TheVM->getTargetData().getTypeSize(Ty); - unsigned Alignment = TheVM->getTargetData().getTypeAlignment(Ty); + unsigned Size = TheJIT->getTargetData().getTypeSize(Ty); + unsigned Alignment = TheJIT->getTargetData().getTypeAlignment(Ty); // Make sure to take into account the alignment requirements of the type. TotalSize = (TotalSize + Alignment-1) & ~(Alignment-1); @@ -213,7 +213,7 @@ // Actually output all of the constants, and remember their addresses. for (unsigned i = 0, e = Constants.size(); i != e; ++i) { void *Addr = Pool + ConstantOffset[i]; - TheVM->InitializeMemory(Constants[i], Addr); + TheJIT->InitializeMemory(Constants[i], Addr); ConstantPoolAddresses.push_back(Addr); } } @@ -248,10 +248,10 @@ uint64_t Emitter::getGlobalValueAddress(GlobalValue *V) { // Try looking up the function to see if it is already compiled, if not return // 0. - return (intptr_t)TheVM->getPointerToGlobalIfAvailable(V); + return (intptr_t)TheJIT->getPointerToGlobalIfAvailable(V); } uint64_t Emitter::getGlobalValueAddress(const std::string &Name) { - return (intptr_t)TheVM->getPointerToNamedFunction(Name); + return (intptr_t)TheJIT->getPointerToNamedFunction(Name); } // getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry @@ -272,19 +272,19 @@ } uint64_t Emitter::forceCompilationOf(Function *F) { - return (intptr_t)TheVM->getPointerToFunction(F); + return (intptr_t)TheJIT->getPointerToFunction(F); } // getPointerToNamedFunction - This function is used as a global wrapper to -// VM::getPointerToNamedFunction for the purpose of resolving symbols when +// JIT::getPointerToNamedFunction for the purpose of resolving symbols when // bugpoint is debugging the JIT. In that scenario, we are loading an .so and // need to resolve function(s) that are being mis-codegenerated, so we need to // resolve their addresses at runtime, and this is the way to do it. extern "C" { void *getPointerToNamedFunction(const char *Name) { - Module &M = TheVM->getModule(); + Module &M = TheJIT->getModule(); if (Function *F = M.getNamedFunction(Name)) - return TheVM->getPointerToFunction(F); - return TheVM->getPointerToNamedFunction(Name); + return TheJIT->getPointerToFunction(F); + return TheJIT->getPointerToNamedFunction(Name); } } Index: llvm/lib/ExecutionEngine/JIT/Intercept.cpp diff -u llvm/lib/ExecutionEngine/JIT/Intercept.cpp:1.11 llvm/lib/ExecutionEngine/JIT/Intercept.cpp:1.12 --- llvm/lib/ExecutionEngine/JIT/Intercept.cpp:1.11 Mon Dec 8 02:06:28 2003 +++ llvm/lib/ExecutionEngine/JIT/Intercept.cpp Fri Dec 19 19:46:27 2003 @@ -15,7 +15,7 @@ // //===----------------------------------------------------------------------===// -#include "VM.h" +#include "JIT.h" #include "Support/DynamicLinker.h" #include using namespace llvm; @@ -28,7 +28,7 @@ /// calls to atexit(3), which we intercept and store in /// AtExitHandlers. /// -void VM::runAtExitHandlers() { +void JIT::runAtExitHandlers() { while (!AtExitHandlers.empty()) { void (*Fn)() = AtExitHandlers.back(); AtExitHandlers.pop_back(); @@ -45,7 +45,7 @@ // jit_exit - Used to intercept the "exit" library call. static void jit_exit(int Status) { - VM::runAtExitHandlers(); // Run atexit handlers... + JIT::runAtExitHandlers(); // Run atexit handlers... exit(Status); } @@ -61,7 +61,7 @@ /// function by using the dynamic loader interface. As such it is only useful /// for resolving library symbols, not code generated symbols. /// -void *VM::getPointerToNamedFunction(const std::string &Name) { +void *JIT::getPointerToNamedFunction(const std::string &Name) { // Check to see if this is one of the functions we want to intercept... if (Name == "exit") return (void*)&jit_exit; if (Name == "atexit") return (void*)&jit_atexit; Index: llvm/lib/ExecutionEngine/JIT/JIT.cpp diff -u llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.27 llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.28 --- llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.27 Fri Dec 19 19:22:19 2003 +++ llvm/lib/ExecutionEngine/JIT/JIT.cpp Fri Dec 19 19:46:27 2003 @@ -1,4 +1,4 @@ -//===-- JIT.cpp - LLVM Just-In-Time Compiler ------------------------------===// +//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===// // // The LLVM Compiler Infrastructure // @@ -7,102 +7,50 @@ // //===----------------------------------------------------------------------===// // -// This file implements the top-level support for creating a Just-In-Time -// compiler for the current architecture. +// This tool implements a just-in-time compiler for LLVM, allowing direct +// execution of LLVM bytecode in an efficient manner. // //===----------------------------------------------------------------------===// -#include "VM.h" -#include "llvm/Module.h" +#include "JIT.h" +#include "llvm/Function.h" #include "llvm/ModuleProvider.h" +#include "llvm/CodeGen/MachineCodeEmitter.h" +#include "llvm/CodeGen/MachineFunction.h" #include "llvm/ExecutionEngine/GenericValue.h" #include "llvm/Target/TargetMachine.h" -#include "llvm/Target/TargetMachineImpls.h" -#include "Support/CommandLine.h" +#include "llvm/Target/TargetJITInfo.h" using namespace llvm; -#if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT) -#define NO_JITS_ENABLED -#endif - -namespace { - enum ArchName { x86, Sparc }; - -#ifndef NO_JITS_ENABLED - cl::opt - Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix, - cl::values( -#ifdef ENABLE_X86_JIT - clEnumVal(x86, " IA-32 (Pentium and above)"), -#endif -#ifdef ENABLE_SPARC_JIT - clEnumValN(Sparc, "sparc", " Sparc-V9"), -#endif - 0), -#if defined(ENABLE_X86_JIT) - cl::init(x86) -#elif defined(ENABLE_SPARC_JIT) - cl::init(Sparc) -#endif - ); -#endif /* NO_JITS_ENABLED */ -} - -/// create - Create an return a new JIT compiler if there is one available -/// for the current target. Otherwise, return null. -/// -ExecutionEngine *VM::create(ModuleProvider *MP) { - TargetMachine* (*TargetMachineAllocator)(const Module &) = 0; - - // Allow a command-line switch to override what *should* be the default target - // machine for this platform. This allows for debugging a Sparc JIT on X86 -- - // our X86 machines are much faster at recompiling LLVM and linking LLI. -#ifndef NO_JITS_ENABLED - - switch (Arch) { -#ifdef ENABLE_X86_JIT - case x86: - TargetMachineAllocator = allocateX86TargetMachine; - break; -#endif -#ifdef ENABLE_SPARC_JIT - case Sparc: - TargetMachineAllocator = allocateSparcTargetMachine; - break; -#endif - default: - assert(0 && "-march flag not supported on this host!"); - } -#else - return 0; -#endif - - // Allocate a target... - TargetMachine *Target = TargetMachineAllocator(*MP->getModule()); - assert(Target && "Could not allocate target machine!"); - - // If the target supports JIT code generation, return a new JIT now. - if (TargetJITInfo *TJ = Target->getJITInfo()) - return new VM(MP, *Target, *TJ); - return 0; -} - -VM::VM(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji) +JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji) : ExecutionEngine(MP), TM(tm), TJI(tji), PM(MP) { setTargetData(TM.getTargetData()); // Initialize MCE MCE = createEmitter(*this); - setupPassManager(); + // Compile LLVM Code down to machine code in the intermediate representation + TJI.addPassesToJITCompile(PM); + + // Turn the machine code intermediate representation into bytes in memory that + // may be executed. + if (TM.addPassesToEmitMachineCode(PM, *MCE)) { + std::cerr << "lli: target '" << TM.getName() + << "' doesn't support machine code emission!\n"; + abort(); + } emitGlobals(); } +JIT::~JIT() { + delete MCE; + delete &TM; +} + /// run - Start execution with the specified function and arguments. /// -GenericValue VM::run(Function *F, const std::vector &ArgValues) -{ +GenericValue JIT::run(Function *F, const std::vector &ArgValues) { assert (F && "Function *F was null at entry to run()"); int (*PF)(int, char **, const char **) = @@ -119,4 +67,75 @@ GenericValue rv; rv.IntVal = ExitCode; return rv; +} + +/// runJITOnFunction - Run the FunctionPassManager full of +/// just-in-time compilation passes on F, hopefully filling in +/// GlobalAddress[F] with the address of F's machine code. +/// +void JIT::runJITOnFunction(Function *F) { + static bool isAlreadyCodeGenerating = false; + assert(!isAlreadyCodeGenerating && "Error: Recursive compilation detected!"); + + // JIT the function + isAlreadyCodeGenerating = true; + PM.run(*F); + isAlreadyCodeGenerating = false; +} + +/// getPointerToFunction - This method is used to get the address of the +/// specified function, compiling it if neccesary. +/// +void *JIT::getPointerToFunction(Function *F) { + void *&Addr = GlobalAddress[F]; // Check if function already code gen'd + if (Addr) return Addr; + + // Make sure we read in the function if it exists in this Module + MP->materializeFunction(F); + + if (F->isExternal()) + return Addr = getPointerToNamedFunction(F->getName()); + + runJITOnFunction(F); + assert(Addr && "Code generation didn't add function to GlobalAddress table!"); + return Addr; +} + +// getPointerToFunctionOrStub - If the specified function has been +// code-gen'd, return a pointer to the function. If not, compile it, or use +// a stub to implement lazy compilation if available. +// +void *JIT::getPointerToFunctionOrStub(Function *F) { + // If we have already code generated the function, just return the address. + std::map::iterator I = GlobalAddress.find(F); + if (I != GlobalAddress.end()) return I->second; + + // If the target supports "stubs" for functions, get a stub now. + if (void *Ptr = TJI.getJITStubForFunction(F, *MCE)) + return Ptr; + + // Otherwise, if the target doesn't support it, just codegen the function. + return getPointerToFunction(F); +} + +/// recompileAndRelinkFunction - This method is used to force a function +/// which has already been compiled, to be compiled again, possibly +/// after it has been modified. Then the entry to the old copy is overwritten +/// with a branch to the new copy. If there was no old copy, this acts +/// just like JIT::getPointerToFunction(). +/// +void *JIT::recompileAndRelinkFunction(Function *F) { + void *&Addr = GlobalAddress[F]; // Check if function already code gen'd + + // If it's not already compiled (this is kind of weird) there is no + // reason to patch it up. + if (!Addr) { return getPointerToFunction (F); } + + void *OldAddr = Addr; + Addr = 0; + MachineFunction::destruct(F); + runJITOnFunction(F); + assert(Addr && "Code generation didn't add function to GlobalAddress table!"); + TJI.replaceMachineCodeForFunction(OldAddr, Addr); + return Addr; } Index: llvm/lib/ExecutionEngine/JIT/JIT.h diff -u llvm/lib/ExecutionEngine/JIT/JIT.h:1.19 llvm/lib/ExecutionEngine/JIT/JIT.h:1.20 --- llvm/lib/ExecutionEngine/JIT/JIT.h:1.19 Fri Dec 19 19:22:19 2003 +++ llvm/lib/ExecutionEngine/JIT/JIT.h Fri Dec 19 19:46:27 2003 @@ -1,4 +1,4 @@ -//===-- VM.h - Definitions for Virtual Machine ------------------*- C++ -*-===// +//===-- JIT.h - Class definition for the JIT --------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,12 +7,12 @@ // //===----------------------------------------------------------------------===// // -// This file defines the top-level Virtual Machine data structure. +// This file defines the top-level JIT data structure. // //===----------------------------------------------------------------------===// -#ifndef VM_H -#define VM_H +#ifndef JIT_H +#define JIT_H #include "llvm/ExecutionEngine/ExecutionEngine.h" #include "llvm/PassManager.h" @@ -27,16 +27,16 @@ class TargetJITInfo; class MachineCodeEmitter; -class VM : public ExecutionEngine { +class JIT : public ExecutionEngine { TargetMachine &TM; // The current target we are compiling to TargetJITInfo &TJI; // The JITInfo for the target we are compiling to FunctionPassManager PM; // Passes to compile a function MachineCodeEmitter *MCE; // MCE object - VM(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji); + JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji); public: - ~VM(); + ~JIT(); /// create - Create an return a new JIT compiler if there is one available /// for the current target. Otherwise, return null. @@ -79,13 +79,12 @@ /// which has already been compiled, to be compiled again, possibly /// after it has been modified. Then the entry to the old copy is overwritten /// with a branch to the new copy. If there was no old copy, this acts - /// just like VM::getPointerToFunction(). + /// just like JIT::getPointerToFunction(). /// void *recompileAndRelinkFunction(Function *F); private: - static MachineCodeEmitter *createEmitter(VM &V); - void setupPassManager(); + static MachineCodeEmitter *createEmitter(JIT &J); void runJITOnFunction (Function *F); }; From lattner at cs.uiuc.edu Fri Dec 19 20:04:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 20:04:01 2003 Subject: [llvm-commits] CVS: llvm/lib/Target/X86/X86CodeEmitter.cpp Message-ID: <200312200203.UAA28188@zion.cs.uiuc.edu> Changes in directory llvm/lib/Target/X86: X86CodeEmitter.cpp updated: 1.43 -> 1.44 --- Log message: A minor cleanup for better encapsulation --- Diffs of the changes: (+13 -12) Index: llvm/lib/Target/X86/X86CodeEmitter.cpp diff -u llvm/lib/Target/X86/X86CodeEmitter.cpp:1.43 llvm/lib/Target/X86/X86CodeEmitter.cpp:1.44 --- llvm/lib/Target/X86/X86CodeEmitter.cpp:1.43 Fri Dec 19 19:22:04 2003 +++ llvm/lib/Target/X86/X86CodeEmitter.cpp Fri Dec 19 20:03:14 2003 @@ -50,13 +50,17 @@ unsigned resolveFunctionReference(unsigned RetAddr); }; - JITResolver *TheJITResolver; + static JITResolver &getResolver(MachineCodeEmitter &MCE) { + static JITResolver *TheJITResolver = 0; + if (TheJITResolver == 0) + TheJITResolver = new JITResolver(MCE); + return *TheJITResolver; + } } + void *X86JITInfo::getJITStubForFunction(Function *F, MachineCodeEmitter &MCE) { - if (TheJITResolver == 0) - TheJITResolver = new JITResolver(MCE); - return (void*)((unsigned long)TheJITResolver->getLazyResolver(F)); + return (void*)((unsigned long)getResolver(MCE).getLazyResolver(F)); } void X86JITInfo::replaceMachineCodeForFunction (void *Old, void *New) { @@ -126,7 +130,8 @@ // Sanity check to make sure this really is a call instruction... assert(((unsigned char*)(intptr_t)RetAddr)[-1] == 0xE8 &&"Not a call instr!"); - unsigned NewVal = TheJITResolver->resolveFunctionReference(RetAddr); + JITResolver &JR = getResolver(*(MachineCodeEmitter*)0); + unsigned NewVal = JR.resolveFunctionReference(RetAddr); // Rewrite the call target... so that we don't fault every time we execute // the call. @@ -267,10 +272,8 @@ if (Address == 0) { // FIXME: this is JIT specific! - if (TheJITResolver == 0) - TheJITResolver = new JITResolver(MCE); - Address = TheJITResolver->addFunctionReference(MCE.getCurrentPCValue(), - cast(GV)); + Address = getResolver(MCE).addFunctionReference(MCE.getCurrentPCValue(), + cast(GV)); } emitMaybePCRelativeValue(Address, true); } @@ -288,9 +291,7 @@ // if (Address == 0) { // FIXME: this is JIT specific! - if (TheJITResolver == 0) - TheJITResolver = new JITResolver(MCE); - Address = TheJITResolver->getLazyResolver((Function*)GV); + Address = getResolver(MCE).getLazyResolver((Function*)GV); } emitMaybePCRelativeValue(Address, false); From lattner at cs.uiuc.edu Fri Dec 19 20:46:02 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 20:46:02 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/ExecutionEngine/ExecutionEngine.h Message-ID: <200312200245.UAA32317@zion.cs.uiuc.edu> Changes in directory llvm/include/llvm/ExecutionEngine: ExecutionEngine.h updated: 1.20 -> 1.21 --- Log message: Simple refactorings to prepare for lazy global emission --- Diffs of the changes: (+10 -3) Index: llvm/include/llvm/ExecutionEngine/ExecutionEngine.h diff -u llvm/include/llvm/ExecutionEngine/ExecutionEngine.h:1.20 llvm/include/llvm/ExecutionEngine/ExecutionEngine.h:1.21 --- llvm/include/llvm/ExecutionEngine/ExecutionEngine.h:1.20 Fri Dec 12 00:31:42 2003 +++ llvm/include/llvm/ExecutionEngine/ExecutionEngine.h Fri Dec 19 20:45:16 2003 @@ -21,9 +21,10 @@ namespace llvm { +union GenericValue; class Constant; class Function; -union GenericValue; +class GlobalVariable; class GlobalValue; class Module; class ModuleProvider; @@ -60,8 +61,8 @@ static ExecutionEngine *create(ModuleProvider *MP, bool ForceInterpreter); - void addGlobalMapping(const Function *F, void *Addr) { - void *&CurVal = GlobalAddress[(const GlobalValue*)F]; + void addGlobalMapping(const GlobalValue *GV, void *Addr) { + void *&CurVal = GlobalAddress[GV]; assert(CurVal == 0 && "GlobalMapping already established!"); CurVal = Addr; } @@ -107,6 +108,12 @@ protected: void emitGlobals(); + + // EmitGlobalVariable - This method emits the specified global variable to the + // address specified in GlobalAddresses, or allocates new memory if it's not + // already in the map. + void EmitGlobalVariable(GlobalVariable *GV); + GenericValue getConstantValue(const Constant *C); GenericValue LoadValueFromMemory(GenericValue *Ptr, const Type *Ty); }; From lattner at cs.uiuc.edu Fri Dec 19 20:46:11 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 20:46:11 2003 Subject: [llvm-commits] CVS: llvm/lib/ExecutionEngine/ExecutionEngine.cpp Message-ID: <200312200245.UAA32327@zion.cs.uiuc.edu> Changes in directory llvm/lib/ExecutionEngine: ExecutionEngine.cpp updated: 1.40 -> 1.41 --- Log message: Simple refactorings to prepare for lazy global emission Also, add a stat for the number of globals emitted --- Diffs of the changes: (+16 -2) Index: llvm/lib/ExecutionEngine/ExecutionEngine.cpp diff -u llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.40 llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.41 --- llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.40 Fri Dec 19 19:45:17 2003 +++ llvm/lib/ExecutionEngine/ExecutionEngine.cpp Fri Dec 19 20:45:37 2003 @@ -30,6 +30,7 @@ namespace { Statistic<> NumInitBytes("lli", "Number of bytes of global vars initialized"); + Statistic<> NumGlobals ("lli", "Number of global vars initialized"); } ExecutionEngine::ExecutionEngine(ModuleProvider *P) : @@ -372,7 +373,7 @@ // Allocate some memory for it! unsigned Size = TD.getTypeSize(Ty); - GlobalAddress[I] = new char[Size]; + addGlobalMapping(I, new char[Size]); NumInitBytes += Size; DEBUG(std::cerr << "Global '" << I->getName() << "' -> " @@ -394,5 +395,18 @@ for (Module::giterator I = getModule().gbegin(), E = getModule().gend(); I != E; ++I) if (!I->isExternal()) - InitializeMemory(I->getInitializer(), GlobalAddress[I]); + EmitGlobalVariable(I); +} + +// EmitGlobalVariable - This method emits the specified global variable to the +// address specified in GlobalAddresses, or allocates new memory if it's not +// already in the map. +void ExecutionEngine::EmitGlobalVariable(GlobalVariable *GV) { + void *&GA = GlobalAddress[GV]; + if (GA == 0) { + // If it's not already specified, allocate memory for the global. + GA = new char[getTargetData().getTypeSize(GV->getType()->getElementType())]; + } + InitializeMemory(GV->getInitializer(), GA); + ++NumGlobals; } From lattner at cs.uiuc.edu Fri Dec 19 21:37:01 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 21:37:01 2003 Subject: [llvm-commits] CVS: llvm/include/llvm/ExecutionEngine/ExecutionEngine.h Message-ID: <200312200336.VAA10317@zion.cs.uiuc.edu> Changes in directory llvm/include/llvm/ExecutionEngine: ExecutionEngine.h updated: 1.21 -> 1.22 --- Log message: Cleanups to implement PR135 --- Diffs of the changes: (+11 -4) Index: llvm/include/llvm/ExecutionEngine/ExecutionEngine.h diff -u llvm/include/llvm/ExecutionEngine/ExecutionEngine.h:1.21 llvm/include/llvm/ExecutionEngine/ExecutionEngine.h:1.22 --- llvm/include/llvm/ExecutionEngine/ExecutionEngine.h:1.21 Fri Dec 19 20:45:16 2003 +++ llvm/include/llvm/ExecutionEngine/ExecutionEngine.h Fri Dec 19 21:35:50 2003 @@ -35,11 +35,11 @@ Module &CurMod; const TargetData *TD; -protected: - ModuleProvider *MP; // GlobalAddress - A mapping between LLVM global values and their actualized // version... std::map GlobalAddress; +protected: + ModuleProvider *MP; void setTargetData(const TargetData &td) { TD = &td; @@ -63,7 +63,7 @@ void addGlobalMapping(const GlobalValue *GV, void *Addr) { void *&CurVal = GlobalAddress[GV]; - assert(CurVal == 0 && "GlobalMapping already established!"); + assert((CurVal == 0 || Addr == 0) && "GlobalMapping already established!"); CurVal = Addr; } @@ -106,13 +106,20 @@ /// virtual void *recompileAndRelinkFunction(Function *F) = 0; + /// getOrEmitGlobalVariable - Return the address of the specified global + /// variable, possibly emitting it to memory if needed. This is used by the + /// Emitter. + virtual void *getOrEmitGlobalVariable(const GlobalVariable *GV) { + return getPointerToGlobal((GlobalValue*)GV); + } + protected: void emitGlobals(); // EmitGlobalVariable - This method emits the specified global variable to the // address specified in GlobalAddresses, or allocates new memory if it's not // already in the map. - void EmitGlobalVariable(GlobalVariable *GV); + void EmitGlobalVariable(const GlobalVariable *GV); GenericValue getConstantValue(const Constant *C); GenericValue LoadValueFromMemory(GenericValue *Ptr, const Type *Ty); From lattner at cs.uiuc.edu Fri Dec 19 21:37:11 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 21:37:11 2003 Subject: [llvm-commits] CVS: llvm/lib/ExecutionEngine/JIT/Emitter.cpp JIT.cpp JIT.h Message-ID: <200312200336.VAA10444@zion.cs.uiuc.edu> Changes in directory llvm/lib/ExecutionEngine/JIT: Emitter.cpp updated: 1.37 -> 1.38 JIT.cpp updated: 1.28 -> 1.29 JIT.h updated: 1.20 -> 1.21 --- Log message: Implement PR135, lazy emission of global variables --- Diffs of the changes: (+78 -15) Index: llvm/lib/ExecutionEngine/JIT/Emitter.cpp diff -u llvm/lib/ExecutionEngine/JIT/Emitter.cpp:1.37 llvm/lib/ExecutionEngine/JIT/Emitter.cpp:1.38 --- llvm/lib/ExecutionEngine/JIT/Emitter.cpp:1.37 Fri Dec 19 19:46:27 2003 +++ llvm/lib/ExecutionEngine/JIT/Emitter.cpp Fri Dec 19 21:36:47 2003 @@ -248,7 +248,11 @@ uint64_t Emitter::getGlobalValueAddress(GlobalValue *V) { // Try looking up the function to see if it is already compiled, if not return // 0. - return (intptr_t)TheJIT->getPointerToGlobalIfAvailable(V); + if (isa(V)) + return (intptr_t)TheJIT->getPointerToGlobalIfAvailable(V); + else { + return (intptr_t)TheJIT->getOrEmitGlobalVariable(cast(V)); + } } uint64_t Emitter::getGlobalValueAddress(const std::string &Name) { return (intptr_t)TheJIT->getPointerToNamedFunction(Name); Index: llvm/lib/ExecutionEngine/JIT/JIT.cpp diff -u llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.28 llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.29 --- llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.28 Fri Dec 19 19:46:27 2003 +++ llvm/lib/ExecutionEngine/JIT/JIT.cpp Fri Dec 19 21:36:47 2003 @@ -13,13 +13,16 @@ //===----------------------------------------------------------------------===// #include "JIT.h" +#include "llvm/DerivedTypes.h" #include "llvm/Function.h" +#include "llvm/GlobalVariable.h" #include "llvm/ModuleProvider.h" #include "llvm/CodeGen/MachineCodeEmitter.h" #include "llvm/CodeGen/MachineFunction.h" #include "llvm/ExecutionEngine/GenericValue.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetJITInfo.h" +#include "Support/DynamicLinker.h" using namespace llvm; JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji) @@ -39,8 +42,6 @@ << "' doesn't support machine code emission!\n"; abort(); } - - emitGlobals(); } JIT::~JIT() { @@ -81,22 +82,36 @@ isAlreadyCodeGenerating = true; PM.run(*F); isAlreadyCodeGenerating = false; + + // If the function referred to a global variable that had not yet been + // emitted, it allocates memory for the global, but doesn't emit it yet. Emit + // all of these globals now. + while (!PendingGlobals.empty()) { + const GlobalVariable *GV = PendingGlobals.back(); + PendingGlobals.pop_back(); + EmitGlobalVariable(GV); + } } /// getPointerToFunction - This method is used to get the address of the /// specified function, compiling it if neccesary. /// void *JIT::getPointerToFunction(Function *F) { - void *&Addr = GlobalAddress[F]; // Check if function already code gen'd - if (Addr) return Addr; + if (void *Addr = getPointerToGlobalIfAvailable(F)) + return Addr; // Check if function already code gen'd // Make sure we read in the function if it exists in this Module MP->materializeFunction(F); - if (F->isExternal()) - return Addr = getPointerToNamedFunction(F->getName()); + if (F->isExternal()) { + void *Addr = getPointerToNamedFunction(F->getName()); + addGlobalMapping(F, Addr); + return Addr; + } runJITOnFunction(F); + + void *Addr = getPointerToGlobalIfAvailable(F); assert(Addr && "Code generation didn't add function to GlobalAddress table!"); return Addr; } @@ -107,8 +122,8 @@ // void *JIT::getPointerToFunctionOrStub(Function *F) { // If we have already code generated the function, just return the address. - std::map::iterator I = GlobalAddress.find(F); - if (I != GlobalAddress.end()) return I->second; + if (void *Addr = getPointerToGlobalIfAvailable(F)) + return Addr; // If the target supports "stubs" for functions, get a stub now. if (void *Ptr = TJI.getJITStubForFunction(F, *MCE)) @@ -118,6 +133,33 @@ return getPointerToFunction(F); } +/// getOrEmitGlobalVariable - Return the address of the specified global +/// variable, possibly emitting it to memory if needed. This is used by the +/// Emitter. +void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) { + void *Ptr = getPointerToGlobalIfAvailable(GV); + if (Ptr) return Ptr; + + // If the global is external, just remember the address. + if (GV->isExternal()) { + Ptr = GetAddressOfSymbol(GV->getName().c_str()); + if (Ptr == 0) { + std::cerr << "Could not resolve external global address: " + << GV->getName() << "\n"; + abort(); + } + } else { + // If the global hasn't been emitted to memory yet, allocate space. We will + // actually initialize the global after current function has finished + // compilation. + Ptr =new char[getTargetData().getTypeSize(GV->getType()->getElementType())]; + PendingGlobals.push_back(GV); + } + addGlobalMapping(GV, Ptr); + return Ptr; +} + + /// recompileAndRelinkFunction - This method is used to force a function /// which has already been compiled, to be compiled again, possibly /// after it has been modified. Then the entry to the old copy is overwritten @@ -125,16 +167,23 @@ /// just like JIT::getPointerToFunction(). /// void *JIT::recompileAndRelinkFunction(Function *F) { - void *&Addr = GlobalAddress[F]; // Check if function already code gen'd + void *OldAddr = getPointerToGlobalIfAvailable(F); - // If it's not already compiled (this is kind of weird) there is no - // reason to patch it up. - if (!Addr) { return getPointerToFunction (F); } + // If it's not already compiled there is no reason to patch it up. + if (OldAddr == 0) { return getPointerToFunction(F); } - void *OldAddr = Addr; - Addr = 0; + // Delete the old function mapping. + addGlobalMapping(F, 0); + + // Destroy the machine code for this function. FIXME: this should be + // incorporated into the code generator! MachineFunction::destruct(F); + + // Recodegen the function runJITOnFunction(F); + + // Update state, forward the old function to the new function. + void *Addr = getPointerToGlobalIfAvailable(F); assert(Addr && "Code generation didn't add function to GlobalAddress table!"); TJI.replaceMachineCodeForFunction(OldAddr, Addr); return Addr; Index: llvm/lib/ExecutionEngine/JIT/JIT.h diff -u llvm/lib/ExecutionEngine/JIT/JIT.h:1.20 llvm/lib/ExecutionEngine/JIT/JIT.h:1.21 --- llvm/lib/ExecutionEngine/JIT/JIT.h:1.20 Fri Dec 19 19:46:27 2003 +++ llvm/lib/ExecutionEngine/JIT/JIT.h Fri Dec 19 21:36:47 2003 @@ -34,6 +34,11 @@ FunctionPassManager PM; // Passes to compile a function MachineCodeEmitter *MCE; // MCE object + /// PendingGlobals - Global variables which have had memory allocated for them + /// while a function was code generated, but which have not been initialized + /// yet. + std::vector PendingGlobals; + JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji); public: ~JIT(); @@ -68,6 +73,11 @@ /// compiling it if necessary. /// void *getPointerToFunction(Function *F); + + /// getOrEmitGlobalVariable - Return the address of the specified global + /// variable, possibly emitting it to memory if needed. This is used by the + /// Emitter. + void *getOrEmitGlobalVariable(const GlobalVariable *GV); /// getPointerToFunctionOrStub - If the specified function has been /// code-gen'd, return a pointer to the function. If not, compile it, or use From lattner at cs.uiuc.edu Fri Dec 19 21:38:00 2003 From: lattner at cs.uiuc.edu (Chris Lattner) Date: Fri Dec 19 21:38:00 2003 Subject: [llvm-commits] CVS: llvm/lib/ExecutionEngine/ExecutionEngine.cpp Message-ID: <200312200337.VAA10450@zion.cs.uiuc.edu> Changes in directory llvm/lib/ExecutionEngine: ExecutionEngine.cpp updated: 1.41 -> 1.42 --- Log message: Implement PR135, lazy emission of global variables --- Diffs of the changes: (+7 -4) Index: llvm/lib/ExecutionEngine/ExecutionEngine.cpp diff -u llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.41 llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.42 --- llvm/lib/ExecutionEngine/ExecutionEngine.cpp:1.41 Fri Dec 19 20:45:37 2003 +++ llvm/lib/ExecutionEngine/ExecutionEngine.cpp Fri Dec 19 21:36:25 2003 @@ -155,7 +155,8 @@ const_cast(dyn_cast(CPR->getValue()))) Result = PTOGV(getPointerToFunctionOrStub(F)); else - Result = PTOGV(getPointerToGlobal(CPR->getValue())); + Result = PTOGV(getOrEmitGlobalVariable( + cast(CPR->getValue()))); } else { assert(0 && "Unknown constant pointer type!"); @@ -374,7 +375,6 @@ // Allocate some memory for it! unsigned