To LUGNET HomepageTo LUGNET News HomepageTo LUGNET Guide Homepage
 Help on Searching
 
Post new message to lugnet.robotics.rcx.legosOpen lugnet.robotics.rcx.legos in your NNTP NewsreaderTo LUGNET News Traffic PageSign In (Members)
 Robotics / RCX / legOS / 3819
3818  |  3820
Subject: 
help building gcc cross-compiler (long)
Newsgroups: 
lugnet.robotics.rcx.legos
Date: 
Mon, 11 Oct 2004 05:27:08 GMT
Viewed: 
7786 times
  
I'm following Matthias Erhmann's excellent BrickOS Linux Installation HOWTO, and
I've hit a snag. When executing the "make" command in step 2.2 to make the gcc
cross-compiler, I got the error below. I commented out the first three lines of
the source, but that only emlimated the first three errors. I'm building on
Fedora 2 Core. All help is appreciated.

------ start of relevant make output --------------------------------------
/usr/local/src/build-gcc/gcc/xgcc -B/usr/local/src/build-gcc/gcc/ -nostdinc -B/u sr/local/src/build-gcc/h8300-hms/newlib/ -isystem /usr/local/src/build-gcc/h8300 -hms/newlib/targ-include -isystem /usr/local/src/gcc-3.4.2/newlib/libc/include - B/usr/local/h8300-hms/bin/ -B/usr/local/h8300-hms/lib/ -isystem /usr/local/h8300 -hms/include -isystem /usr/local/h8300-hms/sys-include -O2  -DIN_GCC -DCROSS_COM PILE   -W -Wall -Wwrite-strings -Wstrict-prototypes -Wmissing-prototypes -Wold-s tyle-definition  -isystem ./include  -DDF=SF -g  -DIN_LIBGCC2 -D__GCC_FLOAT_NOT_ NEEDED -Dinhibit_libc -I. -I. -I../../gcc-3.4.2/gcc -I../../gcc-3.4.2/gcc/. -I.. /../gcc-3.4.2/gcc/../include  -DL_cmpsi2 -xassembler-with-cpp -c ../../gcc-3.4.2 /gcc/config/h8300/lib1funcs.asm -o libgcc/./_cmpsi2.o
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm: Assembler messages:
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:1: Error: no such instruction: `l
ibgcc routines for the Renesas H8/300 CPU.'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:2: Error: no such instruction: `c
ontributed by Steve Chamberlain<sac@cygnus.com>'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:3: Error: no such instruction: `o
ptimizations by Toshiyasu Morita<toshiyasu.morita@renesas.com>'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:114: Error: invalid character '.'
in mnemonic
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:115: Error: no such instruction:
`bne .L2'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:116: Error: invalid character '.'
in mnemonic
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:117: Error: no such instruction:
`bne .L4'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:118: Error: invalid character '.'
in mnemonic
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:119: Error: no such instruction:
`rts'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:121: Error: no such instruction:
`bgt .L5'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:123: Error: invalid character '.'
in mnemonic
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:124: Error: no such instruction:
`rts'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:126: Error: no such instruction:
`bls .L3'
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:128: Error: invalid character '.'
in mnemonic
../../gcc-3.4.2/gcc/config/h8300/lib1funcs.asm:129: Error: no such instruction:
`rts'
------------end of relevant make output----------------------------------

------------lib1funcs.asm source-----------------------------------------
;; libgcc routines for the Renesas H8/300 CPU.
;; Contributed by Steve Chamberlain <sac@cygnus.com>
;; Optimizations by Toshiyasu Morita <toshiyasu.morita@renesas.com>

/* Copyright (C) 1994, 2000, 2001, 2002 Free Software Foundation, Inc.

This file is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

In addition to the permissions in the GNU General Public License, the
Free Software Foundation gives you unlimited permission to link the
compiled version of this file into combinations with other programs,
and to distribute those combinations without any restriction coming
from the use of this file.  (The General Public License restrictions
do apply in other respects; for example, they cover modification of
the file, and distribution when not linked into a combine
executable.)

This file is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

/* Assembler register definitions.  */

#define A0 r0
#define A0L r0l
#define A0H r0h

#define A1 r1
#define A1L r1l
#define A1H r1h

#define A2 r2
#define A2L r2l
#define A2H r2h

#define A3 r3
#define A3L r3l
#define A3H r3h

#define S0 r4
#define S0L r4l
#define S0H r4h

#define S1 r5
#define S1L r5l
#define S1H r5h

#define S2 r6
#define S2L r6l
#define S2H r6h

#ifdef __H8300__
#define PUSHP push
#define POPP pop

#define A0P r0
#define A1P r1
#define A2P r2
#define A3P r3
#define S0P r4
#define S1P r5
#define S2P r6
#endif

#if defined (__H8300H__) || defined (__H8300S__)
#define PUSHP push.l
#define POPP pop.l

#define A0P er0
#define A1P er1
#define A2P er2
#define A3P er3
#define S0P er4
#define S1P er5
#define S2P er6

#define A0E e0
#define A1E e1
#define A2E e2
#define A3E e3
#endif

#ifdef __H8300H__
#ifdef __NORMAL_MODE__
.h8300hn
#else
.h8300h
#endif
#endif

#ifdef __H8300S__
#ifdef __NORMAL_MODE__
.h8300sn
#else
.h8300s
#endif
#endif

#ifdef L_cmpsi2
#ifdef __H8300__
.section .text
.align 2
.global ___cmpsi2
___cmpsi2:
cmp.w A0,A2
bne .L2
cmp.w A2,A3
bne .L4
mov.w #1,A0
rts
.L2:
bgt .L5
.L3:
mov.w #2,A0
rts
.L4:
bls .L3
.L5:
sub.w A0,A0
rts
.end
#endif
#endif /* L_cmpsi2 */

#ifdef L_ucmpsi2
#ifdef __H8300__
.section .text
.align 2
.global ___ucmpsi2
___ucmpsi2:
cmp.w A0,A2
bne .L2
cmp.w A1,A3
bne .L4
mov.w #1,A0
rts
.L2:
bhi .L5
.L3:
mov.w #2,A0
rts
.L4:
bls .L3
.L5:
sub.w A0,A0
rts
.end
#endif
#endif /* L_ucmpsi2 */

#ifdef L_divhi3

;; HImode divides for the H8/300.
;; We bunch all of this into one object file since there are several
;; "supporting routines".

; general purpose normalize routine
;
; divisor in A0
; dividend in A1
; turns both into +ve numbers, and leaves what the answer sign
; should be in A2L

#ifdef __H8300__
.section .text
.align 2
divnorm:
mov.b #0x0,A2L
or A0H,A0H ; is divisor > 0
bge _lab1
not A0H ; no - then make it +ve
not A0L
adds #1,A0
xor #0x1,A2L ; and remember that in A2L
_lab1: or A1H,A1H ; look at dividend
bge _lab2
not A1H ; it is -ve, make it positive
not A1L
adds #1,A1
xor #0x1,A2L; and toggle sign of result
_lab2: rts
;; Basically the same, except that the sign of the divisor determines
;; the sign.
modnorm:
mov.b #0x0,A2L
or A0H,A0H ; is divisor > 0
bge _lab7
not A0H ; no - then make it +ve
not A0L
adds #1,A0
xor #0x1,A2L ; and remember that in A2L
_lab7: or A1H,A1H ; look at dividend
bge _lab8
not A1H ; it is -ve, make it positive
not A1L
adds #1,A1
_lab8: rts

; A0=A0/A1 signed

.global ___divhi3
___divhi3:
bsr divnorm
bsr ___udivhi3
negans: or A2L,A2L ; should answer be negative ?
beq _lab4
not A0H ; yes, so make it so
not A0L
adds #1,A0
_lab4: rts

; A0=A0%A1 signed

.global ___modhi3
___modhi3:
bsr modnorm
bsr ___udivhi3
mov A3,A0
bra negans

; A0=A0%A1 unsigned

.global ___umodhi3
___umodhi3:
bsr ___udivhi3
mov A3,A0
rts

; A0=A0/A1 unsigned
; A3=A0%A1 unsigned
; A2H trashed
; D high 8 bits of denom
; d low 8 bits of denom
; N high 8 bits of num
; n low 8 bits of num
; M high 8 bits of mod
; m low 8 bits of mod
; Q high 8 bits of quot
; q low 8 bits of quot
; P preserve

; The H8/300 only has a 16/8 bit divide, so we look at the incoming and
; see how to partition up the expression.

.global ___udivhi3
___udivhi3:
; A0 A1 A2 A3
; Nn Dd       P
sub.w A3,A3 ; Nn Dd xP 00
or A1H,A1H
bne divlongway
or A0H,A0H
beq _lab6

; we know that D == 0 and N is != 0
mov.b A0H,A3L ; Nn Dd xP 0N
divxu A1L,A3 ;          MQ
mov.b A3L,A0H ; Q
; dealt with N, do n
_lab6: mov.b A0L,A3L ;           n
divxu A1L,A3 ;          mq
mov.b A3L,A0L ; Qq
mov.b A3H,A3L         ;           m
mov.b #0x0,A3H ; Qq       0m
rts

; D != 0 - which means the denominator is
;          loop around to get the result.

divlongway:
mov.b A0H,A3L ; Nn Dd xP 0N
mov.b #0x0,A0H ; high byte of answer has to be zero
mov.b #0x8,A2H ;       8
div8: add.b A0L,A0L ; n*=2
rotxl A3L ; Make remainder bigger
rotxl A3H
sub.w A1,A3 ; Q-=N
bhs setbit ; set a bit ?
add.w A1,A3 ;  no : too far , Q+=N

dec A2H
bne div8 ; next bit
rts

setbit: inc A0L ; do insert bit
dec A2H
bne div8 ; next bit
rts

#endif /* __H8300__ */
#endif /* L_divhi3 */

#ifdef L_divsi3

;; 4 byte integer divides for the H8/300.
;;
;; We have one routine which does all the work and lots of
;; little ones which prepare the args and massage the sign.
;; We bunch all of this into one object file since there are several
;; "supporting routines".

.section .text
.align 2

; Put abs SIs into r0/r1 and r2/r3, and leave a 1 in r6l with sign of rest.
; This function is here to keep branch displacements small.

#ifdef __H8300__

divnorm:
mov.b A0H,A0H ; is the numerator -ve
stc ccr,S2L ; keep the sign in bit 3 of S2L
bge postive

; negate arg
not A0H
not A1H
not A0L
not A1L

add #1,A1L
addx #0,A1H
addx #0,A0L
addx #0,A0H
postive:
mov.b A2H,A2H ; is the denominator -ve
bge postive2
not A2L
not A2H
not A3L
not A3H
add.b #1,A3L
addx #0,A3H
addx #0,A2L
addx #0,A2H
xor.b #0x08,S2L ; toggle the result sign
postive2:
rts

;; Basically the same, except that the sign of the divisor determines
;; the sign.
modnorm:
mov.b A0H,A0H ; is the numerator -ve
stc ccr,S2L ; keep the sign in bit 3 of S2L
bge mpostive

; negate arg
not A0H
not A1H
not A0L
not A1L

add #1,A1L
addx #0,A1H
addx #0,A0L
addx #0,A0H
mpostive:
mov.b A2H,A2H ; is the denominator -ve
bge mpostive2
not A2L
not A2H
not A3L
not A3H
add.b #1,A3L
addx #0,A3H
addx #0,A2L
addx #0,A2H
mpostive2:
rts

#else /* __H8300H__ */

divnorm:
mov.l A0P,A0P ; is the numerator -ve
stc ccr,S2L ; keep the sign in bit 3 of S2L
bge postive

neg.l A0P ; negate arg

postive:
mov.l A1P,A1P ; is the denominator -ve
bge postive2

neg.l A1P ; negate arg
xor.b #0x08,S2L ; toggle the result sign

postive2:
rts

;; Basically the same, except that the sign of the divisor determines
;; the sign.
modnorm:
mov.l A0P,A0P ; is the numerator -ve
stc ccr,S2L ; keep the sign in bit 3 of S2L
bge mpostive

neg.l A0P ; negate arg

mpostive:
mov.l A1P,A1P ; is the denominator -ve
bge mpostive2

neg.l A1P ; negate arg

mpostive2:
rts

#endif

; numerator in A0/A1
; denominator in A2/A3
.global ___modsi3
___modsi3:
#ifdef __H8300__
PUSHP S2P
PUSHP S0P
PUSHP S1P
bsr modnorm
bsr divmodsi4
mov S0,A0
mov S1,A1
bra exitdiv
#else
PUSHP S2P
bsr modnorm
bsr ___udivsi3
mov.l er3,er0
bra exitdiv
#endif

;; H8/300H and H8S version of ___udivsi3 is defined later in
;; the file.
#ifdef __H8300__
.global ___udivsi3
___udivsi3:
PUSHP S2P
PUSHP S0P
PUSHP S1P
bsr divmodsi4
bra reti
#endif

.global ___umodsi3
___umodsi3:
#ifdef __H8300__
PUSHP S2P
PUSHP S0P
PUSHP S1P
bsr divmodsi4
mov S0,A0
mov S1,A1
bra reti
#else
bsr ___udivsi3
mov.l er3,er0
rts
#endif

.global ___divsi3
___divsi3:
#ifdef __H8300__
PUSHP S2P
PUSHP S0P
PUSHP S1P
jsr divnorm
jsr divmodsi4
#else
PUSHP S2P
jsr divnorm
bsr ___udivsi3
#endif

; examine what the sign should be
exitdiv:
btst #3,S2L
beq reti

; should be -ve
#ifdef __H8300__
not A0H
not A1H
not A0L
not A1L

add #1,A1L
addx #0,A1H
addx #0,A0L
addx #0,A0H
#else /* __H8300H__ */
neg.l A0P
#endif

reti:
#ifdef __H8300__
POPP S1P
POPP S0P
#endif
POPP S2P
rts

; takes A0/A1 numerator (A0P for H8/300H)
; A2/A3 denominator (A1P for H8/300H)
; returns A0/A1 quotient (A0P for H8/300H)
; S0/S1 remainder (S0P for H8/300H)
; trashes S2H

#ifdef __H8300__

divmodsi4:
        sub.w S0,S0 ; zero play area
        mov.w S0,S1
        mov.b A2H,S2H
        or A2L,S2H
        or A3H,S2H
        bne DenHighNonZero
        mov.b A0H,A0H
        bne NumByte0Zero
        mov.b A0L,A0L
        bne NumByte1Zero
        mov.b A1H,A1H
        bne NumByte2Zero
        bra NumByte3Zero
NumByte0Zero:
mov.b A0H,S1L
        divxu A3L,S1
        mov.b S1L,A0H
NumByte1Zero:
mov.b A0L,S1L
        divxu A3L,S1
        mov.b S1L,A0L
NumByte2Zero:
mov.b A1H,S1L
        divxu A3L,S1
        mov.b S1L,A1H
NumByte3Zero:
mov.b A1L,S1L
        divxu A3L,S1
        mov.b S1L,A1L

        mov.b S1H,S1L
        mov.b #0x0,S1H
        rts

; have to do the divide by shift and test
DenHighNonZero:
mov.b A0H,S1L
        mov.b A0L,A0H
        mov.b A1H,A0L
        mov.b A1L,A1H

        mov.b #0,A1L
        mov.b #24,S2H ; only do 24 iterations

nextbit:
add.w A1,A1 ; double the answer guess
        rotxl A0L
        rotxl A0H

        rotxl S1L ; double remainder
        rotxl S1H
        rotxl S0L
        rotxl S0H
        sub.w A3,S1 ; does it all fit
        subx A2L,S0L
        subx A2H,S0H
        bhs setone

        add.w A3,S1 ; no, restore mistake
        addx A2L,S0L
        addx A2H,S0H

        dec S2H
        bne nextbit
        rts

setone:
inc A1L
        dec S2H
        bne nextbit
        rts

#else /* __H8300H__ */

;; This function also computes the remainder and stores it in er3.
.global ___udivsi3
___udivsi3:
mov.w A1E,A1E ; denominator top word 0?
bne DenHighNonZero

; do it the easy way, see page 107 in manual
mov.w A0E,A2
extu.l A2P
divxu.w A1,A2P
mov.w A2E,A0E
divxu.w A1,A0P
mov.w A0E,A3
mov.w A2,A0E
extu.l A3P
rts

; er0 = er0 / er1
; er3 = er0 % er1
; trashes er1 er2
; expects er1 >= 2^16
DenHighNonZero:
mov.l er0,er3
mov.l er1,er2
#ifdef __H8300H__
divmod_L21:
shlr.l er0
shlr.l er2 ; make divisor < 2^16
mov.w e2,e2
bne divmod_L21
#else
shlr.l #2,er2 ; make divisor < 2^16
mov.w e2,e2
beq divmod_L22A
divmod_L21:
shlr.l #2,er0
divmod_L22:
shlr.l #2,er2 ; make divisor < 2^16
mov.w e2,e2
bne divmod_L21
divmod_L22A:
rotxl.w r2
bcs divmod_L23
shlr.l er0
bra divmod_L24
divmod_L23:
rotxr.w r2
shlr.l #2,er0
divmod_L24:
#endif
;; At this point,
;;  er0 contains shifted dividend
;;  er1 contains divisor
;;  er2 contains shifted divisor
;;  er3 contains dividend, later remainder
divxu.w r2,er0 ; r0 now contains the approximate quotient (AQ)
extu.l er0
beq divmod_L25
subs #1,er0 ; er0 = AQ - 1
mov.w e1,r2
mulxu.w r0,er2 ; er2 = upper (AQ - 1) * divisor
sub.w r2,e3 ; dividend - 65536 * er2
mov.w r1,r2
mulxu.w r0,er2 ; compute er3 = remainder (tentative)
sub.l er2,er3 ; er3 = dividend - (AQ - 1) * divisor
divmod_L25:
cmp.l er1,er3 ; is divisor < remainder?
blo divmod_L26
adds #1,er0
sub.l er1,er3 ; correct the remainder
divmod_L26:
rts

#endif
#endif /* L_divsi3 */

#ifdef L_mulhi3

;; HImode multiply.
; The H8/300 only has an 8*8->16 multiply.
; The answer is the same as:
;
; product = (srca.l * srcb.l) + ((srca.h * srcb.l) + (srcb.h * srca.l)) * 256
; (we can ignore A1.h * A0.h cause that will all off the top)
; A0 in
; A1 in
; A0 answer

#ifdef __H8300__
.section .text
.align 2
.global ___mulhi3
___mulhi3:
mov.b A1L,A2L ; A2l gets srcb.l
mulxu A0L,A2 ; A2 gets first sub product

mov.b A0H,A3L ; prepare for
mulxu A1L,A3 ; second sub product

add.b A3L,A2H ; sum first two terms

mov.b A1H,A3L ; third sub product
mulxu A0L,A3

add.b A3L,A2H ; almost there
mov.w A2,A0 ; that is
rts

#endif
#endif /* L_mulhi3 */

#ifdef L_mulsi3

;; SImode multiply.
;;
;; I think that shift and add may be sufficient for this.  Using the
;; supplied 8x8->16 would need 10 ops of 14 cycles each + overhead.  This way
;; the inner loop uses maybe 20 cycles + overhead, but terminates
;; quickly on small args.
;;
;; A0/A1 src_a
;; A2/A3 src_b
;;
;;  while (a)
;;    {
;;      if (a & 1)
;;        r += b;
;;      a >>= 1;
;;      b <<= 1;
;;    }

.section .text
.align 2

#ifdef __H8300__

.global ___mulsi3
___mulsi3:
PUSHP S0P
PUSHP S1P

sub.w S0,S0
sub.w S1,S1

; while (a)
_top: mov.w A0,A0
bne _more
mov.w A1,A1
beq _done
_more: ; if (a & 1)
bld #0,A1L
bcc _nobit
; r += b
add.w A3,S1
addx A2L,S0L
addx A2H,S0H
_nobit:
; a >>= 1
shlr A0H
rotxr A0L
rotxr A1H
rotxr A1L

; b <<= 1
add.w A3,A3
addx A2L,A2L
addx A2H,A2H
bra _top

_done:
mov.w S0,A0
mov.w S1,A1
POPP S1P
POPP S0P
rts

#else /* __H8300H__ */

;
; mulsi3 for H8/300H - based on Renesas SH implementation
;
; by Toshiyasu Morita
;
; Old code:
;
; 16b * 16b = 372 states (worst case)
; 32b * 32b = 724 states (worst case)
;
; New code:
;
; 16b * 16b =  48 states
; 16b * 32b =  72 states
; 32b * 32b =  92 states
;

.global ___mulsi3
___mulsi3:
mov.w r1,r2   ; ( 2 states) b * d
mulxu r0,er2  ; (22 states)

mov.w e0,r3   ; ( 2 states) a * d
beq L_skip1 ; ( 4 states)
mulxu r1,er3  ; (22 states)
add.w r3,e2   ; ( 2 states)

L_skip1:
mov.w e1,r3   ; ( 2 states) c * b
beq L_skip2 ; ( 4 states)
mulxu r0,er3  ; (22 states)
add.w r3,e2   ; ( 2 states)

L_skip2:
mov.l er2,er0 ; ( 2 states)
rts ; (10 states)

#endif
#endif /* L_mulsi3 */
#ifdef L_fixunssfsi_asm
/* For the h8300 we use asm to save some bytes, to
   allow more programs to fit into the tiny address
   space.  For the H8/300H and H8S, the C version is good enough.  */
#ifdef __H8300__
/* We still treat NANs different than libgcc2.c, but then, the
   behavior is undefined anyways.  */
.global ___fixunssfsi
___fixunssfsi:
cmp.b #0x4f,r0h
bge Large_num
jmp     @___fixsfsi
Large_num:
bhi L_huge_num
xor.b #0x80,A0L
bmi L_shift8
L_huge_num:
mov.w #65535,A0
mov.w A0,A1
rts
L_shift8:
mov.b A0L,A0H
mov.b A1H,A0L
mov.b A1L,A1H
mov.b #0,A1L
rts
#endif
#endif /* L_fixunssfsi_asm */
------------end of lib1funcs.asm source-------------------------------------



Message has 1 Reply:
  Re: help building gcc cross-compiler (long)
 
(...) You must not compile the gcc by your own. Why don't you use a ready-to-run rpm? You can find all you need at: (URL) (20 years ago, 11-Oct-04, to lugnet.robotics.rcx.legos)

4 Messages in This Thread:

Entire Thread on One Page:
Nested:  All | Brief | Compact | Dots
Linear:  All | Brief | Compact
    

Custom Search

©2005 LUGNET. All rights reserved. - hosted by steinbruch.info GbR