From: Randall Hyde on

"Betov" <betov(a)free.fr> wrote in message
news:XnF969DB820D259Fbetovfreefr(a)212.27.42.68...
> "Randall Hyde" <randyhyde(a)earthlink.net> ýcrivait
> news:QgOEe.3092$0C.1369(a)newsread3.news.pas.earthlink.net:
>
> > assemblers like
> > NASM, FASM, GoAsm, TASM, MASM, Gas/ATT, Gas/Intel, and HLA all have
> > fairly decent followings (numbering in the thousands of users, each)
>
> * HLA is not an Assembler. It is an HLL Pre-Parser,
> that reads a Source File in HLA Syntax, and outputs
> nothing but an Asm Source.

See Point (1) below.

>
> * HLA has almost no users, as everybody can see by
> taking a quick look at the various boards, where
> you try to damage Assembly, by selling yourself.

See Point (2) below

> HLA has only a couple of _victims_ each week, who
> are gone one or two weeks later, not considering
> the tiny couple of definitive idiots keeping stuck
> with this horror.

Guess we'll have to add a new one for this repetitive statement we've
heard so many times, see point (4) below.

Cheers,
Randy Hyde

There's no need to respond point-by-point to any Rene ("Betov") Tournois
post. His posts are all repetitive, saying the same nonsense over and over
again. Therefore, we'll just use "canned" responses to answer his nonsense.
Here's the key to use:

(1) Rene's continued personal attacks on people and name-calling,
(2) Rene's continued attacks on products,
(3) Rene making unsubstantiated (and ridiculous) claims about RosAsm.
(4) Rene making ridiculous statements about other products, of which he has
no knowledge.



From: Ben Bradley on
I'm quoting a quote because I don't see the original:

On Fri, 22 Jul 2005 17:55:32 +0200, "Jeroen" <none(a)none.com> wrote:

>
>"Herbert Kleebauer" <klee(a)unibwm.de> schreef in bericht
>news:42DFDF98.DC5D4AC9(a)unibwm.de...
>> Have to write some AVR code and therefore have read the
>> AVR Instruction Set manual and tried the assembler included
>> in AVR studio. I think the used syntax is completely
>> unusable, so I decided to write my own assembler. A very
>> first version can be downloaded from:
>>
>> ftp://137.193.64.130/pub/assembler/adela.zip
>>
>> Maybe there are some AVR experts who can give some suggestions
>> for an improvement or are even willing to do some testing.

I don't consider myself an AVR expert, but I might take a look at
it. No one else has bother to comment on your actual assembler.
I can actually see why you would want to do this, there's an
addressing mode of the AVR's mov that sure seems backwards compare to
how I've seen mov used elsewhere, and I was somewhat bothered by it.
My solution was my mindset: I'm programing the AVR, the processor with
a backwards mov.
But actually writing an assembler seems extreme to me, especially
when many macro assemblers are versatile enough you can just write new
macros for your new opcodes and addressing modes that expand into the
'standard' assembly code. Have you considered doing this?
As for the same processor having different assembly mnemonics and
syntax, the most obvious case I recall is the Intel 8080 and Zilog
Z80, both executing the same instruction set (ignoring the Z80's extra
instructions) but with two strongly differring assembly languages.
IIRC, Zilog created the new assembly mnemonics because Intel had its
mnemonics copyrighted.
Having said that, I have to agree whoever else said it that the C
compilers thesedays have pretty much made this sort of thing moot for
any 8-bit or larger processor. Writing assembly code is less and less
common even for absolute (pun intended) 'bare metal' programming, as
the compilers do quite well with making optimized code. Even so, I
sometimes catch myself looking 'under the hood' to double-check the
compiler, to see just how good the stuff is it's putting out. It's my
decades of having written a significant amount of assembly myself that
makes me do it...

-----
http://www.mindspring.com/~benbradley
From: Jim Granville on
Herbert Kleebauer wrote:
> Have to write some AVR code and therefore have read the
> AVR Instruction Set manual and tried the assembler included
> in AVR studio. I think the used syntax is completely
> unusable, so I decided to write my own assembler. A very
> first version can be downloaded from:
>
> ftp://137.193.64.130/pub/assembler/adela.zip
>
> Maybe there are some AVR experts who can give some suggestions
> for an improvement or are even willing to do some testing.

You are right that the AVR Assembler is not one of the
better industry examples, but you should look to fix only
what is broken.

Suggestions:

a) You could create a pre-processor, that outputs std AVR_ASM
and includes your codes and comments - that way, you can
still read LIST files, and avoid a whole truck load of work
with symbol/link object files/AVR Core variants.
Use a file extension other than ASM for the starting source.

b) Make the .b suffix default, otherwise that's a lot of dead typing,
and visual clutter.

c) Check carefully that you ARE making code clearer: using a
move for Push/Pop is not widespread, nor is move to alias IN/OUT
on processors that use IN/OUT address space.

move.b +(sp),rj ; j=0..31 POP
move.b rj,(sp)- ; j=0..31 PUSH

move.b ?adr6,rj ; adr6=0..63 j=0..31 IN
move.b ri,?adr6 ; adr6=0..63 i=0..31 OUT

d) If you really want to move AVR Assembler forward, look at expanding
Randall Hyde's High Level Assembler, to include the AVR :)

http://webster.cs.ucr.edu/AsmTools/HLA/index.html
&
http://webster.cs.ucr.edu/AsmTools/HLA/hla2/0_hla2.html

-jg

From: Betov on
Ben Bradley <ben_nospam_bradley(a)frontiernet.net> ýcrivait
news:va58e1l9h89a21plnjbqkb606v184c3ni5(a)4ax.com:

> It's my
> decades of having written a significant amount of assembly myself that
> makes me do it...
>
> -----
> http://www.mindspring.com/~benbradley

:)

A man who builds guitars cannot be completely bad, but
i see no Asm thingie, there. Are you one more of these
guy with a big mouth, about Assembly, without anything
to show?

Not even a small real life Application, with Sources,
to show, after _decades_ of activities?

:)

Betov.

< http://rosasm.org >

From: Herbert Kleebauer on
Jim Granville wrote:
> Herbert Kleebauer wrote:

> You are right that the AVR Assembler is not one of the
> better industry examples, but you should look to fix only
> what is broken.


> b) Make the .b suffix default, otherwise that's a lot of dead typing,
> and visual clutter.

If you use an assembler at a regular basis, the used syntax doesn't
matter at all, you just get used to it. For such people maybe the
Atmel syntax is perfect. But if you only seldom write an AVR assembler
program (or even just once in your live in a student project),
then I think, the Atmel syntax is not very well suited. To add a
..b to the instruction costs you two extra keystrokes, but you
write the line only once but maybe read it many times. So, if
the extra ".b" makes it just a little bit better readable, it's
worth the extra typing.

Maybe it's just me, but I think a

move.b r2,r12
move.w r3|r2 , r13|r12

is easier to understand (for somebody who doesn't use the
assembler on a regular basis) than a

AVRASM ver. 1.77.3 x.asm Mon Jul 25 09:42:19 2005

000000 2cc2 MOV R12,R2
000001 0161 MOVW R12,R2

even if you need to type a few more characters.


> c) Check carefully that you ARE making code clearer: using a
> move for Push/Pop is not widespread, nor is move to alias IN/OUT
> on processors that use IN/OUT address space.

Isn't a pre decrement mostly used for a push? AVR uses a post
decrement. So a

move.b rj,(sp)-

is much more informative than a simple PUSH.


IN/OUT instructions are used in assemblers for processors which
have IO instructions (like the x86). The AVR doesn't have IO
instructions but uses memory mapped IO (at least the ATmega32,
haven't read any other manual) at address $20-$5f. Even the registers
are memory mapped (at address $00-$1f). So all we have is a

mov adr1, adr2

where at least one address has to be <$20. There are short
opcode forms for this mov instruction if the other address
is below $60. Let's assume adr1=$10, then Atmel calls the
move a:

MOV if adr2<$20 (register register move)
IN if $20<=adr2<$60
LDS if $60<=adr2

There is no need to use three different names for a move
instruction depending on the address range. By using
the IN/OUT instructions they also made an address
space shift (to start IO addresses at zero) so we
now have two different address for IO registers. Because
mostly the IO address is given in the IO address space
and not in the memory address space I also had to add
an IO addressing mode:

move.b ?adr,rj

where ?adr is nothing but adr+$20.

If the assembly language would be well designed, we neither
had registers (r0-r31) nor an IO address space. A simple
"move adr1,adr2" would be sufficient. Depending on the
given address, the the assembler would generate the
correct opcode.

But from a marketing point of view it is much better to
say, AVR has 32 registers and a separate IO address space
than say it correctly:

AVR doesn't have any registers and we have to use a part
of the memory address space for addressing the IO registers
and all the ALU operations like add, and, or, ... are
restricted to the first 32 memory locations (or if immediate
operands are used to the memmory locatioons 16-31). The sad
thing is, that because of this marketing trick we have to use
a bad assembler syntax.


> d) If you really want to move AVR Assembler forward, look at expanding
> Randall Hyde's High Level Assembler, to include the AVR :)

I will not comment this. We have this discussion on
a daily basis in alt.lang.asm and better don't start it in
c.a.e (it will never stop). But it is really a sad thing, that
even people in c.a.e call HLA an assembler.
First  |  Prev  |  Next  |  Last
Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
Next: int 10h AX = 4F00h