Makefile.in

   1 #
   2 # Makefile for directory with subdirs to build.
   3 #   Copyright (C) 1990, 1991, 1992 Free Software Foundation
   4 #
   5 # This file is free software; you can redistribute it and/or modify
   6 # it under the terms of the GNU General Public License as published by
   7 # the Free Software Foundation; either version 2 of the License, or
   8 # (at your option) any later version.
   9 #
  10 # This program is distributed in the hope that it will be useful,
  11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 # GNU General Public License for more details.
  14 #
  15 # You should have received a copy of the GNU General Public License
  16 # along with this program; if not, write to the Free Software
  17 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18 #
  19
  20 srcdir = .
  21
  22 prefix = /usr/local
  23
  24 exec_prefix = $(prefix)
  25 bindir = $(exec_prefix)/bin
  26 libdir = $(exec_prefix)/lib
  27
  28 datadir = $(prefix)/lib
  29 mandir = $(prefix)/man
  30 man1dir = $(mandir)/man1
  31 man2dir = $(mandir)/man2
  32 man3dir = $(mandir)/man3
  33 man4dir = $(mandir)/man4
  34 man5dir = $(mandir)/man5
  35 man6dir = $(mandir)/man6
  36 man7dir = $(mandir)/man7
  37 man8dir = $(mandir)/man8
  38 man9dir = $(mandir)/man9
  39 infodir = $(prefix)/info
  40 includedir = $(prefix)/include
  41 docdir = $(datadir)/doc
  42
  43 SHELL = /bin/sh
  44
  45 INSTALL = install -c
  46 INSTALL_PROGRAM = $(INSTALL)
  47 INSTALL_DATA = $(INSTALL)
  48
  49 AR = ar
  50 AR_FLAGS = qc
  51 RANLIB = ranlib
  52
  53 BISON = `if [ -d $${rootme}/bison ] ; \
  54         then echo $${rootme}/bison/bison -L $${rootme}/bison/ -y ; \
  55         else echo bison -y ; fi`
  56
  57 MAKEINFO = `if [ -d $${rootme}/texinfo/C ] ; \
  58         then echo $${rootme}/texinfo/C/makeinfo ; \
  59         else echo makeinfo ; fi`
  60
  61 SUBDIRS = libiberty glob readline bfd gdb binutils ld gas gcc libg++ libgcc clib newlib
  62 OTHERS =
  63
  64 ALL = all.normal
  65 INSTALL_TARGET = install.all
  66
  67 ### for debugging
  68 #GCCVERBOSE=-v
  69
  70
  71 #### host and target specific makefile fragments come in here.
  72 ###
  73
  74 .PHONY: all info install-info clean-info
  75
  76 all:    $(ALL)
  77
  78 info:   cfg-paper.info configure.info
  79         rootme=`pwd` ; export rootme ; $(MAKE) subdir_do DO=info "DODIRS=$(SUBDIRS)" "MAKEINFO=$(MAKEINFO)"
  80
  81 check:; rootme=`pwd` ; export rootme ; $(MAKE) subdir_do DO=check \
  82         "DODIRS=`echo $(SUBDIRS) | sed -e \"s/libg\+\+//\"" \
  83         "MAKEINFO=$(MAKEINFO)"
  84         if [ -d libg++ ] ; then \
  85                 rootme=`pwd` ; export rootme ; \
  86                 (cd libg++ ; \
  87                  $(MAKE) check "CC=$${rootme}/gcc/gcc \
  88                  -B$${rootme}/gcc/") ; \
  89         fi
  90
  91
  92 clean-info:
  93         $(MAKE) subdir_do DO=clean-info "DODIRS=$(SUBDIRS)"
  94         rm -f cfg-paper.info* configure.info*
  95
  96 cfg-paper.info: cfg-paper.texi
  97         rootme=`pwd` ; export rootme ; $(MAKEINFO) -o cfg-paper.info $(srcdir)/cfg-paper.texi
  98
  99 configure.info: configure.texi
 100         rootme=`pwd` ; export rootme ; $(MAKEINFO) -o configure.info $(srcdir)/configure.texi
 101
 102 install-info: install-info-dirs force
 103         [ -d $(infodir) ] || mkdir $(infodir)
 104         $(MAKE) subdir_do DO=install-info "DODIRS=$(SUBDIRS)"
 105         $(INSTALL_DATA) cfg-paper.info $(infodir)/cfg-paper.info
 106         $(INSTALL_DATA) configure.info $(infodir)/configure.info
 107         $(MAKE) dir.info install-dir.info
 108
 109 install-dir.info:
 110         $(INSTALL_DATA) dir.info $(infodir)/dir.info
 111
 112 # clib send_pr
 113 #       all-libgcc
 114 all.normal: all-texinfo all-bison all-byacc all-flex all-ld \
 115         all-gas all-gcc all-binutils \
 116         all-libg++ all-gdb all-make all-cvs all-patch all-emacs \
 117         all-ispell all-fileutils \
 118         all-newlib
 119 all.cross: all-bison all-ld all-libgcc all-gdb
 120 #       $(MAKE) subdir_do DO=all "DODIRS=$(SUBDIRS) $(OTHERS)"
 121
 122 clean: clean-stamps clean-libiberty clean-texinfo clean-bfd clean-newlib clean-binutils \
 123         clean-bison clean-byacc clean-flex clean-ld clean-gas \
 124         clean-gcc clean-libgcc clean-readline clean-glob clean-gdb \
 125         clean-make clean-diff clean-grep clean-rcs clean-gdbm \
 126         clean-cvs clean-patch clean-emacs clean-ispell clean-fileutils \
 127         clean-libg++
 128         -rm -rf *.a TEMP errs core *.o *~ \#* TAGS *.E
 129
 130 clean-stamps:
 131         -rm -f stmp-*
 132
 133 install: $(INSTALL_TARGET) $(srcdir)/configure.man
 134         $(INSTALL_DATA) $(srcdir)/configure.man $(man1dir)/configure.1
 135
 136 install.all: install-dirs install-libiberty install-texinfo \
 137         install-bfd install-binutils install-bison install-byacc \
 138         install-flex install-ld install-gas install-gcc \
 139         install-libgcc install-readline install-glob install-gdb \
 140         install-make install-cvs install-patch install-emacs \
 141         install-ispell install-fileutils install-libg++ install-newlib
 142
 143 install.cross: install-dirs install-libiberty install-binutils install-bison \
 144         install-byacc install-ld install-gas install-libgcc \
 145         install-readline install-glob install-gdb
 146
 147 ### libiberty
 148 .PHONY: all-libiberty stmp-libiberty
 149 all-libiberty: stmp-libiberty
 150 stmp-libiberty:
 151         if [ -d ./libiberty ] ; then \
 152                 rootme=`pwd` ; export rootme ; \
 153                 (cd ./libiberty; \
 154                 $(MAKE) \
 155                         "against=$(against)" \
 156                         "AR=$(AR)" \
 157                         "AR_FLAGS=$(AR_FLAGS)" \
 158                         "CC=$(CC)" \
 159                         "RANLIB=$(RANLIB)" \
 160                         "LOADLIBES=$(LOADLIBES)" \
 161                         "LDFLAGS=$(LDFLAGS)" \
 162                         "BISON=$(BISON)" \
 163                         "MAKEINFO=$(MAKEINFO)" \
 164                         all) ; \
 165         else \
 166                 true ; \
 167         fi
 168         touch stmp-libiberty
 169
 170 clean-libiberty: force
 171         if [ -d ./libiberty ] ; then \
 172                 rootme=`pwd` ; export rootme ; \
 173                 (cd ./libiberty; \
 174                 $(MAKE) \
 175                         "against=$(against)" \
 176                         "AR=$(AR)" \
 177                         "AR_FLAGS=$(AR_FLAGS)" \
 178                         "CC=$(CC)" \
 179                         "RANLIB=$(RANLIB)" \
 180                         "LOADLIBES=$(LOADLIBES)" \
 181                         "LDFLAGS=$(LDFLAGS)" \
 182                         "BISON=$(BISON)" \
 183                         "MAKEINFO=$(MAKEINFO)" \
 184                         clean) ; \
 185         else \
 186                 true ; \
 187         fi
 188
 189 install-libiberty: force
 190         if [ -d ./libiberty ] ; then \
 191                 rootme=`pwd` ; export rootme ; \
 192                 (cd ./libiberty; \
 193                 $(MAKE) \
 194                         "against=$(against)" \
 195                         "AR=$(AR)" \
 196                         "AR_FLAGS=$(AR_FLAGS)" \
 197                         "CC=$(CC)" \
 198                         "RANLIB=$(RANLIB)" \
 199                         "LOADLIBES=$(LOADLIBES)" \
 200                         "LDFLAGS=$(LDFLAGS)" \
 201                         "BISON=$(BISON)" \
 202                         "MAKEINFO=$(MAKEINFO)" \
 203                         install) ; \
 204         else \
 205                 true ; \
 206         fi
 207
 208 ### texinfo
 209 .PHONY: all-texinfo stmp-texinfo
 210 all-texinfo: stmp-libiberty stmp-texinfo
 211 stmp-texinfo:
 212         if [ -d ./texinfo ] ; then \
 213                 rootme=`pwd` ; export rootme ; \
 214                 rootme=`pwd` ; export rootme ; \
 215                 (cd ./texinfo; \
 216                 $(MAKE) \
 217                         "against=$(against)" \
 218                         "AR=$(AR)" \
 219                         "AR_FLAGS=$(AR_FLAGS)" \
 220                         "CC=$(CC)" \
 221                         "RANLIB=$(RANLIB)" \
 222                         "LOADLIBES=$(LOADLIBES)" \
 223                         "LDFLAGS=$(LDFLAGS)" \
 224                         "BISON=$(BISON)" \
 225                         "MAKEINFO=$(MAKEINFO)" \
 226                         all) ; \
 227         else \
 228                 true ; \
 229         fi
 230         touch stmp-texinfo
 231
 232 clean-texinfo: force
 233         if [ -d ./texinfo ] ; then \
 234                 rootme=`pwd` ; export rootme ; \
 235                 (cd ./texinfo; \
 236                 $(MAKE) \
 237                         "against=$(against)" \
 238                         "AR=$(AR)" \
 239                         "AR_FLAGS=$(AR_FLAGS)" \
 240                         "CC=$(CC)" \
 241                         "RANLIB=$(RANLIB)" \
 242                         "LOADLIBES=$(LOADLIBES)" \
 243                         "LDFLAGS=$(LDFLAGS)" \
 244                         "BISON=$(BISON)" \
 245                         "MAKEINFO=$(MAKEINFO)" \
 246                         clean) ; \
 247         else \
 248                 true ; \
 249         fi
 250
 251 install-texinfo: force
 252         if [ -d ./texinfo ] ; then \
 253                 rootme=`pwd` ; export rootme ; \
 254                 (cd ./texinfo; \
 255                 $(MAKE) \
 256                         "against=$(against)" \
 257                         "AR=$(AR)" \
 258                         "AR_FLAGS=$(AR_FLAGS)" \
 259                         "CC=$(CC)" \
 260                         "RANLIB=$(RANLIB)" \
 261                         "LOADLIBES=$(LOADLIBES)" \
 262                         "LDFLAGS=$(LDFLAGS)" \
 263                         "BISON=$(BISON)" \
 264                         "MAKEINFO=$(MAKEINFO)" \
 265                         install) ; \
 266         else \
 267                 true ; \
 268         fi
 269
 270 ### bfd
 271 .PHONY: all-bfd stmp-bfd
 272 all-bfd: stmp-bfd
 273 stmp-bfd:
 274         if [ -d ./bfd ] ; then \
 275                 rootme=`pwd` ; export rootme ; \
 276                 (cd ./bfd; \
 277                 $(MAKE) \
 278                         "against=$(against)" \
 279                         "AR=$(AR)" \
 280                         "AR_FLAGS=$(AR_FLAGS)" \
 281                         "CC=$(CC)" \
 282                         "RANLIB=$(RANLIB)" \
 283                         "LOADLIBES=$(LOADLIBES)" \
 284                         "LDFLAGS=$(LDFLAGS)" \
 285                         "BISON=$(BISON)" \
 286                         "MAKEINFO=$(MAKEINFO)" \
 287                         all) ; \
 288         else \
 289                 true ; \
 290         fi
 291         touch stmp-bfd
 292
 293 clean-bfd: force
 294         if [ -d ./bfd ] ; then \
 295                 rootme=`pwd` ; export rootme ; \
 296                 (cd ./bfd; \
 297                 $(MAKE) \
 298                         "against=$(against)" \
 299                         "AR=$(AR)" \
 300                         "AR_FLAGS=$(AR_FLAGS)" \
 301                         "CC=$(CC)" \
 302                         "RANLIB=$(RANLIB)" \
 303                         "LOADLIBES=$(LOADLIBES)" \
 304                         "LDFLAGS=$(LDFLAGS)" \
 305                         "BISON=$(BISON)" \
 306                         "MAKEINFO=$(MAKEINFO)" \
 307                         clean) ; \
 308         else \
 309                 true ; \
 310         fi
 311
 312 install-bfd: force
 313         if [ -d ./bfd ] ; then \
 314                 rootme=`pwd` ; export rootme ; \
 315                 (cd ./bfd; \
 316                 $(MAKE) \
 317                         "against=$(against)" \
 318                         "AR=$(AR)" \
 319                         "AR_FLAGS=$(AR_FLAGS)" \
 320                         "CC=$(CC)" \
 321                         "RANLIB=$(RANLIB)" \
 322                         "LOADLIBES=$(LOADLIBES)" \
 323                         "LDFLAGS=$(LDFLAGS)" \
 324                         "BISON=$(BISON)" \
 325                         "MAKEINFO=$(MAKEINFO)" \
 326                         install) ; \
 327         else \
 328                 true ; \
 329         fi
 330
 331 ### binutils
 332 .PHONY: all-binutils stmp-binutils
 333 all-binutils: stmp-libiberty stmp-bfd stmp-binutils
 334 stmp-binutils:
 335         if [ -d ./binutils ] ; then \
 336                 rootme=`pwd` ; export rootme ; \
 337                 (cd ./binutils; \
 338                 $(MAKE) \
 339                         "against=$(against)" \
 340                         "AR=$(AR)" \
 341                         "AR_FLAGS=$(AR_FLAGS)" \
 342                         "CC=$(CC)" \
 343                         "RANLIB=$(RANLIB)" \
 344                         "LOADLIBES=$(LOADLIBES)" \
 345                         "LDFLAGS=$(LDFLAGS)" \
 346                         "BISON=$(BISON)" \
 347                         "MAKEINFO=$(MAKEINFO)" \
 348                         all) ; \
 349         else \
 350                 true ; \
 351         fi
 352         touch stmp-binutils
 353
 354 clean-binutils: force
 355         if [ -d ./binutils ] ; then \
 356                 rootme=`pwd` ; export rootme ; \
 357                 (cd ./binutils; \
 358                 $(MAKE) \
 359                         "against=$(against)" \
 360                         "AR=$(AR)" \
 361                         "AR_FLAGS=$(AR_FLAGS)" \
 362                         "CC=$(CC)" \
 363                         "RANLIB=$(RANLIB)" \
 364                         "LOADLIBES=$(LOADLIBES)" \
 365                         "LDFLAGS=$(LDFLAGS)" \
 366                         "BISON=$(BISON)" \
 367                         "MAKEINFO=$(MAKEINFO)" \
 368                         clean) ; \
 369         else \
 370                 true ; \
 371         fi
 372
 373 install-binutils: force
 374         if [ -d ./binutils ] ; then \
 375                 rootme=`pwd` ; export rootme ; \
 376                 (cd ./binutils; \
 377                 $(MAKE) \
 378                         "against=$(against)" \
 379                         "AR=$(AR)" \
 380                         "AR_FLAGS=$(AR_FLAGS)" \
 381                         "CC=$(CC)" \
 382                         "RANLIB=$(RANLIB)" \
 383                         "LOADLIBES=$(LOADLIBES)" \
 384                         "LDFLAGS=$(LDFLAGS)" \
 385                         "BISON=$(BISON)" \
 386                         "MAKEINFO=$(MAKEINFO)" \
 387                         install) ; \
 388         else \
 389                 true ; \
 390         fi
 391
 392 ### newlib
 393 .PHONY: all-newlib stmp-newlib
 394 all-newlib: stmp-newlib
 395 stmp-newlib:
 396         if [ -d ./newlib ] ; then \
 397                 rootme=`pwd` ; export rootme ; \
 398                 (cd ./newlib; \
 399                 $(MAKE) \
 400                         "against=$(against)" \
 401                         "AR=$(AR)" \
 402                         "AR_FLAGS=$(AR_FLAGS)" \
 403                         "CC=$(CC)" \
 404                         "RANLIB=$(RANLIB)" \
 405                         "LOADLIBES=$(LOADLIBES)" \
 406                         "LDFLAGS=$(LDFLAGS)" \
 407                         "BISON=$(BISON)" \
 408                         "MAKEINFO=$(MAKEINFO)" \
 409                         all) ; \
 410         else \
 411                 true ; \
 412         fi
 413         touch stmp-newlib
 414
 415 clean-newlib: force
 416         if [ -d ./newlib ] ; then \
 417                 rootme=`pwd` ; export rootme ; \
 418                 (cd ./newlib; \
 419                 $(MAKE) \
 420                         "against=$(against)" \
 421                         "AR=$(AR)" \
 422                         "AR_FLAGS=$(AR_FLAGS)" \
 423                         "CC=$(CC)" \
 424                         "RANLIB=$(RANLIB)" \
 425                         "LOADLIBES=$(LOADLIBES)" \
 426                         "LDFLAGS=$(LDFLAGS)" \
 427                         "BISON=$(BISON)" \
 428                         "MAKEINFO=$(MAKEINFO)" \
 429                         clean) ; \
 430         else \
 431                 true ; \
 432         fi
 433
 434 install-newlib: force
 435         if [ -d ./newlib ] ; then \
 436                 rootme=`pwd` ; export rootme ; \
 437                 (cd ./newlib; \
 438                 $(MAKE) \
 439                         "against=$(against)" \
 440                         "AR=$(AR)" \
 441                         "AR_FLAGS=$(AR_FLAGS)" \
 442                         "CC=$(CC)" \
 443                         "RANLIB=$(RANLIB)" \
 444                         "LOADLIBES=$(LOADLIBES)" \
 445                         "LDFLAGS=$(LDFLAGS)" \
 446                         "BISON=$(BISON)" \
 447                         "MAKEINFO=$(MAKEINFO)" \
 448                         install) ; \
 449         else \
 450                 true ; \
 451         fi
 452
 453 ### byacc
 454 .PHONY: all-byacc stmp-byacc
 455 all-byacc: stmp-byacc
 456 stmp-byacc:
 457         if [ -d ./byacc ] ; then \
 458                 rootme=`pwd` ; export rootme ; \
 459                 (cd ./byacc; \
 460                 $(MAKE) \
 461                         "against=$(against)" \
 462                         "AR=$(AR)" \
 463                         "AR_FLAGS=$(AR_FLAGS)" \
 464                         "CC=$(CC)" \
 465                         "RANLIB=$(RANLIB)" \
 466                         "LOADLIBES=$(LOADLIBES)" \
 467                         "LDFLAGS=$(LDFLAGS)" \
 468                         "BISON=$(BISON)" \
 469                         "MAKEINFO=$(MAKEINFO)" \
 470                         all) ; \
 471         else \
 472                 true ; \
 473         fi
 474         touch stmp-byacc
 475
 476 clean-byacc: force
 477         if [ -d ./byacc ] ; then \
 478                 rootme=`pwd` ; export rootme ; \
 479                 (cd ./byacc; \
 480                 $(MAKE) \
 481                         "against=$(against)" \
 482                         "AR=$(AR)" \
 483                         "AR_FLAGS=$(AR_FLAGS)" \
 484                         "CC=$(CC)" \
 485                         "RANLIB=$(RANLIB)" \
 486                         "LOADLIBES=$(LOADLIBES)" \
 487                         "LDFLAGS=$(LDFLAGS)" \
 488                         "BISON=$(BISON)" \
 489                         "MAKEINFO=$(MAKEINFO)" \
 490                         clean) ; \
 491         else \
 492                 true ; \
 493         fi
 494
 495 install-byacc: force
 496         if [ -d ./byacc ] ; then \
 497                 rootme=`pwd` ; export rootme ; \
 498                 (cd ./byacc; \
 499                 $(MAKE) \
 500                         "against=$(against)" \
 501                         "AR=$(AR)" \
 502                         "AR_FLAGS=$(AR_FLAGS)" \
 503                         "CC=$(CC)" \
 504                         "RANLIB=$(RANLIB)" \
 505                         "LOADLIBES=$(LOADLIBES)" \
 506                         "LDFLAGS=$(LDFLAGS)" \
 507                         "BISON=$(BISON)" \
 508                         "MAKEINFO=$(MAKEINFO)" \
 509                         install) ; \
 510         else \
 511                 true ; \
 512         fi
 513
 514 ### bison
 515 .PHONY: all-bison stmp-bison
 516 all-bison: stmp-libiberty stmp-bison
 517 stmp-bison:
 518         if [ -d ./bison ] ; then \
 519                 rootme=`pwd` ; export rootme ; \
 520                 (cd ./bison; \
 521                 $(MAKE) \
 522                         "prefix=$(prefix)" \
 523                         "datadir=$(datadir)" \
 524                         "AR=$(AR)" \
 525                         "AR_FLAGS=$(AR_FLAGS)" \
 526                         "CC=$(CC)" \
 527                         "RANLIB=$(RANLIB)" \
 528                         "LOADLIBES=$(LOADLIBES)" \
 529                         "LDFLAGS=$(LDFLAGS)" \
 530                         "BISON=$(BISON)" \
 531                         "MAKEINFO=$(MAKEINFO)" \
 532                         all) ; \
 533         else \
 534                 true ; \
 535         fi
 536         touch stmp-bison
 537
 538 clean-bison: force
 539         if [ -d ./bison ] ; then \
 540                 rootme=`pwd` ; export rootme ; \
 541                 (cd ./bison; \
 542                 $(MAKE) \
 543                         "prefix=$(prefix)" \
 544                         "datadir=$(datadir)" \
 545                         "AR=$(AR)" \
 546                         "AR_FLAGS=$(AR_FLAGS)" \
 547                         "CC=$(CC)" \
 548                         "RANLIB=$(RANLIB)" \
 549                         "LOADLIBES=$(LOADLIBES)" \
 550                         "LDFLAGS=$(LDFLAGS)" \
 551                         "BISON=$(BISON)" \
 552                         "MAKEINFO=$(MAKEINFO)" \
 553                         clean) ; \
 554         else \
 555                 true ; \
 556         fi
 557
 558 install-bison: force
 559         if [ -d ./bison ] ; then \
 560                 rootme=`pwd` ; export rootme ; \
 561                 (cd ./bison; \
 562                 $(MAKE) \
 563                         "prefix=$(prefix)" \
 564                         "datadir=$(datadir)" \
 565                         "AR=$(AR)" \
 566                         "AR_FLAGS=$(AR_FLAGS)" \
 567                         "CC=$(CC)" \
 568                         "RANLIB=$(RANLIB)" \
 569                         "LOADLIBES=$(LOADLIBES)" \
 570                         "LDFLAGS=$(LDFLAGS)" \
 571                         "BISON=$(BISON)" \
 572                         "MAKEINFO=$(MAKEINFO)" \
 573                         install) ; \
 574         else \
 575                 true ; \
 576         fi
 577
 578 ### gcc
 579 .PHONY: all-gcc stmp-gcc
 580 all-gcc: stmp-libiberty stmp-bison stmp-gas
 581 stmp-gcc:
 582         if [ -d ./gcc ] ; then \
 583                 rootme=`pwd` ; export rootme ; \
 584                 (cd ./gcc; \
 585                 $(MAKE) \
 586                         "against=$(against)" \
 587                         "AR=$(AR)" \
 588                         "AR_FLAGS=$(AR_FLAGS)" \
 589                         "CC=$(CC)" \
 590                         "RANLIB=$(RANLIB)" \
 591                         "LOADLIBES=$(LOADLIBES)" \
 592                         "LDFLAGS=$(LDFLAGS)" \
 593                         "BISON=$(BISON)" \
 594                         "MAKEINFO=$(MAKEINFO)" \
 595                         all) ; \
 596         else \
 597                 true ; \
 598         fi
 599         touch stmp-gcc
 600
 601 clean-gcc: force
 602         if [ -d ./gcc ] ; then \
 603                 rootme=`pwd` ; export rootme ; \
 604                 (cd ./gcc; \
 605                 $(MAKE) \
 606                         "against=$(against)" \
 607                         "AR=$(AR)" \
 608                         "AR_FLAGS=$(AR_FLAGS)" \
 609                         "CC=$(CC)" \
 610                         "RANLIB=$(RANLIB)" \
 611                         "LOADLIBES=$(LOADLIBES)" \
 612                         "LDFLAGS=$(LDFLAGS)" \
 613                         "BISON=$(BISON)" \
 614                         "MAKEINFO=$(MAKEINFO)" \
 615                         clean) ; \
 616         else \
 617                 true ; \
 618         fi
 619
 620 install-gcc:
 621         if [ -d ./gcc ] ; then \
 622                 rootme=`pwd` ; export rootme ; \
 623                 (cd ./gcc; \
 624                 $(MAKE) \
 625                         "against=$(against)" \
 626                         "AR=$(AR)" \
 627                         "AR_FLAGS=$(AR_FLAGS)" \
 628                         "CC=$(CC)" \
 629                         "RANLIB=$(RANLIB)" \
 630                         "LOADLIBES=$(LOADLIBES)" \
 631                         "LDFLAGS=$(LDFLAGS)" \
 632                         "BISON=$(BISON)" \
 633                         "MAKEINFO=$(MAKEINFO)" \
 634                         install) ; \
 635         else \
 636                 true ; \
 637         fi
 638
 639 ### readline
 640 .PHONY: all-readline stmp-readline
 641 all-readline: stmp-readline
 642 stmp-readline:
 643         if [ -d ./readline ] ; then \
 644                 rootme=`pwd` ; export rootme ; \
 645                 (cd ./readline; \
 646                 $(MAKE) \
 647                         "against=$(against)" \
 648                         "AR=$(AR)" \
 649                         "AR_FLAGS=$(AR_FLAGS)" \
 650                         "CC=$(CC)" \
 651                         "RANLIB=$(RANLIB)" \
 652                         "LOADLIBES=$(LOADLIBES)" \
 653                         "LDFLAGS=$(LDFLAGS)" \
 654                         "BISON=$(BISON)" \
 655                         "MAKEINFO=$(MAKEINFO)" \
 656                         all) ; \
 657         else \
 658                 true ; \
 659         fi
 660         touch stmp-readline
 661
 662 clean-readline: force
 663         if [ -d ./readline ] ; then \
 664                 rootme=`pwd` ; export rootme ; \
 665                 (cd ./readline; \
 666                 $(MAKE) \
 667                         "against=$(against)" \
 668                         "AR=$(AR)" \
 669                         "AR_FLAGS=$(AR_FLAGS)" \
 670                         "CC=$(CC)" \
 671                         "RANLIB=$(RANLIB)" \
 672                         "LOADLIBES=$(LOADLIBES)" \
 673                         "LDFLAGS=$(LDFLAGS)" \
 674                         "BISON=$(BISON)" \
 675                         "MAKEINFO=$(MAKEINFO)" \
 676                         clean) ; \
 677         else \
 678                 true ; \
 679         fi
 680
 681 install-readline: force
 682         if [ -d ./readline ] ; then \
 683                 rootme=`pwd` ; export rootme ; \
 684                 (cd ./readline; \
 685                 $(MAKE) \
 686                         "against=$(against)" \
 687                         "AR=$(AR)" \
 688                         "AR_FLAGS=$(AR_FLAGS)" \
 689                         "CC=$(CC)" \
 690                         "RANLIB=$(RANLIB)" \
 691                         "LOADLIBES=$(LOADLIBES)" \
 692                         "LDFLAGS=$(LDFLAGS)" \
 693                         "BISON=$(BISON)" \
 694                         "MAKEINFO=$(MAKEINFO)" \
 695                         install) ; \
 696         else \
 697                 true ; \
 698         fi
 699
 700 ### glob
 701 .PHONY: all-glob stmp-glob
 702 all-glob: stmp-glob
 703 stmp-glob:
 704         if [ -d ./glob ] ; then \
 705                 rootme=`pwd` ; export rootme ; \
 706                 (cd ./glob; \
 707                 $(MAKE) \
 708                         "against=$(against)" \
 709                         "AR=$(AR)" \
 710                         "AR_FLAGS=$(AR_FLAGS)" \
 711                         "CC=$(CC)" \
 712                         "RANLIB=$(RANLIB)" \
 713                         "LOADLIBES=$(LOADLIBES)" \
 714                         "LDFLAGS=$(LDFLAGS)" \
 715                         "BISON=$(BISON)" \
 716                         "MAKEINFO=$(MAKEINFO)" \
 717                         all) ; \
 718         else \
 719                 true ; \
 720         fi
 721         touch stmp-glob
 722
 723 clean-glob: force
 724         if [ -d ./glob ] ; then \
 725                 rootme=`pwd` ; export rootme ; \
 726                 (cd ./glob; \
 727                 $(MAKE) \
 728                         "against=$(against)" \
 729                         "AR=$(AR)" \
 730                         "AR_FLAGS=$(AR_FLAGS)" \
 731                         "CC=$(CC)" \
 732                         "RANLIB=$(RANLIB)" \
 733                         "LOADLIBES=$(LOADLIBES)" \
 734                         "LDFLAGS=$(LDFLAGS)" \
 735                         "BISON=$(BISON)" \
 736                         "MAKEINFO=$(MAKEINFO)" \
 737                         clean) ; \
 738         else \
 739                 true ; \
 740         fi
 741
 742 install-glob: force
 743         if [ -d ./glob ] ; then \
 744                 rootme=`pwd` ; export rootme ; \
 745                 (cd ./glob; \
 746                 $(MAKE) \
 747                         "against=$(against)" \
 748                         "AR=$(AR)" \
 749                         "AR_FLAGS=$(AR_FLAGS)" \
 750                         "CC=$(CC)" \
 751                         "RANLIB=$(RANLIB)" \
 752                         "LOADLIBES=$(LOADLIBES)" \
 753                         "LDFLAGS=$(LDFLAGS)" \
 754                         "BISON=$(BISON)" \
 755                         "MAKEINFO=$(MAKEINFO)" \
 756                         install) ; \
 757         else \
 758                 true ; \
 759         fi
 760
 761 ### gas
 762 .PHONY: all-gas stmp-gas
 763 all-gas: stmp-libiberty stmp-bfd stmp-gas
 764 stmp-gas:
 765         if [ -d ./gas ] ; then \
 766                 rootme=`pwd` ; export rootme ; \
 767                 (cd ./gas; \
 768                 $(MAKE) \
 769                         "against=$(against)" \
 770                         "AR=$(AR)" \
 771                         "AR_FLAGS=$(AR_FLAGS)" \
 772                         "CC=$(CC)" \
 773                         "RANLIB=$(RANLIB)" \
 774                         "LOADLIBES=$(LOADLIBES)" \
 775                         "LDFLAGS=$(LDFLAGS)" \
 776                         "BISON=$(BISON)" \
 777                         "MAKEINFO=$(MAKEINFO)" \
 778                         all) ; \
 779         else \
 780                 true ; \
 781         fi
 782         touch stmp-gas
 783
 784 clean-gas: force
 785         if [ -d ./gas ] ; then \
 786                 rootme=`pwd` ; export rootme ; \
 787                 (cd ./gas; \
 788                 $(MAKE) \
 789                         "against=$(against)" \
 790                         "AR=$(AR)" \
 791                         "AR_FLAGS=$(AR_FLAGS)" \
 792                         "CC=$(CC)" \
 793                         "RANLIB=$(RANLIB)" \
 794                         "LOADLIBES=$(LOADLIBES)" \
 795                         "LDFLAGS=$(LDFLAGS)" \
 796                         "BISON=$(BISON)" \
 797                         "MAKEINFO=$(MAKEINFO)" \
 798                         clean) ; \
 799         else \
 800                 true ; \
 801         fi
 802
 803 install-gas: force
 804         if [ -d ./gas ] ; then \
 805                 rootme=`pwd` ; export rootme ; \
 806                 (cd ./gas; \
 807                 $(MAKE) \
 808                         "against=$(against)" \
 809                         "AR=$(AR)" \
 810                         "AR_FLAGS=$(AR_FLAGS)" \
 811                         "CC=$(CC)" \
 812                         "RANLIB=$(RANLIB)" \
 813                         "LOADLIBES=$(LOADLIBES)" \
 814                         "LDFLAGS=$(LDFLAGS)" \
 815                         "BISON=$(BISON)" \
 816                         "MAKEINFO=$(MAKEINFO)" \
 817                         install) ; \
 818         else \
 819                 true ; \
 820         fi
 821
 822 ### ld
 823 .PHONY: all-ld stmp-ld
 824 all-ld: stmp-libiberty stmp-bfd stmp-bison stmp-ld
 825 stmp-ld:
 826         if [ -d ./ld ] ; then \
 827                 rootme=`pwd` ; export rootme ; \
 828                 (cd ./ld; \
 829                 $(MAKE) \
 830                         "against=$(against)" \
 831                         "AR=$(AR)" \
 832                         "AR_FLAGS=$(AR_FLAGS)" \
 833                         "CC=$(CC)" \
 834                         "RANLIB=$(RANLIB)" \
 835                         "LOADLIBES=$(LOADLIBES)" \
 836                         "LDFLAGS=$(LDFLAGS)" \
 837                         "BISON=$(BISON)" \
 838                         "MAKEINFO=$(MAKEINFO)" \
 839                         all) ; \
 840         else \
 841                 true ; \
 842         fi
 843         touch stmp-ld
 844
 845 clean-ld: force
 846         if [ -d ./ld ] ; then \
 847                 rootme=`pwd` ; export rootme ; \
 848                 (cd ./ld; \
 849                 $(MAKE) \
 850                         "against=$(against)" \
 851                         "AR=$(AR)" \
 852                         "AR_FLAGS=$(AR_FLAGS)" \
 853                         "CC=$(CC)" \
 854                         "RANLIB=$(RANLIB)" \
 855                         "LOADLIBES=$(LOADLIBES)" \
 856                         "LDFLAGS=$(LDFLAGS)" \
 857                         "BISON=$(BISON)" \
 858                         "MAKEINFO=$(MAKEINFO)" \
 859                         clean) ; \
 860         else \
 861                 true ; \
 862         fi
 863
 864 install-ld: force
 865         if [ -d ./ld ] ; then \
 866                 rootme=`pwd` ; export rootme ; \
 867                 (cd ./ld; \
 868                 $(MAKE) \
 869                         "against=$(against)" \
 870                         "AR=$(AR)" \
 871                         "AR_FLAGS=$(AR_FLAGS)" \
 872                         "CC=$(CC)" \
 873                         "RANLIB=$(RANLIB)" \
 874                         "LOADLIBES=$(LOADLIBES)" \
 875                         "LDFLAGS=$(LDFLAGS)" \
 876                         "BISON=$(BISON)" \
 877                         "MAKEINFO=$(MAKEINFO)" \
 878                         install) ; \
 879         else \
 880                 true ; \
 881         fi
 882
 883 ### libgcc (and libgcc1)
 884 .PHONY: all-libgcc stmp-libgcc1 stmp-libgcc
 885 all-libgcc1: all-gas all-binutils stmp-libgcc1
 886 stmp-libgcc1:
 887         if [ -d ./libgcc ] ; then \
 888                 rootme=`pwd` ; export rootme ; \
 889                 (cd ./libgcc; \
 890                 $(MAKE) \
 891                         "against=$(against)" \
 892                         "AR=$(AR)" \
 893                         "AR_FLAGS=$(AR_FLAGS)" \
 894                         "CC=$(CC)" \
 895                         "RANLIB=$(RANLIB)" \
 896                         "LOADLIBES=$(LOADLIBES)" \
 897                         "LDFLAGS=$(LDFLAGS)" \
 898                         "BISON=$(BISON)" \
 899                         "MAKEINFO=$(MAKEINFO)" \
 900                         libgcc1.a) ; \
 901         else \
 902                 true ; \
 903         fi
 904         touch stmp-libgcc1
 905
 906 clean-libgcc1: force
 907         if [ -d ./libgcc ] ; then \
 908                 rootme=`pwd` ; export rootme ; \
 909                 (cd ./libgcc; \
 910                 $(MAKE) \
 911                         "against=$(against)" \
 912                         "AR=$(AR)" \
 913                         "AR_FLAGS=$(AR_FLAGS)" \
 914                         "CC=$(CC)" \
 915                         "RANLIB=$(RANLIB)" \
 916                         "LOADLIBES=$(LOADLIBES)" \
 917                         "LDFLAGS=$(LDFLAGS)" \
 918                         "BISON=$(BISON)" \
 919                         "MAKEINFO=$(MAKEINFO)" \
 920                         clean-libgcc1) ; \
 921         else \
 922                 true ; \
 923         fi
 924
 925 install-libgcc1: force
 926         echo libgcc1 is a component, not an installable target
 927
 928 all-libgcc: all-gas all-gcc all-binutils stmp-libgcc
 929 stmp-libgcc:
 930         true
 931         if [ -d ./libgcc ] ; then \
 932                 rootme=`pwd` ; export rootme ; \
 933                 (cd ./libgcc; \
 934                 $(MAKE) \
 935                         "against=$(against)" \
 936                         "AR=$(AR)" \
 937                         "AR_FLAGS=$(AR_FLAGS)" \
 938                         "CC=$(CC)" \
 939                         "RANLIB=$(RANLIB)" \
 940                         "LOADLIBES=$(LOADLIBES)" \
 941                         "LDFLAGS=$(LDFLAGS)" \
 942                         "BISON=$(BISON)" \
 943                         "MAKEINFO=$(MAKEINFO)" \
 944                         all) ; \
 945         else \
 946                 true ; \
 947         fi
 948         touch stmp-libgcc
 949
 950 clean-libgcc: force
 951         if [ -d ./libgcc ] ; then \
 952                 rootme=`pwd` ; export rootme ; \
 953                 (cd ./libgcc; \
 954                 $(MAKE) \
 955                         "against=$(against)" \
 956                         "AR=$(AR)" \
 957                         "AR_FLAGS=$(AR_FLAGS)" \
 958                         "CC=$(CC)" \
 959                         "RANLIB=$(RANLIB)" \
 960                         "LOADLIBES=$(LOADLIBES)" \
 961                         "LDFLAGS=$(LDFLAGS)" \
 962                         "BISON=$(BISON)" \
 963                         "MAKEINFO=$(MAKEINFO)" \
 964                         clean) ; \
 965         else \
 966                 true ; \
 967         fi
 968
 969 install-libgcc: force
 970         if [ -d ./libgcc ] ; then \
 971                 rootme=`pwd` ; export rootme ; \
 972                 (cd ./libgcc; \
 973                 $(MAKE) \
 974                         "against=$(against)" \
 975                         "AR=$(AR)" \
 976                         "AR_FLAGS=$(AR_FLAGS)" \
 977                         "CC=$(CC)" \
 978                         "RANLIB=$(RANLIB)" \
 979                         "LOADLIBES=$(LOADLIBES)" \
 980                         "LDFLAGS=$(LDFLAGS)" \
 981                         "BISON=$(BISON)" \
 982                         "MAKEINFO=$(MAKEINFO)" \
 983                         install) ; \
 984         else \
 985                 true ; \
 986         fi
 987
 988 ### gdb
 989 .PHONY: all-gdb stmp-gdb
 990 all-gdb: stmp-bfd stmp-libiberty stmp-readline stmp-glob stmp-bison stmp-gdb
 991 stmp-gdb:
 992         if [ -d ./gdb ] ; then \
 993                 rootme=`pwd` ; export rootme ; \
 994                 (cd ./gdb; \
 995                 $(MAKE) \
 996                         "against=$(against)" \
 997                         "AR=$(AR)" \
 998                         "AR_FLAGS=$(AR_FLAGS)" \
 999                         "CC=$(CC)" \
1000                         "RANLIB=$(RANLIB)" \
1001                         "LOADLIBES=$(LOADLIBES)" \
1002                         "LDFLAGS=$(LDFLAGS)" \
1003                         "BISON=$(BISON)" \
1004                         "MAKEINFO=$(MAKEINFO)" \
1005                         all) ; \
1006         else \
1007                 true ; \
1008         fi
1009         touch stmp-gdb
1010
1011 clean-gdb: force
1012         if [ -d ./gdb ] ; then \
1013                 rootme=`pwd` ; export rootme ; \
1014                 (cd ./gdb; \
1015                 $(MAKE) \
1016                         "against=$(against)" \
1017                         "AR=$(AR)" \
1018                         "AR_FLAGS=$(AR_FLAGS)" \
1019                         "CC=$(CC)" \
1020                         "RANLIB=$(RANLIB)" \
1021                         "LOADLIBES=$(LOADLIBES)" \
1022                         "LDFLAGS=$(LDFLAGS)" \
1023                         "BISON=$(BISON)" \
1024                         "MAKEINFO=$(MAKEINFO)" \
1025                         clean) ; \
1026         else \
1027                 true ; \
1028         fi
1029
1030 install-gdb: force
1031         if [ -d ./gdb ] ; then \
1032                 rootme=`pwd` ; export rootme ; \
1033                 (cd ./gdb; \
1034                 $(MAKE) \
1035                         "against=$(against)" \
1036                         "AR=$(AR)" \
1037                         "AR_FLAGS=$(AR_FLAGS)" \
1038                         "CC=$(CC)" \
1039                         "RANLIB=$(RANLIB)" \
1040                         "LOADLIBES=$(LOADLIBES)" \
1041                         "LDFLAGS=$(LDFLAGS)" \
1042                         "BISON=$(BISON)" \
1043                         "MAKEINFO=$(MAKEINFO)" \
1044                         install) ; \
1045         else \
1046                 true ; \
1047         fi
1048
1049 ### make
1050 .PHONY: all-make stmp-make
1051 all-make: all-libiberty stmp-make
1052 stmp-make:
1053         if [ -d ./make ] ; then \
1054                 rootme=`pwd` ; export rootme ; \
1055                 (cd ./make; \
1056                 $(MAKE) \
1057                         "against=$(against)" \
1058                         "AR=$(AR)" \
1059                         "AR_FLAGS=$(AR_FLAGS)" \
1060                         "CC=$(CC)" \
1061                         "RANLIB=$(RANLIB)" \
1062                         "LOADLIBES=$(LOADLIBES)" \
1063                         "LDFLAGS=$(LDFLAGS)" \
1064                         "BISON=$(BISON)" \
1065                         "MAKEINFO=$(MAKEINFO)" \
1066                         all) ; \
1067         else \
1068                 true ; \
1069         fi
1070         touch stmp-make
1071
1072 clean-make: force
1073         if [ -d ./make ] ; then \
1074                 rootme=`pwd` ; export rootme ; \
1075                 (cd ./make; \
1076                 $(MAKE) \
1077                         "against=$(against)" \
1078                         "AR=$(AR)" \
1079                         "AR_FLAGS=$(AR_FLAGS)" \
1080                         "CC=$(CC)" \
1081                         "RANLIB=$(RANLIB)" \
1082                         "LOADLIBES=$(LOADLIBES)" \
1083                         "LDFLAGS=$(LDFLAGS)" \
1084                         "BISON=$(BISON)" \
1085                         "MAKEINFO=$(MAKEINFO)" \
1086                         clean) ; \
1087         else \
1088                 true ; \
1089         fi
1090
1091 install-make: force
1092         if [ -d ./make ] ; then \
1093                 rootme=`pwd` ; export rootme ; \
1094                 (cd ./make; \
1095                 $(MAKE) \
1096                         "against=$(against)" \
1097                         "AR=$(AR)" \
1098                         "AR_FLAGS=$(AR_FLAGS)" \
1099                         "CC=$(CC)" \
1100                         "RANLIB=$(RANLIB)" \
1101                         "LOADLIBES=$(LOADLIBES)" \
1102                         "LDFLAGS=$(LDFLAGS)" \
1103                         "BISON=$(BISON)" \
1104                         "MAKEINFO=$(MAKEINFO)" \
1105                         install) ; \
1106         else \
1107                 true ; \
1108         fi
1109
1110 ### diff
1111 .PHONY: all-diff stmp-diff
1112 all-diff: stmp-diff
1113 stmp-diff:
1114         if [ -d ./diff ] ; then \
1115                 rootme=`pwd` ; export rootme ; \
1116                 (cd ./diff; \
1117                 $(MAKE) \
1118                         "against=$(against)" \
1119                         "AR=$(AR)" \
1120                         "AR_FLAGS=$(AR_FLAGS)" \
1121                         "CC=$(CC)" \
1122                         "RANLIB=$(RANLIB)" \
1123                         "LOADLIBES=$(LOADLIBES)" \
1124                         "LDFLAGS=$(LDFLAGS)" \
1125                         "BISON=$(BISON)" \
1126                         "MAKEINFO=$(MAKEINFO)" \
1127                         all) ; \
1128         else \
1129                 true ; \
1130         fi
1131         touch stmp-diff
1132
1133 clean-diff: force
1134         if [ -d ./diff ] ; then \
1135                 rootme=`pwd` ; export rootme ; \
1136                 (cd ./diff; \
1137                 $(MAKE) \
1138                         "against=$(against)" \
1139                         "AR=$(AR)" \
1140                         "AR_FLAGS=$(AR_FLAGS)" \
1141                         "CC=$(CC)" \
1142                         "RANLIB=$(RANLIB)" \
1143                         "LOADLIBES=$(LOADLIBES)" \
1144                         "LDFLAGS=$(LDFLAGS)" \
1145                         "BISON=$(BISON)" \
1146                         "MAKEINFO=$(MAKEINFO)" \
1147                         clean) ; \
1148         else \
1149                 true ; \
1150         fi
1151
1152 install-diff: force
1153         if [ -d ./diff ] ; then \
1154                 rootme=`pwd` ; export rootme ; \
1155                 (cd ./diff/; \
1156                 $(MAKE) \
1157                         "against=$(against)" \
1158                         "AR=$(AR)" \
1159                         "AR_FLAGS=$(AR_FLAGS)" \
1160                         "CC=$(CC)" \
1161                         "RANLIB=$(RANLIB)" \
1162                         "LOADLIBES=$(LOADLIBES)" \
1163                         "LDFLAGS=$(LDFLAGS)" \
1164                         "BISON=$(BISON)" \
1165                         "MAKEINFO=$(MAKEINFO)" \
1166                         install) ; \
1167         else \
1168                 true ; \
1169         fi
1170
1171 ### grep
1172 .PHONY: all-grep stmp-grep
1173 all-grep: stmp-grep
1174 stmp-grep:
1175         if [ -d ./grep ] ; then \
1176                 rootme=`pwd` ; export rootme ; \
1177                 (cd ./grep; \
1178                 $(MAKE) \
1179                         "against=$(against)" \
1180                         "AR=$(AR)" \
1181                         "AR_FLAGS=$(AR_FLAGS)" \
1182                         "CC=$(CC)" \
1183                         "RANLIB=$(RANLIB)" \
1184                         "LOADLIBES=$(LOADLIBES)" \
1185                         "LDFLAGS=$(LDFLAGS)" \
1186                         "BISON=$(BISON)" \
1187                         "MAKEINFO=$(MAKEINFO)" \
1188                         all) ; \
1189         else \
1190                 true ; \
1191         fi
1192         touch stmp-grep
1193
1194 clean-grep: force
1195         if [ -d ./grep ] ; then \
1196                 rootme=`pwd` ; export rootme ; \
1197                 (cd ./grep; \
1198                 $(MAKE) \
1199                         "against=$(against)" \
1200                         "AR=$(AR)" \
1201                         "AR_FLAGS=$(AR_FLAGS)" \
1202                         "CC=$(CC)" \
1203                         "RANLIB=$(RANLIB)" \
1204                         "LOADLIBES=$(LOADLIBES)" \
1205                         "LDFLAGS=$(LDFLAGS)" \
1206                         "BISON=$(BISON)" \
1207                         "MAKEINFO=$(MAKEINFO)" \
1208                         clean) ; \
1209         else \
1210                 true ; \
1211         fi
1212
1213 install-grep: force
1214         if [ -d ./grep ] ; then \
1215                 rootme=`pwd` ; export rootme ; \
1216                 (cd ./grep; \
1217                 $(MAKE) \
1218                         "against=$(against)" \
1219                         "AR=$(AR)" \
1220                         "AR_FLAGS=$(AR_FLAGS)" \
1221                         "CC=$(CC)" \
1222                         "RANLIB=$(RANLIB)" \
1223                         "LOADLIBES=$(LOADLIBES)" \
1224                         "LDFLAGS=$(LDFLAGS)" \
1225                         "BISON=$(BISON)" \
1226                         "MAKEINFO=$(MAKEINFO)" \
1227                         install) ; \
1228         else \
1229                 true ; \
1230         fi
1231
1232 ### rcs
1233 .PHONY: all-rcs stmp-rcs
1234 all-rcs: stmp-diff stmp-grep stmp-rcs
1235 stmp-rcs:
1236         if [ -d ./rcs ] ; then \
1237                 rootme=`pwd` ; export rootme ; \
1238                 (cd ./rcs; \
1239                 $(MAKE) \
1240                         "against=$(against)" \
1241                         "AR=$(AR)" \
1242                         "AR_FLAGS=$(AR_FLAGS)" \
1243                         "CC=$(CC)" \
1244                         "RANLIB=$(RANLIB)" \
1245                         "LOADLIBES=$(LOADLIBES)" \
1246                         "LDFLAGS=$(LDFLAGS)" \
1247                         "BISON=$(BISON)" \
1248                         "MAKEINFO=$(MAKEINFO)" \
1249                         all) ; \
1250         else \
1251                 true ; \
1252         fi
1253         touch stmp-rcs
1254
1255 clean-rcs: force
1256         if [ -d ./rcs ] ; then \
1257                 rootme=`pwd` ; export rootme ; \
1258                 (cd ./rcs; \
1259                 $(MAKE) \
1260                         "against=$(against)" \
1261                         "AR=$(AR)" \
1262                         "AR_FLAGS=$(AR_FLAGS)" \
1263                         "CC=$(CC)" \
1264                         "RANLIB=$(RANLIB)" \
1265                         "LOADLIBES=$(LOADLIBES)" \
1266                         "LDFLAGS=$(LDFLAGS)" \
1267                         "BISON=$(BISON)" \
1268                         "MAKEINFO=$(MAKEINFO)" \
1269                         clean) ; \
1270         else \
1271                 true ; \
1272         fi
1273
1274 install-rcs: install-grep install-diff force
1275         if [ -d ./rcs ] ; then \
1276                 rootme=`pwd` ; export rootme ; \
1277                 (cd ./rcs; \
1278                 $(MAKE) \
1279                         "against=$(against)" \
1280                         "AR=$(AR)" \
1281                         "AR_FLAGS=$(AR_FLAGS)" \
1282                         "CC=$(CC)" \
1283                         "RANLIB=$(RANLIB)" \
1284                         "LOADLIBES=$(LOADLIBES)" \
1285                         "LDFLAGS=$(LDFLAGS)" \
1286                         "BISON=$(BISON)" \
1287                         "MAKEINFO=$(MAKEINFO)" \
1288                         install) ; \
1289         else \
1290                 true ; \
1291         fi
1292
1293 ### gdbm
1294 .PHONY: all-gdbm stmp-gdbm
1295 all-gdbm: stmp-gdbm
1296 stmp-gdbm: force
1297         if [ -d ./gdbm ] ; then \
1298                 rootme=`pwd` ; export rootme ; \
1299                 (cd ./gdbm; \
1300                 $(MAKE) \
1301                         "against=$(against)" \
1302                         "AR=$(AR)" \
1303                         "AR_FLAGS=$(AR_FLAGS)" \
1304                         "CC=$(CC)" \
1305                         "RANLIB=$(RANLIB)" \
1306                         "LOADLIBES=$(LOADLIBES)" \
1307                         "LDFLAGS=$(LDFLAGS)" \
1308                         "BISON=$(BISON)" \
1309                         "MAKEINFO=$(MAKEINFO)" \
1310                         all) ; \
1311         else \
1312                 true ; \
1313         fi
1314         touch stmp-gdbm
1315
1316 clean-gdbm: force
1317         if [ -d ./gdbm ] ; then \
1318                 rootme=`pwd` ; export rootme ; \
1319                 (cd ./gdbm; \
1320                 $(MAKE) \
1321                         "against=$(against)" \
1322                         "AR=$(AR)" \
1323                         "AR_FLAGS=$(AR_FLAGS)" \
1324                         "CC=$(CC)" \
1325                         "RANLIB=$(RANLIB)" \
1326                         "LOADLIBES=$(LOADLIBES)" \
1327                         "LDFLAGS=$(LDFLAGS)" \
1328                         "BISON=$(BISON)" \
1329                         "MAKEINFO=$(MAKEINFO)" \
1330                         clean) ; \
1331         else \
1332                 true ; \
1333         fi
1334
1335 install-gdbm: force
1336         if [ -d ./gdbm ] ; then \
1337                 rootme=`pwd` ; export rootme ; \
1338                 (cd ./gdbm; \
1339                 $(MAKE) \
1340                         "against=$(against)" \
1341                         "AR=$(AR)" \
1342                         "AR_FLAGS=$(AR_FLAGS)" \
1343                         "CC=$(CC)" \
1344                         "RANLIB=$(RANLIB)" \
1345                         "LOADLIBES=$(LOADLIBES)" \
1346                         "LDFLAGS=$(LDFLAGS)" \
1347                         "BISON=$(BISON)" \
1348                         "MAKEINFO=$(MAKEINFO)" \
1349                         install) ; \
1350         else \
1351                 true ; \
1352         fi
1353
1354 ### cvs
1355 .PHONY: all-cvs stmp-cvs
1356 all-cvs: stmp-cvs stmp-rcs stmp-grep stmp-diff
1357 stmp-cvs: stmp-gdbm force
1358         if [ -d ./cvs ] ; then \
1359                 rootme=`pwd` ; export rootme ; \
1360                 (cd ./cvs; \
1361                 $(MAKE) \
1362                         "against=$(against)" \
1363                         "AR=$(AR)" \
1364                         "AR_FLAGS=$(AR_FLAGS)" \
1365                         "CC=$(CC)" \
1366                         "RANLIB=$(RANLIB)" \
1367                         "LOADLIBES=$(LOADLIBES)" \
1368                         "LDFLAGS=$(LDFLAGS)" \
1369                         "BISON=$(BISON)" \
1370                         "MAKEINFO=$(MAKEINFO)" \
1371                         all) ; \
1372         else \
1373                 true ; \
1374         fi
1375         touch stmp-cvs
1376
1377 clean-cvs: clean-gdbm force
1378         if [ -d ./cvs ] ; then \
1379                 rootme=`pwd` ; export rootme ; \
1380                 (cd ./cvs; \
1381                 $(MAKE) \
1382                         "against=$(against)" \
1383                         "AR=$(AR)" \
1384                         "AR_FLAGS=$(AR_FLAGS)" \
1385                         "CC=$(CC)" \
1386                         "RANLIB=$(RANLIB)" \
1387                         "LOADLIBES=$(LOADLIBES)" \
1388                         "LDFLAGS=$(LDFLAGS)" \
1389                         "BISON=$(BISON)" \
1390                         "MAKEINFO=$(MAKEINFO)" \
1391                         clean) ; \
1392         else \
1393                 true ; \
1394         fi
1395
1396 install-cvs: install-rcs install-gdbm force
1397         if [ -d ./cvs ] ; then \
1398                 rootme=`pwd` ; export rootme ; \
1399                 (cd ./cvs; \
1400                 $(MAKE) \
1401                         "against=$(against)" \
1402                         "AR=$(AR)" \
1403                         "AR_FLAGS=$(AR_FLAGS)" \
1404                         "CC=$(CC)" \
1405                         "RANLIB=$(RANLIB)" \
1406                         "LOADLIBES=$(LOADLIBES)" \
1407                         "LDFLAGS=$(LDFLAGS)" \
1408                         "BISON=$(BISON)" \
1409                         "MAKEINFO=$(MAKEINFO)" \
1410                         install) ; \
1411         else \
1412                 true ; \
1413         fi
1414
1415 ### patch
1416 .PHONY: all-patch stmp-patch
1417 all-patch: stmp-patch
1418 stmp-patch: force
1419         if [ -d ./patch ] ; then \
1420                 rootme=`pwd` ; export rootme ; \
1421                 (cd ./patch; \
1422                 $(MAKE) \
1423                         "against=$(against)" \
1424                         "AR=$(AR)" \
1425                         "AR_FLAGS=$(AR_FLAGS)" \
1426                         "CC=$(CC)" \
1427                         "RANLIB=$(RANLIB)" \
1428                         "LOADLIBES=$(LOADLIBES)" \
1429                         "LDFLAGS=$(LDFLAGS)" \
1430                         "BISON=$(BISON)" \
1431                         "MAKEINFO=$(MAKEINFO)" \
1432                         all) ; \
1433         else \
1434                 true ; \
1435         fi
1436         touch stmp-patch
1437
1438 clean-patch: force
1439         if [ -d ./patch ] ; then \
1440                 rootme=`pwd` ; export rootme ; \
1441                 (cd ./patch; \
1442                 $(MAKE) \
1443                         "against=$(against)" \
1444                         "AR=$(AR)" \
1445                         "AR_FLAGS=$(AR_FLAGS)" \
1446                         "CC=$(CC)" \
1447                         "RANLIB=$(RANLIB)" \
1448                         "LOADLIBES=$(LOADLIBES)" \
1449                         "LDFLAGS=$(LDFLAGS)" \
1450                         "BISON=$(BISON)" \
1451                         "MAKEINFO=$(MAKEINFO)" \
1452                         clean) ; \
1453         else \
1454                 true ; \
1455         fi
1456
1457 install-patch: force
1458         if [ -d ./patch ] ; then \
1459                 rootme=`pwd` ; export rootme ; \
1460                 (cd ./patch; \
1461                 $(MAKE) \
1462                         bindir=$(bindir) \
1463                         man1dir=$(man1dir) \
1464                         "AR=$(AR)" \
1465                         "AR_FLAGS=$(AR_FLAGS)" \
1466                         "CC=$(CC)" \
1467                         "RANLIB=$(RANLIB)" \
1468                         "LOADLIBES=$(LOADLIBES)" \
1469                         "LDFLAGS=$(LDFLAGS)" \
1470                         "BISON=$(BISON)" \
1471                         "MAKEINFO=$(MAKEINFO)" \
1472                         install) ; \
1473         else \
1474                 true ; \
1475         fi
1476
1477 ### emacs
1478 .PHONY: all-emacs stmp-emacs
1479 all-emacs: stmp-emacs
1480 stmp-emacs: force
1481         if [ -d ./emacs ] ; then \
1482                 rootme=`pwd` ; export rootme ; \
1483                 (cd ./emacs; \
1484                 $(MAKE) \
1485                         "against=$(against)" \
1486                         "AR=$(AR)" \
1487                         "AR_FLAGS=$(AR_FLAGS)" \
1488                         "CC=$(CC)" \
1489                         "RANLIB=$(RANLIB)" \
1490                         "LOADLIBES=$(LOADLIBES)" \
1491                         "LDFLAGS=$(LDFLAGS)" \
1492                         "BISON=$(BISON)" \
1493                         "MAKEINFO=$(MAKEINFO)" \
1494                         all) ; \
1495         else \
1496                 true ; \
1497         fi
1498         touch stmp-emacs
1499
1500 clean-emacs: force
1501         if [ -d ./emacs ] ; then \
1502                 rootme=`pwd` ; export rootme ; \
1503                 (cd ./emacs; \
1504                 $(MAKE) \
1505                         "against=$(against)" \
1506                         "AR=$(AR)" \
1507                         "AR_FLAGS=$(AR_FLAGS)" \
1508                         "CC=$(CC)" \
1509                         "RANLIB=$(RANLIB)" \
1510                         "LOADLIBES=$(LOADLIBES)" \
1511                         "LDFLAGS=$(LDFLAGS)" \
1512                         "BISON=$(BISON)" \
1513                         "MAKEINFO=$(MAKEINFO)" \
1514                         clean) ; \
1515         else \
1516                 true ; \
1517         fi
1518
1519 install-emacs: install-rcs install-gdbm force
1520         if [ -d ./emacs ] ; then \
1521                 rootme=`pwd` ; export rootme ; \
1522                 (cd ./emacs; \
1523                 $(MAKE) \
1524                         "against=$(against)" \
1525                         "AR=$(AR)" \
1526                         "AR_FLAGS=$(AR_FLAGS)" \
1527                         "CC=$(CC)" \
1528                         "RANLIB=$(RANLIB)" \
1529                         "LOADLIBES=$(LOADLIBES)" \
1530                         "LDFLAGS=$(LDFLAGS)" \
1531                         "BISON=$(BISON)" \
1532                         "MAKEINFO=$(MAKEINFO)" \
1533                         install) ; \
1534         else \
1535                 true ; \
1536         fi
1537
1538 ### ispell
1539 .PHONY: all-ispell stmp-ispell
1540 all-ispell: stmp-ispell
1541 stmp-ispell: all-emacs force
1542         if [ -d ./ispell ] ; then \
1543                 rootme=`pwd` ; export rootme ; \
1544                 (cd ./ispell; \
1545                 $(MAKE) \
1546                         "against=$(against)" \
1547                         "AR=$(AR)" \
1548                         "AR_FLAGS=$(AR_FLAGS)" \
1549                         "CC=$(CC)" \
1550                         "RANLIB=$(RANLIB)" \
1551                         "LOADLIBES=$(LOADLIBES)" \
1552                         "LDFLAGS=$(LDFLAGS)" \
1553                         "BISON=$(BISON)" \
1554                         "MAKEINFO=$(MAKEINFO)" \
1555                         all) ; \
1556         else \
1557                 true ; \
1558         fi
1559         touch stmp-ispell
1560
1561 clean-ispell: force
1562         if [ -d ./ispell ] ; then \
1563                 rootme=`pwd` ; export rootme ; \
1564                 (cd ./ispell; \
1565                 $(MAKE) \
1566                         "against=$(against)" \
1567                         "AR=$(AR)" \
1568                         "AR_FLAGS=$(AR_FLAGS)" \
1569                         "CC=$(CC)" \
1570                         "RANLIB=$(RANLIB)" \
1571                         "LOADLIBES=$(LOADLIBES)" \
1572                         "LDFLAGS=$(LDFLAGS)" \
1573                         "BISON=$(BISON)" \
1574                         "MAKEINFO=$(MAKEINFO)" \
1575                         clean) ; \
1576         else \
1577                 true ; \
1578         fi
1579
1580 install-ispell: install-rcs install-gdbm force
1581         if [ -d ./ispell ] ; then \
1582                 rootme=`pwd` ; export rootme ; \
1583                 (cd ./ispell; \
1584                 $(MAKE) \
1585                         "against=$(against)" \
1586                         "AR=$(AR)" \
1587                         "AR_FLAGS=$(AR_FLAGS)" \
1588                         "CC=$(CC)" \
1589                         "RANLIB=$(RANLIB)" \
1590                         "LOADLIBES=$(LOADLIBES)" \
1591                         "LDFLAGS=$(LDFLAGS)" \
1592                         "BISON=$(BISON)" \
1593                         "MAKEINFO=$(MAKEINFO)" \
1594                         install) ; \
1595         else \
1596                 true ; \
1597         fi
1598
1599 ### flex
1600 .PHONY: all-flex stmp-flex
1601 all-flex: stmp-flex
1602 stmp-flex: force
1603         if [ -d ./flex ] ; then \
1604                 rootme=`pwd` ; export rootme ; \
1605                 (cd ./flex; \
1606                 $(MAKE) \
1607                         "against=$(against)" \
1608                         "AR=$(AR)" \
1609                         "AR_FLAGS=$(AR_FLAGS)" \
1610                         "CC=$(CC)" \
1611                         "RANLIB=$(RANLIB)" \
1612                         "LOADLIBES=$(LOADLIBES)" \
1613                         "LDFLAGS=$(LDFLAGS)" \
1614                         "BISON=$(BISON)" \
1615                         "MAKEINFO=$(MAKEINFO)" \
1616                         all) ; \
1617         else \
1618                 true ; \
1619         fi
1620         touch stmp-flex
1621
1622 clean-flex: force
1623         if [ -d ./flex ] ; then \
1624                 rootme=`pwd` ; export rootme ; \
1625                 (cd ./flex; \
1626                 $(MAKE) \
1627                         "against=$(against)" \
1628                         "AR=$(AR)" \
1629                         "AR_FLAGS=$(AR_FLAGS)" \
1630                         "CC=$(CC)" \
1631                         "RANLIB=$(RANLIB)" \
1632                         "LOADLIBES=$(LOADLIBES)" \
1633                         "LDFLAGS=$(LDFLAGS)" \
1634                         "BISON=$(BISON)" \
1635                         "MAKEINFO=$(MAKEINFO)" \
1636                         clean) ; \
1637         else \
1638                 true ; \
1639         fi
1640
1641 install-flex: force
1642         if [ -d ./flex ] ; then \
1643                 rootme=`pwd` ; export rootme ; \
1644                 (cd ./flex; \
1645                 $(MAKE) \
1646                         "against=$(against)" \
1647                         "AR=$(AR)" \
1648                         "AR_FLAGS=$(AR_FLAGS)" \
1649                         "CC=$(CC)" \
1650                         "RANLIB=$(RANLIB)" \
1651                         "LOADLIBES=$(LOADLIBES)" \
1652                         "LDFLAGS=$(LDFLAGS)" \
1653                         "BISON=$(BISON)" \
1654                         "MAKEINFO=$(MAKEINFO)" \
1655                         install) ; \
1656         else \
1657                 true ; \
1658         fi
1659
1660 ### fileutils
1661 .PHONY: all-fileutils stmp-fileutils
1662 all-fileutils: stmp-fileutils
1663 stmp-fileutils: force
1664         if [ -d ./fileutils ] ; then \
1665                 rootme=`pwd` ; export rootme ; \
1666                 (cd ./fileutils; \
1667                 $(MAKE) \
1668                         "prefix=$(prefix)" \
1669                         "datadir=$(datadir)" \
1670                         "mandir=$(mandir)" \
1671                         "against=$(against)" \
1672                         "AR=$(AR)" \
1673                         "AR_FLAGS=$(AR_FLAGS)" \
1674                         "CC=$(CC)" \
1675                         "RANLIB=$(RANLIB)" \
1676                         "LOADLIBES=$(LOADLIBES)" \
1677                         "LDFLAGS=$(LDFLAGS)" \
1678                         "BISON=$(BISON)" \
1679                         "MAKEINFO=$(MAKEINFO)" \
1680                         all) ; \
1681         else \
1682                 true ; \
1683         fi
1684         touch stmp-fileutils
1685
1686 clean-fileutils: force
1687         if [ -d ./fileutils ] ; then \
1688                 rootme=`pwd` ; export rootme ; \
1689                 (cd ./fileutils; \
1690                 $(MAKE) \
1691                         "prefix=$(prefix)" \
1692                         "datadir=$(datadir)" \
1693                         "mandir=$(mandir)" \
1694                         "against=$(against)" \
1695                         "AR=$(AR)" \
1696                         "AR_FLAGS=$(AR_FLAGS)" \
1697                         "CC=$(CC)" \
1698                         "RANLIB=$(RANLIB)" \
1699                         "LOADLIBES=$(LOADLIBES)" \
1700                         "LDFLAGS=$(LDFLAGS)" \
1701                         "BISON=$(BISON)" \
1702                         "MAKEINFO=$(MAKEINFO)" \
1703                         clean) ; \
1704         else \
1705                 true ; \
1706         fi
1707
1708 install-fileutils: force
1709         if [ -d ./fileutils ] ; then \
1710                 rootme=`pwd` ; export rootme ; \
1711                 (cd ./fileutils; \
1712                 $(MAKE) \
1713                         "prefix=$(prefix)" \
1714                         "datadir=$(datadir)" \
1715                         "mandir=$(mandir)" \
1716                         "against=$(against)" \
1717                         "AR=$(AR)" \
1718                         "AR_FLAGS=$(AR_FLAGS)" \
1719                         "CC=$(CC)" \
1720                         "RANLIB=$(RANLIB)" \
1721                         "LOADLIBES=$(LOADLIBES)" \
1722                         "LDFLAGS=$(LDFLAGS)" \
1723                         "BISON=$(BISON)" \
1724                         "MAKEINFO=$(MAKEINFO)" \
1725                         install) ; \
1726         else \
1727                 true ; \
1728         fi
1729
1730 ### libg++
1731 .PHONY: all-libg++ stmp-libg++
1732 all-libg++: stmp-gas stmp-ld stmp-gcc stmp-libg++
1733 stmp-libg++: stmp-gcc force
1734         if [ -d ./libg++ ] ; then \
1735                 rootme=`pwd` ; export rootme ; \
1736                 (cd ./libg++; \
1737                 $(MAKE) \
1738                         "prefix=$(prefix)" \
1739                         "datadir=$(datadir)" \
1740                         "mandir=$(mandir)" \
1741                         "against=$(against)" \
1742                         "AR=$(AR)" \
1743                         "AR_FLAGS=$(AR_FLAGS)" \
1744                         "CC=$${rootme}/gcc/gcc -B$${rootme}/gcc/" \
1745                         "RANLIB=$(RANLIB)" \
1746                         "LOADLIBES=$(LOADLIBES)" \
1747                         "LDFLAGS=$(LDFLAGS)" \
1748                         "BISON=$(BISON)" \
1749                         "MAKEINFO=$(MAKEINFO)" \
1750                         all) ; \
1751         else \
1752                 true ; \
1753         fi
1754         touch stmp-libgxx
1755
1756 clean-libg++: force
1757         if [ -d ./libg++ ] ; then \
1758                 rootme=`pwd` ; export rootme ; \
1759                 (cd ./libg++; \
1760                 $(MAKE) \
1761                         "prefix=$(prefix)" \
1762                         "datadir=$(datadir)" \
1763                         "mandir=$(mandir)" \
1764                         "against=$(against)" \
1765                         "AR=$(AR)" \
1766                         "AR_FLAGS=$(AR_FLAGS)" \
1767                         "CC=$(CC)" \
1768                         "RANLIB=$(RANLIB)" \
1769                         "LOADLIBES=$(LOADLIBES)" \
1770                         "LDFLAGS=$(LDFLAGS)" \
1771                         "BISON=$(BISON)" \
1772                         "MAKEINFO=$(MAKEINFO)" \
1773                         clean) ; \
1774         else \
1775                 true ; \
1776         fi
1777
1778 install-libg++: force
1779         if [ -d ./libg++ ] ; then \
1780                 rootme=`pwd` ; export rootme ; \
1781                 (cd ./libg++; \
1782                 $(MAKE) \
1783                         "prefix=$(prefix)" \
1784                         "datadir=$(datadir)" \
1785                         "mandir=$(mandir)" \
1786                         "against=$(against)" \
1787                         "AR=$(AR)" \
1788                         "AR_FLAGS=$(AR_FLAGS)" \
1789                         "CC=$(CC)" \
1790                         "RANLIB=$(RANLIB)" \
1791                         "LOADLIBES=$(LOADLIBES)" \
1792                         "LDFLAGS=$(LDFLAGS)" \
1793                         "BISON=$(BISON)" \
1794                         "MAKEINFO=$(MAKEINFO)" \
1795                         install) ; \
1796         else \
1797                 true ; \
1798         fi
1799
1800 ### other supporting targets
1801 # this is a bad hack.
1802 all.xclib:      all.normal
1803         if [ -d clib ] ; then \
1804                 (cd clib ; $(MAKE)) ; \
1805         fi
1806
1807 subdir_do: force
1808         for i in $(DODIRS); do \
1809                 if [ -f ./$$i/localenv ] ; then \
1810                         if (rootme=`pwd` ; export rootme ; cd ./$$i; \
1811                                 $(MAKE) \
1812                                         "against=$(against)" \
1813                                         "BISON=$(BISON)" \
1814                                         "MAKEINFO=$(MAKEINFO)" \
1815                                         $(DO)) ; then true ; \
1816                                 else exit 1 ; fi ; \
1817                 else if [ -d ./$$i ] ; then \
1818                         if (rootme=`pwd` ; export rootme ; cd ./$$i; \
1819                                 $(MAKE) \
1820                                         "against=$(against)" \
1821                                         "AR=$(AR)" \
1822                                         "AR_FLAGS=$(AR_FLAGS)" \
1823                                         "CC=$(CC)" \
1824                                         "RANLIB=$(RANLIB)" \
1825                                         "LOADLIBES=$(LOADLIBES)" \
1826                                         "LDFLAGS=$(LDFLAGS)" \
1827                                         "BISON=$(BISON)" \
1828                                         "MAKEINFO=$(MAKEINFO)" \
1829                                         $(DO)) ; then true ; \
1830                         else exit 1 ; fi ; \
1831                 else true ; fi ; \
1832         fi ; \
1833         done
1834
1835 bootstrap:
1836         $(MAKE) all info
1837         $(MAKE) stage1
1838         $(MAKE) pass "stagepass=stage1"
1839         $(MAKE) stage2
1840         $(MAKE) pass "stagepass=stage2"
1841         $(MAKE) comparison
1842
1843 bootstrap2:
1844         $(MAKE) pass "stagepass=stage1"
1845         $(MAKE) stage2
1846         $(MAKE) pass "stagepass=stage2"
1847         $(MAKE) comparison
1848
1849 bootstrap3:
1850         $(MAKE) pass "stagepass=stage2"
1851         $(MAKE) comparison
1852
1853 pass:
1854         cp $(srcdir)/gcc/gstdarg.h ./gas/stdarg.h
1855         $(MAKE) subdir_do "DO=all info" "DODIRS=$(SUBDIRS)" \
1856                 "CC=`pwd`/gcc/$(stagepass)/gcc \
1857                 -O $(GCCVERBOSE) -I`pwd`/gcc/include \
1858                 -B`pwd`/gcc/$(stagepass)/ \
1859                 -B`pwd`/gas/$(stagepass)/ \
1860                 -B`pwd`/ld/$(stagepass)/" \
1861                 "AR=`pwd`/binutils/$(stagepass)/ar" \
1862                 "LD=`pwd`/gcc/$(stagepass)/gcc $(GCCVERBOSE)" \
1863                 "RANLIB=`pwd`/binutils/$(stagepass)/ranlib" \
1864                 "LOADLIBES=`pwd`/libgcc/$(stagepass)/libgcc.a /lib/libc.a" \
1865                 "LDFLAGS=-nostdlib /lib/crt0.o \
1866                 -L`pwd`/libgcc/$(stagepass)/ \
1867                 -B`pwd`/ld/$(stagepass)/"
1868
1869
1870 stage1:
1871         $(MAKE) subdir_do DO=stage1 "DODIRS=$(SUBDIRS)"
1872
1873 stage2:
1874         $(MAKE) subdir_do DO=stage2 "DODIRS=$(SUBDIRS)"
1875
1876 stage3:
1877         $(MAKE) subdir_do DO=stage3 "DODIRS=$(SUBDIRS)"
1878
1879 stage4:
1880         $(MAKE) subdir_do DO=stage4 "DODIRS=$(SUBDIRS)"
1881
1882 against=stage2
1883
1884 comparison:; $(MAKE) subdir_do DO=comparison against=$(against) "DODIRS=$(SUBDIRS)"
1885
1886 de-stage1:; $(MAKE) subdir_do DO=de-stage1 "DODIRS=$(SUBDIRS)"
1887 de-stage2:; $(MAKE) subdir_do DO=de-stage2 "DODIRS=$(SUBDIRS)"
1888 de-stage3:; $(MAKE) subdir_do DO=de-stage3 "DODIRS=$(SUBDIRS)"
1889 de-stage4:; $(MAKE) subdir_do DO=de-stage4 "DODIRS=$(SUBDIRS)"
1890
1891 # The "else true" stuff is for Ultrix; the shell returns the exit code
1892 # of the "if" command, if no commands are run in the "then" or "else" part,
1893 # causing Make to quit.
1894
1895 MAKEDIRS= \
1896         $(prefix) \
1897         $(exec_prefix) \
1898         $(bindir) \
1899         $(libdir) \
1900         $(tooldir) \
1901         $(includedir) \
1902         $(datadir) \
1903         $(docdir) \
1904         $(mandir) \
1905         $(man1dir) \
1906         $(man5dir)
1907
1908 #       $(man2dir) \
1909 #       $(man3dir) \
1910 #       $(man4dir) \
1911 #       $(man6dir) \
1912 #       $(man7dir) \
1913 #       $(man8dir)
1914
1915 install-dirs: force
1916         for i in $(MAKEDIRS) ; do \
1917                 echo Making $$i... ; \
1918                 [ -d $$i ] || mkdir $$i || exit 1 ; \
1919         done
1920
1921 MAKEINFODIRS= \
1922         $(prefix) \
1923         $(infodir)
1924
1925 install-info-dirs: force
1926         if [ -d $(prefix) ] ; then true ; else mkdir $(prefix) ; fi
1927         if [ -d $(datadir) ] ; then true ; else mkdir $(datadir) ; fi
1928         if [ -d $(infodir) ] ; then true ; else mkdir $(infodir) ; fi
1929
1930 dir.info: force
1931         $(srcdir)/texinfo/gen-info-dir $(infodir) > dir.info.new
1932         mv -f dir.info.new dir.info
1933
1934 etags tags: TAGS
1935
1936 TAGS: FORCE
1937         etags `$(MAKE) ls`
1938
1939 ls:
1940         @echo Makefile
1941         @for i in $(SUBDIRS); \
1942         do \
1943                 (cd $$i; \
1944                         pwd=`pwd`; \
1945                         wd=`basename $$pwd`; \
1946                         for j in `$(MAKE) ls`; \
1947                         do \
1948                                 echo $$wd/$$j; \
1949                         done) \
1950         done
1951
1952 force:
1953
1954 # with the gnu make, this is done automatically.
1955
1956 Makefile: $(srcdir)/Makefile.in $(host_makefile_frag) $(target_makefile_frag)
1957         $(SHELL) ./config.status
1958
1959 #
1960 # Build GDB distributions that contain BFD, Include, Libiberty, Readline, etc
1961
1962 DEVO_SUPPORT= README cfg-paper.texi Makefile.in configure configure.in \
1963         config.sub config configure.man
1964 GDB_SUPPORT_DIRS= bfd include libiberty readline glob
1965 GDB_SUPPORT_FILES= $(GDB_SUPPORT_DIRS) texinfo/fsf/texinfo.tex
1966
1967 setup-dirs: force_update
1968         ./configure sun4
1969         make clean
1970         ./configure -rm sun4
1971         chmod og=u `find $(DEVO_SUPPORT) $(GDB_SUPPORT_FILES) -print`
1972
1973 bfd.ilrt.tar.Z: setup-dirs
1974         rm -f bfd.ilrt.tar.Z
1975         tar cf - $(DEVO_SUPPORT) $(GDB_SUPPORT_FILES) \
1976                 | compress -v >bfd.ilrt.tar.Z
1977
1978 gdb.tar.Z: setup-dirs
1979         (cd gdb; $(MAKE) -f Makefile.in make-proto-gdb.dir)
1980         $(MAKE) $(MFLAGS) -f Makefile.in make-gdb.tar.Z
1981
1982 make-gdb.tar.Z: $(DEVO_SUPPORT) $(GDB_SUPPORT_DIRS) gdb texinfo/fsf/texinfo.tex
1983         rm -rf proto-toplev; mkdir proto-toplev
1984         ln -s ../gdb/proto-gdb.dir proto-toplev/gdb
1985         (cd proto-toplev; for i in $(DEVO_SUPPORT) $(GDB_SUPPORT_DIRS); do \
1986                 ln -s ../$$i . ; \
1987         done)
1988         # Put only one copy (four hard links) of COPYING in the tar file.
1989         rm                          proto-toplev/bfd/COPYING
1990         ln proto-toplev/gdb/COPYING proto-toplev/bfd/COPYING
1991         rm                          proto-toplev/include/COPYING
1992         ln proto-toplev/gdb/COPYING proto-toplev/include/COPYING
1993         rm                          proto-toplev/readline/COPYING
1994         ln proto-toplev/gdb/COPYING proto-toplev/readline/COPYING
1995         # Take out texinfo from configurable dirs
1996         rm proto-toplev/configure.in
1997         sed '/^configdirs=/s/texinfo //' <configure.in >proto-toplev/configure.in
1998         # Take out glob from buildable dirs
1999         rm proto-toplev/Makefile.in
2000         sed '/^SUBDIRS =/s/glob //' <Makefile.in >proto-toplev/Makefile.in
2001         # Take out texinfo from buildable dirs
2002         cp proto-toplev/Makefile.in temp.$$
2003         sed '/^all\.normal: /s/all-texinfo //' <temp.$$ >temp1.$$
2004         sed '/^clean: /s/clean-texinfo //' <temp1.$$ >temp.$$
2005         sed '/^install\.all: /s/install-texinfo //' <temp.$$ >proto-toplev/Makefile.in
2006         rm temp.$$ temp1.$$
2007         mkdir proto-toplev/texinfo
2008         mkdir proto-toplev/texinfo/fsf
2009         ln -s ../../../texinfo/fsf/texinfo.tex proto-toplev/texinfo/fsf/
2010         chmod og=u `find proto-toplev -print`
2011         (VER=`sed <gdb/Makefile.in -n 's/VERSION = //p'`; \
2012                 echo "==> Making gdb-$$VER.tar.Z"; \
2013                 ln -s proto-toplev gdb-$$VER; \
2014                 tar cfh - gdb-$$VER \
2015                 | compress -v >gdb-$$VER.tar.Z)
2016
2017 force_update:
2018
2019 nothing:
2020
2021 # end of Makefile.in