> Note: I understand I can use a switch statement, but I really don't want
nor
> need a check to make sure it's within bounds.  If there's a way to define
a
> switch statement without the bounds checking I'm all ears.

> #define NEXT goto **ip++
> main()
> {
>   static void  *prog[] =
> {&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&loop};
>   void **ip=prog;
>   int    count = 10000000;

>  next:
>   NEXT;
>  loop:
>   if (count>0) {
>     count--;
>     ip=prog;
>     NEXT;
>   }
> }

> Off Subject:  Anyone know where I can get a nice Itanium/Hammer simulator,
> if I can compile XP 64 while in 32-bit windows, and if XP 64 will support
> the Hammer Architecture and if it does will VC.NET be able to compile
64-bit
> code for it?  If so I have some benchmarks I'm working on that I'd love to
> try and test on those 64-bit chips, specifically the Claw Hammer if it's
> going to be as reasonably priced as we've been led to believe.

> --Jonathan Ross, Mark Ross & Co., VB Programmer
> // If you need to send me e-mail remove all numbers and capital letters
from
> the e-mail listed.

> There is no way in C or C++ to take the address of a label: the only way I
> could think of doing this would be using assembler -- but that would not
be
> very protable.

> --
> Jonathan Caves
> Microsoft Corporation

> This posting is provided "AS IS" with no warranties, and confers no

> #include <stdio.h>

> #define NEXT goto *ip++
> main()
> {
>   static void  *prog[] = {&&cool,&&notcool};
>   //void **ip=prog;
>   //int    count = 1;

>   goto *prog[0];
> notcool:
>   printf("Not Cool\n");
>   exit(0);
> cool:
>   printf("Cool\n");
>   exit(0);
> }

>    The output when compiled and ran was, of course, "Cool".  The following
> did however work in VC++

> #include <iostream>

> void main()
> {
>     __asm jmp mylabel;
>     std::cout << "didn't work" << std::endl;
>     return;
>     mylabel:
>     std::cout << "worked" << std::endl;
>     return;
> }

>> Note: I understand I can use a switch statement, but I really don't want
>nor
>> need a check to make sure it's within bounds.  If there's a way to define
>a
>> switch statement without the bounds checking I'm all ears.

>> #define NEXT goto **ip++
>> main()
>> {
>>   static void  *prog[] =
>> {&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&loop};
>>   void **ip=prog;
>>   int    count = 10000000;

>>  next:
>>   NEXT;
>>  loop:
>>   if (count>0) {
>>     count--;
>>     ip=prog;
>>     NEXT;
>>   }
>> }

>I don't know what language this is -- but it is not C or C++ as I know it.

>There is no way in C or C++ to take the address of a label: the only way I
>could think of doing this would be using assembler -- but that would not be
>very protable.

>>>  next:
>>>   NEXT;
>>>  loop:
>>>   if (count>0) {
>>>     count--;
>>>     ip=prog;
>>>     NEXT;
>>>   }
>>> }

>>I don't know what language this is -- but it is not C or C++ as I know it.

>>There is no way in C or C++ to take the address of a label: the only way I
>>could think of doing this would be using assembler -- but that would not be
>>very protable.

>Right, this is a gcc'ism.  With the 4.3 release of Comeau we'll support
>this as an extension, along with 'goto *p;', but I agree one should
>not expect this for portable code.  So to adapt it for Standard C++
>you'll need to perhaps use pointers to function, or a switch statement
>or something.

> >>>  next:
> >>>   NEXT;
> >>>  loop:
> >>>   if (count>0) {
> >>>     count--;
> >>>     ip=prog;
> >>>     NEXT;
> >>>   }
> >>> }

> >>I don't know what language this is -- but it is not C or C++ as I know
it.

> >>There is no way in C or C++ to take the address of a label: the only way
I
> >>could think of doing this would be using assembler -- but that would not
be
> >>very protable.

> >Right, this is a gcc'ism.  With the 4.3 release of Comeau we'll support
> >this as an extension, along with 'goto *p;', but I agree one should
> >not expect this for portable code.  So to adapt it for Standard C++
> >you'll need to perhaps use pointers to function, or a switch statement
> >or something.

> BTW, if I'm not mistaken, your code seems equivalent to this:

> int main()
> {
>   int count = 10000000;

>   do {
>     for (int next = 0; next < 9; next++)
>       ;
>   } while (count-- > 0);

>   return 0;
> }

> or for that matter just use 90000000L with one loop.
> --
> Greg Comeau  GA BETA:4+ New Windows Backends  PLUS 'export' beta online!
> Comeau C/C++ ONLINE ==>     http://www.comeaucomputing.com/tryitout
> World Class Compilers:  Breathtaking C++, Amazing C99, Fabulous C90.
> Comeau C/C++ with Dinkumware's Libraries... Have you tried it?

>    Also, I tried to use the inline assembly of VC++ to load a label into a
> register, it did not work.  At this point I'm concerned about my code
being
> compliable in both gcc and VC++, but I would be willing to define a few
> assembly macros and switch them at compile time for the sake of speed.

>    So with the goal of jumping to different areas in the function using an
> index to an array of code positions as opcodes I have two choices.  The
> first is using a switch statement, which I do not like since compilers
> generally insert code to insure the variable is within bounds [ If I use
an
> unsigned value for the switch will VC++ only check to make sure the opcode
> is <= the upper bound? ].  The second is the direct style which basically
> means that instead of having a break at the end of an opcode's code there
is
> code that will move it directly to the next opcode in line.  Here's a
simple
> switch case example that I did get to work successfully in VC++.

> void switch_type()
> {
>     static int prog[] = {0,0,0,0,0,0,0,0,0,1};
>     int *ip=prog;
>     int count = 10000000;
>     unsigned int nop = 0;

>     for (;;)
>     {
>         switch (*ip++)
>         {
>         case 0:
>                 nop++;
>                 break;
>         case 1:
>             if (--count)
>             {
>                 ip=prog;
>                 break;
>             }else
>                 return;
>         }
>     }
> }

>     Remember that direct or tail style is different from switch style byte
> code in that instead of returning to the beginning of the switch
statement,
> each opcode's native code goes straight to the next opcode in line instead
> of going back to another position and then re-entering.  In other words,
> there's no nesting.

>    What I want to achieve is a direct calling example I can use in my
> benchmark that will work in VC++ and GCC that has no bound checking.
While
> I have no doubt that VC++ is an exceptionally smart compiler and may even
> generate assembly that does do direct calling when all the optimizations
for
> speed are on (after all you're really just indexing an array for a switch
> anyway, where you index it from isn't all that important) my worry is two
> fold.  First off, gcc may not be this smart and I'd like my code to be as
> static as possible.  And secondly, there's still a very high if not 100%
> chance VC++ is still going to implement bound checking which is completely
> unnecessary as the opcode generation will be handled by an assembler which
> itself is used by a compiler in the finished product.

>    As I said, I am not opposed to swapping a few macro definitions so long
> as the general structure is the same for both ports of the code.  So my
> question to anyone who can answer is how do I get the offset of a position
> of code; the value of a label, and how do I then use that value, stored in
> memory, to jump to the portion of the code I want?

>    As for the using Comeau the idea is starting to look very attractive
for
> other reasons as well.  I had planned to use non-fixed length arrays as
> masks for each code segment.  The idea was to have a structure with some
> header, multi-threaded, etc. basic information in the front and an empty
> array at the bottom.  I would then malloc whatever size code I need and
use
> one of these structures as the type of a pointer to that malloced area.
> This would mean that the function wouldn't require an even deeper level
> pointer to the code and would save sizeof(pointer) space in the function
as
> a bonus.  While that does compile in VC++, it only compiles while
Microsoft
> extensions are enabled (I'm writing my test code in VC++ 6.0, I'm waiting
> for my recently purchased MSDN Developer CustomerID to kick in).

>    My concerns however are that one of the biggest reasons I choose to
> develop this project in Windows first instead of a Unix flavor or on a Mac
> (although Unix/Linux/Solaris x86 is my main target) is that IDE for VC.NET
> is just so extraordinary [ plus you just _HAVE_ to love the documentation
> and help ].  It also doesn't hurt that VC++ is such a smart optimizer, but
> that's just why I decided to actually compile the Windows final version in
> VC++, not why I'm developing in it.  I looked at the Comeau site and I
must
> admit I didn't quite fully grasp the concept of what it is.  From my
> understanding it's basically the top layer of a compiler, it compiles into
> the middle code of another compiler, and then lets that compiler compile
> native code from it's own middle language.  What concerns me is of course
> that I noticed Comeau is text prompt based system, and I heard no mention
of
> it being an IDE.  To me this is extraordinarily important and why I choose
> VC.NET in the first place.

>    So my question to you is how could I leverage the IDE of VC.NET, the
> compiler of Comeau, and the middle language to native code abilities of
> VC.NET and GCC without making this project more difficult than it already
> is?

> --Jonathan Ross
> // To send me e-mail remove all capital letters and numbers from my e-mail
> address.

> > >>> #define NEXT goto **ip++
> > >>> main()
> > >>> {
> > >>>   static void  *prog[] =

> {&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&next,&&loop};
> > >>>   void **ip=prog;
> > >>>   int    count = 10000000;

> > >>>  next:
> > >>>   NEXT;
> > >>>  loop:
> > >>>   if (count>0) {
> > >>>     count--;
> > >>>     ip=prog;
> > >>>     NEXT;
> > >>>   }
> > >>> }

> > >>I don't know what language this is -- but it is not C or C++ as I know
> it.

> > >>There is no way in C or C++ to take the address of a label: the only
way
> I
> > >>could think of doing this would be using assembler -- but that would
not
> be
> > >>very protable.

> > >Right, this is a gcc'ism.  With the 4.3 release of Comeau we'll support
> > >this as an extension, along with 'goto *p;', but I agree one should
> > >not expect this for portable code.  So to adapt it for Standard C++
> > >you'll need to perhaps use pointers to function, or a switch statement
> > >or something.

> > BTW, if I'm not mistaken, your code seems equivalent to this:

> > int main()
> > {
> >   int count = 10000000;

> >   do {
> >     for (int next = 0; next < 9; next++)
> >       ;
> >   } while (count-- > 0);

> >   return 0;
> > }

> > or for that matter just use 90000000L with one loop.
> > --
> > Greg Comeau  GA BETA:4+ New Windows Backends  PLUS 'export' beta online!
> > Comeau C/C++ ONLINE ==>     http://www.comeaucomputing.com/tryitout
> > World Class Compilers:  Breathtaking C++, Amazing C99, Fabulous C90.
> > Comeau C/C++ with Dinkumware's Libraries... Have you tried it?

>> BTW, if I'm not mistaken, your code seems equivalent to this:

>> int main()
>> {
>>   int count = 10000000;

>>   do {
>>     for (int next = 0; next < 9; next++)
>>       ;
>>   } while (count-- > 0);

>>   return 0;
>> }

>> or for that matter just use 90000000L with one loop.

>   When optimized down, yes, you're absolutely correct.  However, I was
>simply trying to do some benchmarks to decide what form of byte code
>interpreter run structure would work best on different platforms.  I may not
>have made it clear but I'm trying to design a Direct Calling interpreter,
>which may also be called a tail call interpreter (I'm not positive).

>void switch_type()
>{
>    static int prog[] = {0,0,0,0,0,0,0,0,0,1};
>    int *ip=prog;
>    int count = 10000000;
>    unsigned int nop = 0;

>    for (;;)
>    {
>        switch (*ip++)
>        {
>        case 0:
>                nop++;
>                break;
>        case 1:
>            if (--count)
>            {
>                ip=prog;
>                break;
>            }else
>                return;
>        }
>    }
>}

>    Remember that direct or tail style is different from switch style byte
>code in that instead of returning to the beginning of the switch statement,
>each opcode's native code goes straight to the next opcode in line instead
>of going back to another position and then re-entering.  In other words,
>there's no nesting.

> However, since we are talking about pretty deep stuff here, would the
> VC specific __assume help the optimizer? Would something likt the
> following perhaps help?

> extern unsigned int iVal;
> __assume(iVal < 2);
> switch (iVal) {
> case 0: do_zero_stuff(); break;
> case 1: do_one_stuff(); break;
> }

> Would the check still be made (if iVal < 2), or would that __assume
> hint to the optimizer tell it that "these are the only two legal
> values in this code and if you gimme something else it's your fault",
> and not insert the extra "bounds"?

> /Mike

>Wow wow wooooooow.  Are you saying that Comeau will eventually let me write
>C++ code in the VC.NET interface, write and debug Comeau code (maybe even
>profile), etc., etc., compile into MSML, then get VS.NET to optimize the
>heck out of it and after I'm done testing I can take the source, compile it
>in a different platform's Comeau?

>   To think, I was actually starting to doubt my MSDN Developer
>Subscription.  Granted, I may not have gotten that little flow perfectly but
>if it's anything like that...  Sign me up for beta testing and let me buy
>the first copy you sell :)

>--Jonathan Ross, very very e{*filter*}d
>PS:  Got a link to it describing it any further?  I think this is getting a
>bit off thread here, just post the link so everyone can read it and we don't
>clutter the boards anymore.  And I'm serious about beta testing, I tend to
>break the unbreakable; as you can probably see why from this thread.