tools/build-srcpkg-bak-20240503/shlib/toolchain.shlib

   1 #!/bin/bash
   2 ############################################################
   3 # source: toolchain.shlib
   4 # author: devenkong(18151155@qq.com)
   5 # date: 2023-02-15
   6 ############################################################
   7 # note:
   8 #     toolchain cmd set. it uses fname.shlib to get output
   9 # dirs, and ../platform/toolchain_info.imi for cmd name with
  10 # cross compile prefix. before invoke func in this file, load
  11 # parameters defined in dest/dest-xxx/* by param-load.shlib.
  12 ############################################################
  13
  14 #
  15 # todo：
  16 # @ o2drv
  17 # @ fhex2fbin/fbin2fhex
  18 #
  19
  20 #
  21 # features：
  22 # @ absolution of toolchain cmd & op.
  23 # !# cmd: gcc/ld/ar ...
  24 # !# compile, asm2o(), c2o(), cpp2o(),
  25 # !# link, o2exe(), o2a(), o2dlib(), o2drv()
  26 # !# postage-proc, progstrip()
  27 # !# postage-info, prog_size_info(), prog_symbols(), prog_func_symbs(),
  28 #   prog_var_symbs(), prog_inner_symbs(), prog_ext_symbs(),
  29 # # postage-output, exe2bin(), exe2hex(), hex2bin(), bin2hex(),
  30 #   fhex2bin(), fbin2hex(),
  31 # # general log output info, dbg output info.
  32 # !@ compile hdr file dep list.
  33 # !@ cross(untested)
  34 # !@ different cpu arch optimzation opt.(untested)
  35 # @ *opt check.
  36 # @ gcc -f opt.
  37 # @ INVOKE type
  38 # @ prev & post invoke
  39 #
  40
  41
  42 # . incfile.shlib
  43
  44 #
  45 # this func copied from incfile.shlib. due to the file is not in a fixed dir,
  46 # it can'nt be used by source operation.
  47 #
  48 if [[ -z $(declare -F inc) ]]; then
  49         inc ()
  50         {
  51         local pwd=$PWD
  52
  53         [[ -z "$1" || ! -f "$1" ]] && return
  54
  55         cd $(dirname $1)
  56         source $(basename $1)
  57         cd $pwd
  58         }
  59 fi
  60
  61
  62 #
  63 # file name format define
  64 # before using,
  65 #
  66 inc fname.shlib
  67
  68
  69
  70 ######################
  71 # section: common comment info
  72 ######################
  73
  74 ######################
  75 # section: variable define
  76 ######################
  77
  78
  79
  80 ######################
  81 # section: private function
  82 ######################
  83
  84 toolchain_dbgout ()
  85 {
  86         test "${OPT_VERBOSE_INFO}" == 'Y' && echo "$@"
  87         return;
  88         echo "$@"
  89 }
  90
  91
  92
  93 ######################
  94 # section: public function
  95 ######################
  96
  97 #########################################
  98 # Compile Function
  99 #########################################
 100
 101 # OPT_OBJSIZE_INFO=Y
 102 # OPT_VERBOSE_INFO=Y
 103 # OPT_DEPHDR=Y
 104 # OPT_CALL_GRAPH=Y
 105
 106 cmd_run ()
 107 {
 108         local cmd="$1"
 109         local output=
 110         local ret=
 111         local line=
 112
 113         # attention -lncurses paramter must be put after .o file,
 114         # or it report err that symbol not found.
 115 #       cmd="${CC} ${ASFLAGS_OUT} ${ASFLAGS_EXT} ${CFLAGS} ${LDFLAGS} $(echo ${SRC_FILE[@]}) -o ${DST_FILE[0]}"
 116
 117         #
 118         # XXX: if there is blank in quoted "string", it will be shorten to single.
 119         #      append '\' before it.
 120         #
 121         cmd="$(echo "${cmd//[[:space:]]/ }" | tr -s ' ')"
 122
 123         # release var after cmd is filled.
 124         unset SRC_FILE DST_FILE
 125
 126         #
 127         # TBD: do parameter checking work here.
 128         #
 129
 130         #
 131         # build operation
 132         # NOTE:
 133         # if stdout is redirected by '|' pipe,
 134         # it will not display in colorfull.
 135         # the commented statement does not display in colorfull.
 136         #
 137 #       output="$( eval $cmd 2>&1 )"
 138         eval $cmd 2>&1 > /tmp/output.log
 139         ret=$?
 140
 141         echo -ne " === ${cmd}\n" >> ${OUTDIR}/build-dbgout.log
 142         echo -ne " === ${cmd}\n" >> ${OUTDIR}/build.log
 143
 144         if test $ret = 0 || ! test -s /tmp/output.log && test "${verbose_mode,,}" != y ; then
 145                 toolchain_dbgout -ne "${CHIGHL} === ${cmd}${CNORMAL}\n"
 146         else
 147                 echo -ne "${CHIGHL} === ${cmd}${CNORMAL}\n"
 148                 cat /tmp/output.log
 149                 test "${OPT_VERBOSE_INFO}" == 'Y' && cat /tmp/output.log >> ${OUTDIR}/build-dbgout.log
 150         fi
 151
 152         if test $ret != 0 ; then
 153                 return 2
 154         else
 155                 return 0
 156         fi
 157 }
 158
 159 #
 160 # fsyntax: asm2o <src-file> <output-file>
 161 # fdesc: asm汇编程序.S文件编译成.o文件。
 162 #
 163 asm2o ()
 164 {
 165         local cmd=
 166
 167         [[ -n "${1}" ]] && SRC_FILE[0]="$1"
 168         [[ -n "${2}" ]] && DST_FILE[1]="$2"
 169
 170         eval cmd=\"$ASM2O_CMD_FMT\"
 171         cmd_run "$cmd"
 172         cmd=$?
 173
 174         [[ $cmd == 0 ]] && CMPL_OBJ_LIST+="$fdst"
 175         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 176
 177         return $cmd
 178 }
 179
 180 #
 181 # fsyntax: src2dst_filename
 182 # fdesc: compile each src file.
 183 #
 184 src2dst_filename ()
 185 {
 186         [[ -z "${SRC_FILE[0]}" ]] && echo -e "[error]: SRC_FILE[0] should not be NULL, and '\n$(declare -p DST_FILE)'.\n" >&2 && exit
 187
 188         SRC_FILE="${SRC_FILE//\,/\ }"
 189
 190         [[ -z "${DST_FILE[0]}" ]] && fname_src2dst $SRC_FILE
 191         [[ -z "${DST_FILE[1]}" ]] && fname_src2obj $SRC_FILE
 192
 193         [[ OPT_CALLGRAPH =~ '' ]] &&
 194
 195         [[ -z "${DST_FILE[2]}" ]] && fname_src2dep $SRC_FILE
 196         [[ -z "${DST_FILE[3]}" ]] && fname_src2graph $SRC_FILE
 197 }
 198
 199
 200 # set those two by cmd opt or envar or DEBUG/RELEASE opt.
 201 #
 202 # OPT_DEPHDR
 203 # OPT_CALLGRAPH
 204
 205 #
 206 # fsyntax: c2o <src-file> [ <obj-file> [ <dep-file> [<graph-file>] ] ]
 207 # fdesc: .c src file compile to .o file. parameters can be given in func arg,
 208 #   and envar SRC_FILE & DST_FILE. you can given one param <obj-file> only,
 209 #   it will generate others in auto.
 210 #
 211 c2o ()
 212 {
 213         local cmd=
 214         local fdst=
 215
 216         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[c]}$ ]] && SRC_FILE[0]="$1"
 217         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 218         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 219         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 220         src2dst_filename
 221
 222         fdst="${DST_FILE[1]} "
 223
 224         mkdir -p $(dirname ${DST_FILE[1]})
 225
 226 #    echo \$1=${1}
 227 #    echo \$2=${2}
 228 #    echo SRC_FILE=${SRC_FILE[@]}
 229 #    echo DST_FILE=${DST_FILE[@]}
 230
 231         CFLAGS_DEPHDR_Y=""
 232         CFLAGS_CALLGRAPH_Y=""
 233         if test -n "${DST_FILE[2]}" && test "${OPT_DEPHDR^^}" == 'Y'; then
 234                 eval "CFLAGS_DEPHDR_${OPT_DEPHDR^^}=\"$CFLAGS_DEPHDR_Y_EVL\""
 235         fi
 236         if test -n "${DST_FILE[3]}" && test "${OPT_CALL_GRAPH^^}" == 'Y'; then
 237                 eval "CFLAGS_CALLGRAPH_${OPT_CALLGRAPH^^}=\"$CFLAGS_CALLGRAPH_Y_EVL\""
 238         fi
 239
 240         eval cmd=\"$C2O_CMD_FMT\"
 241         cmd_run "$cmd"
 242         cmd=$?
 243
 244         [[ $cmd == 0 ]] && CMPL_OBJ_LIST+="$fdst"
 245         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 246
 247         return $cmd
 248 }
 249
 250 #
 251 # fsyntax: cxx2o
 252 # fdesc: .cc文件编译成.o文件。
 253 cxx2o ()
 254 {
 255         local cmd=
 256         local fdst=
 257
 258         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[cxx]}$ ]] && SRC_FILE[0]="$1"
 259         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 260         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 261         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 262         src2dst_filename
 263         fdst="${DST_FILE[1]} "
 264
 265         mkdir -p $(dirname ${DST_FILE[0]})
 266
 267         CFLAGS_DEPHDR_Y=""
 268         CFLAGS_CALLGRAPH_Y=""
 269         if test -n "${DST_FILE[2]}" && test ${OPT_DEPHDR^^} == 'Y'; then
 270                 eval "CFLAGS_DEPHDR_${OPT_DEPHDR}=\"$CFLAGS_DEPHDR_Y_EVL\""
 271         fi
 272         if test -n "${DST_FILE[3]}" && test ${OPT_CALL_GRAPH^^} == 'Y'; then
 273                 eval "CFLAGS_CALLGRAPH_${OPT_CALLGRAPH}=\"$CFLAGS_CALLGRAPH_Y_EVL\""
 274         fi
 275
 276         eval cmd=\"$CXX2O_CMD_FMT\"
 277         cmd_run "$cmd"
 278         cmd=$?
 279
 280         [[ $cmd == 0 ]] && CMPL_OBJ_LIST+="$fdst"
 281         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 282
 283         return $cmd
 284 }
 285
 286 #
 287 # fsyntax: cpp2o
 288 # fdesc: cpp程序.cpp文件编译成.o文件。
 289 #
 290 cpp2o ()
 291 {
 292         local cmd=
 293         local fdst=
 294
 295         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[cpp]}$ ]] && SRC_FILE[0]="$1"
 296         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 297         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 298         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 299         src2dst_filename
 300         fdst="${DST_FILE[1]} "
 301
 302         mkdir -p $(dirname ${DST_FILE[0]})
 303
 304         CFLAGS_DEPHDR_Y=""
 305         CFLAGS_CALLGRAPH_Y=""
 306         if test -n "${DST_FILE[2]}" && test ${OPT_DEPHDR^^} == 'Y'; then
 307                 eval "CFLAGS_DEPHDR_${OPT_DEPHDR:+Y}=\"$CFLAGS_DEPHDR_Y_EVL\""
 308         fi
 309         if test -n "${DST_FILE[3]}" && test ${OPT_CALL_GRAPH^^} == 'Y'; then
 310                 eval "CFLAGS_CALLGRAPH_${OPT_CALLGRAPH:+Y}=\"$CFLAGS_CALLGRAPH_Y_EVL\""
 311         fi
 312
 313         eval cmd=\"$CPP2O_CMD_FMT\"
 314         cmd_run "$cmd"
 315         cmd=$?
 316
 317         [[ $cmd == 0 ]] && CMPL_OBJ_LIST+="$fdst"
 318         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 319
 320         return $cmd
 321 }
 322
 323
 324 #
 325 # fsyntax: asm2exe
 326 # fdesc: .asm文件编译成exe文件。
 327 asm2exe ()
 328 {
 329         local cmd=
 330
 331         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[asm]}$ ]] && SRC_FILE[0]="$1"
 332         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 333         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 334         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 335         src2dst_filename
 336
 337         mkdir -p $(dirname ${DST_FILE[0]})
 338
 339         eval cmd=\"$ASM2EXE_CMD_FMT\"
 340         cmd_run "$cmd"
 341         cmd=$?
 342
 343         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 344
 345         return $cmd
 346 }
 347
 348 #
 349 # fsyntax: c2exe
 350 # fdesc: c语言程序.c文件编译成.o文件。
 351 c2exe ()
 352 {
 353         local cmd=
 354
 355         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[c]}$ ]] && SRC_FILE[0]="$1"
 356         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 357         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 358         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 359         src2dst_filename
 360
 361         mkdir -p $(dirname ${DST_FILE[0]})
 362
 363         eval cmd=\"$C2EXE_CMD_FMT\"
 364         cmd_run "$cmd"
 365         cmd=$?
 366
 367         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 368
 369         return $cmd
 370 }
 371
 372 #
 373 # fsyntax: cxx2exe
 374 # fdesc: cpp程序.cpp文件编译成.o文件。
 375 #
 376 cxx2exe ()
 377 {
 378         local cmd=
 379
 380         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[cxx]}$ ]] && SRC_FILE[0]="$1"
 381         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 382         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 383         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 384         src2dst_filename
 385
 386         mkdir -p $(dirname ${DST_FILE[0]})
 387
 388         eval cmd=\"$CXX2EXE_CMD_FMT\"
 389         cmd_run "$cmd"
 390         cmd=$?
 391
 392         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 393
 394         return $cmd
 395 }
 396
 397 #
 398 # fsyntax: cpp2exe
 399 # fdesc: cpp程序.cpp文件编译成.o文件。
 400 #
 401 cpp2exe ()
 402 {
 403         local cmd=
 404
 405         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[cpp]}$ ]] && SRC_FILE[0]="$1"
 406         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && DST_FILE[1]="$2"
 407         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 408         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 409         src2dst_filename
 410
 411         mkdir -p $(dirname ${DST_FILE[0]})
 412
 413         eval cmd=\"$CPP2EXE_CMD_FMT\"
 414         cmd_run "$cmd"
 415         cmd=$?
 416
 417         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 418
 419         return $cmd
 420 }
 421
 422
 423 #########################################
 424 # link function
 425 #########################################
 426
 427 #
 428 # fsyntax: o2o
 429 # fdesc: .o文件链接成.o文件。
 430 #
 431 o2o ()
 432 {
 433         local cmd=
 434
 435         [[ -n "${1}" ]] && SRC_FILE[0]="$1"
 436         [[ -n "${2}" ]] && DST_FILE[0]="$2"
 437         [[ -n "${3}" ]] && DST_FILE[2]="$3"
 438         [[ -n "${4}" ]] && DST_FILE[3]="$4"
 439         src2dst_filename
 440
 441         mkdir -p $(dirname ${DST_FILE[0]})
 442
 443         eval cmd=\"$O2O_CMD_FMT\"
 444         cmd_run "$cmd"
 445         cmd=$?
 446
 447         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 448
 449         return $cmd
 450 }
 451
 452 #
 453 # fsyntax: link_filename_fix
 454 # fdesc: compile each src file.
 455 #
 456 link_filename_fix ()
 457 {
 458         local ext=
 459         local dst=
 460
 461 #       eval "ext=\"\${LANG_EXT_NAME[${lang,,}]}\""
 462         #"${SRC_FILE[0]##*.}"
 463
 464 #       obj="${DSTDIR}/${obj//\.$ext/\.o}"
 465 #       DST_FILE[0]="${DSTDIR}/${DST_FILE[0]}"
 466
 467         fname_objdir
 468         for ((i=0; i<${#SRC_FILE[@]}; i++)); do
 469                 if [[ ! "${SRC_FILE[$i]}" =~ ${OBJDIR} ]]; then
 470                         SRC_FILE[$i]="${OBJDIR}/${SRC_FILE[$i]}"
 471                 fi
 472         done
 473
 474 #       DST_FILE[0]="${OUTDIR}/${DST_FILE[0]}"
 475 }
 476
 477 #
 478 # fsyntax: o2lib
 479 # fdesc: .o files link to static library.
 480 #
 481 o2lib ()
 482 {
 483         local cmd=
 484         local output=
 485         local ret=
 486         local file=
 487
 488         [[ -n "${1}" && "${!2}" =~ ${EXT_NAME[obj]}$ ]] && SRC_FILE[0]="$1"
 489         [[ -n "${2}" && "${!2}" =~ ${EXT_NAME[lib]}$ ]] && DST_FILE[1]="$2"
 490         [[ -n "${3}" && "${!2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 491         [[ -n "${4}" && "${!2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 492         link_filename_fix
 493
 494 #       echo \$2=$2=${!2}
 495 #       echo DST_FILE=$DST_FILE
 496
 497         file=${DST_FILE}
 498         mkdir -p $(dirname ${DST_FILE[0]})
 499
 500         eval cmd=\"$O2LIB_CMD_FMT\"
 501         cmd_run "$cmd"
 502         [[ $? != 0 ]] && return $?
 503
 504         ranlib $file
 505         cmd=$?
 506
 507         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 508
 509         return $cmd
 510 }
 511
 512 #
 513 # fsyntax: o2la
 514 # fdesc: .o files link to general static library.
 515 #
 516 o2la ()
 517 {
 518         # TBD:
 519 #       if test $ret != 0 ; then
 520                 return 2
 521 #       else
 522 #               return 0
 523 #       fi
 524 }
 525
 526 #
 527 # fsyntax: o2dll
 528 # fdesc: .o files link to dynamic library.
 529 #
 530 o2dll ()
 531 {
 532         local cmd=
 533
 534         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && SRC_FILE[0]="$1"
 535         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[dll]}$ ]] && DST_FILE[1]="$2"
 536         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 537         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 538         link_filename_fix
 539
 540         mkdir -p $(dirname ${DST_FILE[0]})
 541
 542         eval cmd=\"$O2DLL_CMD_FMT\"
 543         cmd_run "$cmd"
 544         cmd=$?
 545
 546         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 547
 548         return $cmd
 549 }
 550
 551 #
 552 # fsyntax: o2libdll
 553 # fdesc: .o files link to static & dynamic library.
 554 #
 555 o2libdll ()
 556 {
 557         local cmd=
 558         local output=
 559         local ret=
 560         local file=
 561         local srcfile=
 562
 563         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && SRC_FILE[0]="$1"
 564         [[ -n "${2}" && "${2}" =~ (${EXT_NAME[lib]}|${EXT_NAME[dll]})$ ]] && DST_FILE[1]="$2"
 565         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 566         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 567         link_filename_fix
 568
 569         mkdir -p $(dirname ${DST_FILE[0]})
 570
 571         file=$DST_FILE
 572         srcfile=( ${SRC_FILE[@]} )
 573         DST_FILE="${DST_FILE%\.*}.a"
 574
 575         eval cmd=\"$O2LIB_CMD_FMT\"
 576         cmd_run "$cmd"
 577         [[ $? != 0 ]] && return $?
 578
 579         ${RANLIB} ${file}
 580         [[ $? != 0 ]] && return $?
 581
 582         SRC_FILE=( ${srcfile[@]} )
 583         DST_FILE="${file%\.*}.so"
 584         eval cmd=\"$O2DLL_CMD_FMT\"
 585         cmd_run "$cmd"
 586         cmd=$?
 587
 588         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 589
 590         return $cmd
 591 }
 592
 593 #
 594 # fsyntax: o2exe
 595 # fdesc: .o files link to executables.
 596 #
 597 o2exe ()
 598 {
 599         local cmd=
 600
 601         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && SRC_FILE[0]="$1"
 602         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[exe]}$ ]] && DST_FILE[1]="$2"
 603         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 604         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 605         link_filename_fix
 606
 607         mkdir -p $(dirname ${DST_FILE[0]})
 608
 609         eval cmd=\"$O2EXE_CMD_FMT\"
 610         cmd_run "$cmd"
 611         cmd=$?
 612
 613         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 614
 615         return $cmd
 616 }
 617
 618 #
 619 # fsyntax: o2drv
 620 # fdesc: .o文件链接成elf格式linux的drv文件。
 621 #
 622 o2drv ()
 623 {
 624         local cmd=
 625
 626         [[ -n "${1}" && "${2}" =~ ${EXT_NAME[obj]}$ ]] && SRC_FILE[0]="$1"
 627         [[ -n "${2}" && "${2}" =~ ${EXT_NAME[drv]}$ ]] && DST_FILE[1]="$2"
 628         [[ -n "${3}" && "${2}" =~ \.dephdr$ ]] && DST_FILE[2]="$3"
 629         [[ -n "${4}" && "${2}" =~ \.cgraph$ ]] && DST_FILE[3]="$4"
 630         link_filename_fix
 631
 632         mkdir -p $(dirname ${DST_FILE[0]})
 633
 634         eval cmd=\"$O2DRV_CMD_FMT\"
 635         cmd_run "$cmd"
 636         cmd=$?
 637
 638         test "${OPT_OBJSIZE_INFO^^}" == 'Y' && eval ${SIZE} ${DST_FILE[1]}
 639
 640         return $cmd
 641 }
 642
 643 #########################################
 644 # build postage processing & info.
 645 # size of .text/.data/.rodata/.bss.
 646 # internal symbol of an executable file.
 647 # export symbol of an executable file.
 648 #
 649 #
 650 # nm -D <file>, dynamic symbol. U, imported; T, exported.
 651 # nm -g <file>, global symbol, all symbol.
 652 #
 653 # objdump -t <file> | grep -e "\.text", native code symbol.
 654 # objdump -t <file> | grep -e "\.data", initialized var symbol.
 655 # objdump -t <file> | grep -e "\.rodata", read only var symbol.
 656 # objdump -t <file> | grep -e "\.bss", uninitialized var symbol.
 657 #
 658 # size <file>, it display size info in .text/.data(.rodata)/.bss
 659 #########################################
 660
 661 #
 662 # fsyntax: progstrip
 663 # fdesc: delete debug symbol info .etc .
 664 #
 665 progstrip ()
 666 {
 667         local cmd=
 668         local output=
 669         local ret=
 670
 671         # attention -lncurses paramter must be put after .o file,
 672         # or it report err that symbol not found.
 673         cmd="${STRIP} $(echo ${DST_FILE[@]})"
 674
 675         toolchain_dbgout -ne "${CHIGHL} === ${cmd}${CNORMAL}\n"
 676
 677         # build operation
 678         output="$( eval $cmd 2>&1; )"
 679         ret=$?
 680
 681         echo -ne " === ${cmd}\n" >> ${OUTDIR}/build-dbgout.log
 682         echo -ne " === ${cmd}\n" >> ${OUTDIR}/build.log
 683
 684         if test $ret == 0 || test -z "$output" ; then
 685                 toolchain_dbgout -ne " === ${cmd}\n"
 686         else
 687                 toolchain_dbgout -ne "${CHIGHL} === ${cmd}${CNORMAL}\n"
 688                 toolchain_dbgout "$output"
 689                 echo "$output" >> ${OUTDIR}/build-dbgout.log
 690         fi
 691
 692         if test $ret != 0 ; then
 693                 return 2
 694         else
 695                 return 0
 696         fi
 697 }
 698
 699 #
 700 # fsyntax: prog_sizeinfo
 701 # fdesc: size of .text/.data/.rodata/.bss.
 702 #
 703 prog_sizeinfo ()
 704 {
 705         local cmd=
 706         local output=
 707         local ret=
 708         local file=
 709         local filelist=
 710
 711         DST_FILE="${OUTDIR}/${!3}"
 712
 713         fname_dstdir
 714 #       for file in ${SRC_FILE[@]}; do
 715 #               if test -f "${DSTDIR}/${file}" ; then
 716 #                       filelist+="${DSTDIR}/${file} "
 717 #               fi
 718 #       done
 719 #       filelist+="${DST_FILE}"
 720
 721         # attention -lncurses paramter must be put after .o file,
 722         # or it report err that symbol not found.
 723         cmd="${SIZE} $(basename ${DST_FILE})"
 724
 725         toolchain_dbgout -ne "${CHIGHL} === ${cmd}${CNORMAL}\n"
 726
 727         # build operation
 728         cd $(dirname ${DST_FILE})
 729         output="$( eval ${cmd} 2>&1; )"
 730         ret=$?
 731         cd - 2>&1 >/dev/null
 732
 733         echo -ne " === ${cmd}\n" >> ${OUTDIR}/build-dbgout.log
 734         echo -ne " === ${cmd}\n" >> ${OUTDIR}/build.log
 735
 736         if test $ret == 0 || test -z "$output" ; then
 737                 toolchain_dbgout -ne " === ${cmd}\n"
 738                 infoo "$output"
 739         else
 740                 toolchain_dbgout -ne "${CHIGHL} === ${cmd}${CNORMAL}\n"
 741                 infoo "$output"
 742                 echo "$output" >> ${OUTDIR}/build-dbgout.log
 743         fi
 744
 745         if test $ret != 0 ; then
 746                 return 2
 747         else
 748                 return 0
 749         fi
 750 }
 751
 752 #
 753 # fsyntax: prog_symboals
 754 # fdesc: output .text/.data/.rodata/.bss symbols in executables.
 755 #
 756 prog_symboals ()
 757 {
 758         local ret=
 759         local file=
 760
 761         while read file; do
 762                 toolchain_dbgout "[$file]"
 763                 { ${OBJDUMP} -t $file; ret=$?; } | grep -o -e "\*UND\*.*" -e "\.bss.*" -e "\.rodata.*"  -e "\.data.*" -e "\.text.*" | grep -v $'[ |\t]'"\..*" | grep -v \"00000000\" | sort | sed -e "s/\.text/func-i/g; s/\*UND\*/func-e/g; s///g; s/\.data/var-i/g; s/\.bss/var/g; s/\.rodata/var-e/g;"
 764                 [[ $ret != 0 ]] && break;
 765         done <<< "${SRC_FILE[@]}"
 766
 767         if test $ret != 0 ; then
 768                 return 2
 769         else
 770                 return 0
 771         fi
 772 }
 773
 774 SYMB_FILTER_SYS='y'
 775
 776 #
 777 # fsyntax: prog_inner_symbs
 778 # fdesc: output internal symbols in executables.
 779 #
 780 prog_inner_symbs ()
 781 {
 782         local ret=
 783         local file=
 784         local param=
 785
 786         [[ $SYMB_FILTER_SYS == 'y' ]] && param="-v \"00000000\""
 787
 788         while read file; do
 789                 toolchain_dbgout "[$file]"
 790                 { ${OBJDUMP} -t $file; ret=$?; } | grep -o -e "\.text.*"| grep -v $'[ |\t]'"\..*" | sort | sed -e "s/\.text/func-i/g;"
 791         done <<< "${SRC_FILE[@]}"
 792
 793         if test $ret != 0 ; then
 794                 return 2
 795         else
 796                 return 0
 797         fi
 798 }
 799
 800 #
 801 # fsyntax: prog_ext_symbs
 802 # fdesc: output external symbols in executables.
 803 #
 804 prog_ext_symbs ()
 805 {
 806         local ret=
 807         local file=
 808
 809         while read file; do
 810                 toolchain_dbgout "[$file]"
 811                 { ${OBJDUMP} -t $file; ret=$?; } | grep -o -e "\*UND\*.*"| grep -v $'[ |\t]'"\..*" | grep -v \"00000000\" | sort | sed -e "s/\*UND\*/func-e/g; s///g;"
 812         done <<< "${SRC_FILE[@]}"
 813
 814         if test $ret != 0 ; then
 815                 return 2
 816         else
 817                 return 0
 818         fi
 819 }
 820
 821 #
 822 # fsyntax: prog_func_symbs
 823 # fdesc: output function symbols in executables.
 824 #
 825 prog_func_symbs ()
 826 {
 827         local ret=
 828         local file=
 829
 830         while read file; do
 831                 toolchain_dbgout "[$file]"
 832                 { ${OBJDUMP} -t $file; ret=$?; } | grep -o -e "\*UND\*.*" -e "\.text.*" | grep -v $'[ |\t]'"\..*" | sort | sed -e "s/\.text/func-i/g; s/\*UND\*/func-e/g; s///g;"
 833         done <<< "${SRC_FILE[@]}"
 834
 835         if test $ret != 0 ; then
 836                 return 2
 837         else
 838                 return 0
 839         fi
 840 }
 841
 842 #
 843 # fsyntax: prog_func_symbs
 844 # fdesc: output function symbols in executables.
 845 #
 846 prog_var_symbs ()
 847 {
 848         local ret=
 849         local file=
 850
 851         while read file; do
 852                 toolchain_dbgout "[$file]"
 853                 { ${OBJDUMP} -t $file; ret=$?; } | grep -o  -e "\.bss.*" -e "\.rodata.*"  -e "\.data.*" | grep -v $'[ |\t]'"\..*" | grep -v \"00000000\" | sort | sed -e "s/\.text/func-i/g; s/\*UND\*/func-e/g; s///g;"
 854         done <<< "${SRC_FILE[@]}"
 855
 856         if test $ret != 0 ; then
 857                 return 2
 858         else
 859                 return 0
 860         fi
 861 }
 862
 863
 864 #########################################
 865 # bin/hex output and transform.
 866 #########################################
 867
 868
 869 #
 870 # fsyntax: exe2hex
 871 # fdesc: bin二进制文件转换成hex字符串。
 872 #
 873 exe2hex ()
 874 {
 875         exe2bin "$@"
 876         bin2hex "$@"
 877 }
 878
 879 #
 880 # fsyntax: exe2bin
 881 # fdesc: elf文件读取code/data的section，保存成bin文件。
 882 #   通常用于非操作系统环境下运行的程序。
 883 #
 884 exe2bin ()
 885 {
 886         local ret=
 887
 888         { objcopy -t $file | grep -o  -e "\.bss.*" -e "\.rodata.*"  -e "\.data.*"; ret=$?; } | grep -v $'[ |\t]'"\..*" | grep -v \"00000000\" | sort | sed -e "s/\.text/func-i/g; s/\*UND\*/func-e/g; s///g;"
 889
 890         if test $ret != 0 ; then
 891                 return 2
 892         else
 893                 return 0
 894         fi
 895 }
 896
 897 #
 898 # fsyntax: bin2hex
 899 # fdesc: bin二进制文件转换成hex字符串。
 900 #
 901 bin2hex ()
 902 {
 903 #       hexdump -e '/1 "%02x " '
 904         xxd -ps -c 16 - 2>/dev/null
 905 }
 906
 907 #
 908 # fsyntax: hex2bin
 909 # fdesc: hex字符串转换成bin二进制数据文件。
 910 #
 911 hex2bin ()
 912 {
 913         xxd -r - $2
 914 }
 915
 916 #
 917 # fsyntax: fbin2fhex <srcfile> <dst>
 918 # fdesc: bin二进制文件转换成hex文件。
 919 #
 920 fbin2fhex ()
 921 {
 922         xxd -ps -c 16 $1 2>/dev/null > $2
 923 }
 924
 925 #
 926 # fsyntax: fhex2fbin
 927 # fdesc: hex文件转换成bin二进制数据文件。
 928 #
 929 fhex2fbin ()
 930 {
 931         xxd -r $1 > $1
 932 }
 933
 934 #
 935 # or use ':'
 936 #
 937 nullcmd ()
 938 {
 939         echo "[error]: cmd not defined. look at the defination in toolchain/${TOOLCHAIN}.imi, or use another toolchain." >&2
 940         exit -1
 941 }
 942
 943 # syntax: without_pfx <pfx>
 944 without_pfx ()
 945 {
 946     local name=
 947     eval local varlist="\${!${1}*}"
 948
 949     for var in ${varlist}; do
 950         eval name="\${var#$1}"
 951         eval $name=${!var}
 952     done
 953 }
 954
 955 #
 956 # fdesc: get
 957 #
 958 get_toolchain_info ()
 959 {
 960         echo 'int main(){}' > /tmp/dummy.c
 961
 962         verbose_mode=y
 963         #
 964         # test the parameters setting in files.
 965         # use c2exe() instead of directly invoke, it can test for some 'GCC' cross-compiler.
 966         #
 967 #       gcc /tmp/dummy.c -I. -L/tmp/lib -Wl,-rpath,/tmp/lib -rdynamic -lpthread -v -Wl,--verbose &> /tmp/dummy.log
 968         LDFLAGS_EXT="-v -Wl,--verbose -lpthread" c2exe /tmp/dummy.c /tmp/dummy > /tmp/dummy.log
 969         unset verbose_mode
 970
 971         #
 972         # get include paths for '#include <...>'
 973         #
 974 #       echo "===== get include path ====="
 975         INC_PATHS=( `grep -B100 '^End of search list.' /tmp/dummy.log | grep -A100 '^#include <...>' | grep -v 'End of search list.' | grep -v '#include <...>'` )
 976 #       echo INC_PATHS:
 977 #       echo ${INC_PATHS[@]}
 978         # .
 979         # /usr/lib/gcc/i686-linux-gnu/5/include
 980         # /usr/local/include
 981         # /usr/lib/gcc/i686-linux-gnu/5/include-fixed
 982         # /usr/include/i386-linux-gnu
 983         # /usr/include
 984
 985         #
 986         # get lib paths in linking
 987         #
 988 #       echo "===== get lib path ====="
 989         LIB_PATHS=( `grep 'SEARCH.*/usr/lib' /tmp/dummy.log |sed 's|; |\n|g' | sed 's|SEARCH_DIR("=||g' | sed 's|")||g' | sed 's|;||g'` )
 990 #       echo LIB_PATHS:
 991 #       echo ${LIB_PATHS[@]}
 992         #/usr/local/lib/i386-linux-gnu
 993         #/lib/i386-linux-gnu
 994         #/usr/lib/i386-linux-gnu
 995         #/usr/local/lib32
 996         #/lib32
 997         #/usr/lib32
 998         #/usr/local/lib
 999         #/lib
1000         #/usr/lib
1001         #/usr/i686-linux-gnu/lib32
1002         #/usr/i686-linux-gnu/lib
1003
1004         #
1005         # get lib libpthread linked in.
1006         #
1007 #       echo "===== get libs ====="
1008         LINKED_LIBS=( `grep -e 'succeeded' /tmp/dummy.log | grep -v '\.o[[:blank:]]*' | sed 's|attempt to open ||g' | sed 's| succeeded||g' | xargs file -L 2>/dev/null| grep -E 'ELF|archive' | sed 's|:.*$||g'` )
1009 #       echo LINKED_LIBS:
1010 #       echo ${LINKED_LIBS[@]}
1011         #/lib/i386-linux-gnu/libpthread.so.0
1012         #/usr/lib/i386-linux-gnu/libpthread_nonshared.a
1013
1014         rm /tmp/dummy.c /tmp/dummy /tmp/dummy.log
1015 }
1016
1017 toolchain_init ()
1018 {
1019         #loadimi ../platform/param.imi
1020
1021         #
1022         # toolchain config info & general define info.
1023         # TBD: config info should be get from cmd param or envar.
1024         #
1025         loadimi ${SRCPKG_DIR_FULL}/build/toolchain-cfg.imi
1026
1027         echo =========================== MACHTYPE=$MACHTYPE
1028
1029         loadimi ${SRCPKG_DIR_FULL}/tools/build-srcpkg/platform/toolchain_info.imi
1030
1031         echo =========================== MACHTYPE=$MACHTYPE
1032
1033         # other build utilities.
1034         #loadimi ../toolset/toolset.imi
1035 }
1036
1037 toolchain_default_param_load ()
1038 {
1039         loadimi tools/build-srcpkg/info/paramters.imi
1040 }
1041
1042
1043
1044 ######################
1045 # section: file tail
1046 ######################
1047
1048 return 0
1049
1050
1051 #
1052 # fsyntax: toolchain_chk
1053 # fdesc: check toolchain if it can works in usual. save flags in
1054 #        build-srcpkg config file.
1055 #
1056 toolchain_chk ()
1057 {
1058         # TBD:
1059         :
1060 }
1061
1062 #
1063 # fsyntax: dev_env_chk
1064 # fdesc: check commands and build env.
1065 #
1066 dev_env_chk ()
1067 {
1068         # TBD:
1069         :
1070 }
1071
1072 #
1073 # fsyntax: dep_lib_chk
1074 # fdesc: check external lib file if it exist and can works.
1075 #        save checking resualt into build-srcpkg config file.
1076 #
1077 dep_lib_chk ()
1078 {
1079         # TBD:
1080         :
1081 }
1082
1083 #
1084 # fsyntax: dep_syshdr_chk
1085 # fdesc: check system .h file if it exist.
1086 #
1087 dep_syshdr_chk ()
1088 {
1089         # TBD:
1090         :
1091 }