<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
   <channel>
      <title>Comp.compilers newsgroup</title>
      <link>http://compilers.iecc.com/</link>
      <description>The oldest and most popular online compilers forum.</description>
      <language>en-us</language>
      <generator>Compilers RSS kludge 0.1</generator>
      <managingEditor>compilers-request@iecc.com</managingEditor>
      <webMaster>webmaster@iecc.com</webMaster>
      <item>
         <title>Re: Predict register usage</title>
	 <pubDate>Fri, 9 May 2008 19:35:15 +0000 (UTC)</pubDate>
	 <author>=?ISO-8859-1?Q?Bj=F6rn_Franke?= &lt;bfranke@inf.ed.ac.uk&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-024</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-024</guid>
	 <description>&gt; Do you know of any approaches which try to predict the resulting
&gt; spill code added by a register allocation when inlining is done for
&gt; a particular function?

Have a look at these two papers, they may contain some useful
information for you:
</description>
      </item>
      <item>
         <title>Seed7 Release 2008-05-08</title>
	 <pubDate>Fri, 9 May 2008 19:34:56 +0000 (UTC)</pubDate>
	 <author>thomas.mertes@gmx.at</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-023</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-023</guid>
	 <description>Hello,

I have released a new version of Seed7: seed7_05_20080508.tgz

In the Seed7 programming language new statements and operators
can be declared easily. Types are first class objects and therefore
templates/generics need no special syntax. Object orientation is
</description>
      </item>
      <item>
         <title>Bison conflict ?</title>
	 <pubDate>Fri, 9 May 2008 19:34:44 +0000 (UTC)</pubDate>
	 <author>judicator3@gmail.com</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-022</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-022</guid>
	 <description>Hello All:

I am writing a parser to parse SQL (actually T-SQL for MS Sql Server).
I am getting a shift/reduce conflict that I don't know how to solve. I
know the reason of the conflict and I can give you 2 valid SQL
statements that can be parsed in two different ways. I just don't know
</description>
      </item>
      <item>
         <title>Look for GDT_PC paper from Algirdas Pakstas</title>
	 <pubDate>Thu, 8 May 2008 13:10:07 +0000 (UTC)</pubDate>
	 <author>Tom &lt;txchen@gmail.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-021</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-021</guid>
	 <description>I read about GDP_PC by Algirdas Pakstas at
http://compilers.iecc.com/comparch/article/92-05-030 He said the paper
could be sent to everybody by E-mail. It's been 16 years now. Does
anyone still have this paper or how can I contact him?

I sent an email to these addresses but got no response:
</description>
      </item>
      <item>
         <title>Re: Optimization for OOP</title>
	 <pubDate>Thu, 8 May 2008 01:32:48 +0000 (UTC)</pubDate>
	 <author>sgkelly4@gmail.com</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-020</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-020</guid>
	 <description>Thanks for the responses!

Anyway, the final Idea is good, it will allow me some more knowledge
about what the programmer feels a function should be doing. And thus
allow the optimizer to know what it can do. However, the problem is,
because of the way the optimizer is set up (basically the way in which
</description>
      </item>
      <item>
         <title>Re: Compiler optimizations on GPU?</title>
	 <pubDate>Tue, 6 May 2008 18:39:59 +0000 (UTC)</pubDate>
	 <author>Anton Lokhmotov &lt;al407@cam.ac.uk&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-019</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-019</guid>
	 <description>Shrey:
&gt; Can any one give me some broad hints on what sort of compiler
&gt; optimizations are important for GPU's

Have a look at the recent work of guys from the Ohio State University:
http://www.cse.ohio-state.edu/%7Ebaskaran/ics08.pdf

Cheers,
</description>
      </item>
      <item>
         <title>Re: Optimization for OOP</title>
	 <pubDate>Tue, 6 May 2008 18:39:18 +0000 (UTC)</pubDate>
	 <author>"Dmitry A. Kazakov" &lt;mailbox@dmitry-kazakov.de&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-018</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-018</guid>
	 <description>On Mon, 5 May 2008 18:51:58 -0700 (PDT), lucretia9@lycos.co.uk wrote:

&gt; On 5 May, 17:37, "Dmitry A. Kazakov" &lt;mail...@dmitry-kazakov.de&gt;
&gt; wrote:
&gt;
&gt;&gt; I think a consistent types system would be a better way. In Ada it
&gt;&gt; is always known if a call is dispatching or not. That is because of
</description>
      </item>
      <item>
         <title>Re: Optimization for OOP</title>
	 <pubDate>Tue, 6 May 2008 03:16:11 +0000 (UTC)</pubDate>
	 <author>"lucretia9@lycos.co.uk" &lt;lucretia9@lycos.co.uk&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-017</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-017</guid>
	 <description>On 5 May, 17:37, "Dmitry A. Kazakov" &lt;mail...@dmitry-kazakov.de&gt;
wrote:

&gt; I think a consistent types system would be a better way. In Ada it
&gt; is always known if a call is dispatching or not. That is because of
&gt; proper typing. When an object is of a specific type, its methods
</description>
      </item>
      <item>
         <title>Re: The Flaming Thunder compiler</title>
	 <pubDate>Tue, 6 May 2008 03:15:54 +0000 (UTC)</pubDate>
	 <author>Dave Parker &lt;daveparker@flamingthunder.com&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-016</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-016</guid>
	 <description>On May 5, 3:05 pm, Dave Parker &lt;davepar...@flamingthunder.com&gt; wrote:
&gt; The programming language itself reminds me of JOSS. -John]

John, thanks for the reference to JOSS.  I can see the similarity.
http://en.wikipedia.org/wiki/JOSS
-Dave

</description>
      </item>
      <item>
         <title>For Review: C++ Performance Benchmarks</title>
	 <pubDate>Tue, 6 May 2008 03:15:37 +0000 (UTC)</pubDate>
	 <author>Chris Cox &lt;ccox@comcast.net&gt;</author>
	 <link>http://compilers.iecc.com/comparch/article/08-05-015</link>
	 <guid isPermaLink="true">http://compilers.iecc.com/comparch/article/08-05-015</guid>
	 <description>Dear Colleagues;

I would like to get your help in reviewing the initial release of an
open source C++ Performance Benchmark.

These benchmarks will test compiler optimizations, language features,
common programming idioms, as well as some compiler runtime and OS
</description>
      </item>
   </channel>
</rss>
