libc/Jamfile

   1 # This file is used to build the Bionic library with the Jam build
   2 # tool. For info, see www.perforce.com/jam/jam.html
   3 #
   4
   5 BIONIC_TOP ?= $(DOT) ;
   6
   7 DEBUG = 1 ;
   8
   9 # pattern used for automatic heade inclusion detection
  10 HDRPATTERN = "^[        ]*#[    ]*include[      ]*[<\"]([^\">]*)[\">].*$" ;
  11
  12
  13 # debugging support, simply define the DEBUG variable to activate verbose output
  14 rule Debug
  15 {
  16     if $(DEBUG) {
  17         Echo $(1) ;
  18     }
  19 }
  20
  21 # return all elements from $(1) that are not in $(2)
  22 rule Filter  list : filter
  23 {
  24     local result = ;
  25     local item ;
  26     for item in $(list) {
  27         if ! $(item) in $(filter) {
  28             result += $(item) ;
  29         }
  30     }
  31     return $(result) ;
  32 }
  33
  34
  35 # reverse a list of elements
  36 rule Reverse  list
  37 {
  38     local  result = ;
  39     local  item ;
  40
  41     for item in $(list) {
  42         result = $(item) $(result) ;
  43     }
  44     return $(result) ;
  45 }
  46
  47
  48 # decompose a path into a list of elements
  49 rule PathDecompose  dir
  50 {
  51     local  result ;
  52
  53     while $(dir:D)
  54     {
  55         if ! $(dir:BS) {  # for rooted paths like "/foo"
  56             break ;
  57         }
  58         result = $(dir:BS) $(result) ;
  59         dir    = $(dir:D) ;
  60     }
  61     result = $(dir) $(result) ;
  62     return $(result) ;
  63 }
  64
  65
  66 # simply a file path, i.e. get rid of . or .. when possible
  67 rule _PathSimplify  dir
  68 {
  69     local  result = ;
  70     local  dir2 d ;
  71
  72     dir  = [ PathDecompose $(dir) ] ;
  73
  74     # get rid of any single dot
  75     dir2 = ;
  76     for d in $(dir) {
  77         if $(d) = "." {
  78             continue ;
  79         }
  80         dir2 += $(d) ;
  81     }
  82
  83     # get rid of .. when possible
  84     for d in $(dir2) {
  85         if $(d) = ".." && $(result) {
  86             result = $(result[2-]) ;
  87         }
  88         else
  89             result = $(d) $(result) ;
  90     }
  91
  92     # now invert the result
  93     result = [ Reverse $(result) ] ;
  94     if ! $(result) {
  95         result = "." ;
  96     }
  97     return $(result:J="/") ;
  98 }
  99
 100
 101 rule PathSimplify  dirs
 102 {
 103     local result ;
 104     local d ;
 105     for d in $(dirs) {
 106         result += [ _PathSimplify $(d) ] ;
 107     }
 108     return $(result) ;
 109 }
 110
 111
 112 # retrieve list of subdirectories
 113 rule ListSubDirs  paths
 114 {
 115     local  result  = ;
 116     local  entry ;
 117     for entry in [ Glob $(paths) : * ] {
 118         if ! $(entry:S) {
 119             result += $(entry) ;
 120         }
 121     }
 122     return [ PathSimplify $(result) ] ;
 123 }
 124
 125
 126 # retrieve list of sources in a given directory
 127 rule ListSources  path
 128 {
 129     return [ Glob $(path) : *.S *.c ] ;
 130 }
 131
 132
 133 # find the prebuilt directory
 134 #
 135 if ! $(TOP) {
 136     Echo "Please define TOP as the root of your device build tree" ;
 137     Exit ;
 138 }
 139
 140 Debug "OS is" $(OS) ;
 141 Debug "CPU is" $(CPU) ;
 142
 143 if $(OS) = LINUX
 144 {
 145     PREBUILT = $(TOP)/prebuilt/Linux ;
 146 }
 147 else if $(OS) = MACOSX
 148 {
 149     switch $(CPU) {
 150         case i386 : PREBUILT = $(TOP)/prebuilt/darwin-x86 ; break ;
 151         case ppc  : PREBUILT = $(TOP)/prebuilt/darwin-ppc ; break ;
 152         case *    : Echo "unsupported CPU" "$(CPU) !!" ;
 153                     Echo "Please contact digit@google.com for help" ;
 154                     Exit ;
 155     }
 156 }
 157 else
 158 {
 159     Echo "Unsupported operating system" $(OS) ;
 160     Echo "Please contact digit@google.com for help" ;
 161     Exit ;
 162 }
 163
 164 Debug "TOP is" $(TOP) ;
 165 Debug "PREBUILT is" $(PREBUILT) ;
 166
 167
 168 # check architectures and setup toolchain variables
 169 #
 170 SUPPORTED_ARCHS = x86 arm ;
 171
 172 ARCH ?= $(SUPPORTED_ARCHS) ;
 173
 174 if ! $(ARCH) in $(SUPPORTED_ARCHS) {
 175     Echo "The variable ARCH contains an unsupported value, use one or more of these instead" ;
 176     Echo "separated by spaces:" $(SUPPORTED_ARCHS) ;
 177     Exit ;
 178 }
 179
 180 x86_TOOLSET_PREFIX ?= "" ;
 181 arm_TOOLSET_PREFIX ?= $(TOP)/prebuilt/Linux/toolchain-4.1.1/bin/arm-elf- ;
 182
 183 for arch in $(ARCH) {
 184     CC_$(arch)  = $($(arch)_TOOLSET_PREFIX)gcc ;
 185     C++_$(arch) = $($(arch)_TOOLSET_PREFIX)g++ ;
 186     AR_$(arch)  = $($(arch)_TOOLSET_PREFIX)ar ;
 187 }
 188
 189
 190 # the list of arch-independent source subdirectories
 191 BIONIC_SRC_SUBDIRS = string ;
 192 BIONIC_x86_SUBDIRS = ;
 193 BIONIC_arm_SUBDIRS = ;
 194
 195 CFLAGS   = -O0 -g -W ;
 196
 197
 198
 199 # find sources in a given list of subdirectories
 200 rule FindSources  dirs
 201 {
 202     local dir ;
 203
 204     for dir in $(dirs)
 205     {
 206         local LOCAL_SRC NO_LOCAL_SRC ;
 207
 208         if [ Glob $(dir) : rules.jam ] {
 209             include $(dir)/rules.jam ;
 210             if $(LOCAL_SRC) {
 211                 _sources = $(LOCAL_SRC) ;
 212             }
 213             else {
 214                 _sources = [ Glob $(dir) : *.S *.c ] ;
 215                 _sources = $(_sources:BS) ;
 216             }
 217             if $(NO_LOCAL_SRC) {
 218                 _sources = [ Filter $(_sources) : $(NO_LOCAL_SRC) ] ;
 219             }
 220             sources += $(dir)/$(_sources) ;
 221         }
 222         else
 223             sources += [ ListSources $(dir) ] ;
 224     }
 225 }
 226
 227 # Compile a given object file from a source
 228 rule Compile  object : source
 229 {
 230     Depends $(object) : $(source) ;
 231     Depends bionic : $(object) ;
 232     Clean clean : $(object) ;
 233
 234     MakeLocate $(object) : $(OUT) ;
 235
 236
 237     CC on $(object)       = $(CC_$(arch)) ;
 238     CFLAGS on $(object)   = $(CFLAGS) ;
 239     INCLUDES on $(object) = $(INCLUDES) ;
 240     DEFINES on $(object)  = $(DEFINES) ;
 241
 242     HDRRULE on $(>) = HdrRule ;
 243     HDRSCAN on $(>) = $(HDRPATTERN) ;
 244     HDRSEARCH on $(>) = $(INCLUDES) ;
 245     HDRGRIST on $(>) = $(HDRGRIST) ;
 246 }
 247
 248
 249 actions Compile
 250 {
 251     $(CC) -c -o $(1) $(CFLAGS) -I$(INCLUDES) -D$(DEFINES) $(2)
 252 }
 253
 254
 255 rule RmTemps
 256 {
 257     Temporary $(2) ;
 258 }
 259
 260 actions quietly updated piecemeal together RmTemps
 261 {
 262     rm -f $(2)
 263 }
 264
 265 actions Archive
 266 {
 267     $(AR) ru $(1) $(2)
 268 }
 269
 270 rule Library  library : objects
 271 {
 272     local  obj ;
 273
 274     if ! $(library:S) {
 275         library = $(library:S=.a) ;
 276     }
 277     library = $(library:G=<$(arch)>) ;
 278
 279     Depends all : $(library) ;
 280
 281     if ! $(library:D) {
 282         MakeLocate $(library) $(library)($(objects:BS)) : $(OUT) ;
 283     }
 284
 285     Depends $(library) : $(library)($(objects:BS)) ;
 286     for obj in $(objects) {
 287         Depends $(library)($(obj:BS)) : $(obj) ;
 288     }
 289
 290     Clean clean : $(library) ;
 291
 292     AR on $(library) = $(AR_$(arch)) ;
 293     Archive $(library) : $(objects) ;
 294
 295     RmTemps $(library) : $(objects) ;
 296 }
 297
 298
 299 rule  ProcessDir
 300 {
 301     local CFLAGS   = $(CFLAGS) ;
 302     local DEFINES  = $(DEFINES) ;
 303     local INCLUDES = $(INCLUDES) ;
 304     local local_rules = [ Glob $(1) : rules.jam ] ;
 305     local source sources ;
 306
 307     if $(local_rules) {
 308         local LOCAL_CFLAGS LOCAL_DEFINES LOCAL_INCLUDES LOCAL_SRC NO_LOCAL_SRC ;
 309
 310         include $(local_rules) ;
 311         CFLAGS   += $(LOCAL_CFLAGS) ;
 312         DEFINES  += $(LOCAL_DEFINES) ;
 313         INCLUDES += $(LOCAL_INCLUDES) ;
 314
 315         if $(LOCAL_SRC) {
 316             sources = $(LOCAL_SRC) ;
 317         }
 318         else {
 319             sources = [ Glob $(1) : *.S *.c ] ;
 320             sources = $(sources:BS) ;
 321         }
 322
 323         if $(NO_LOCAL_SRC) {
 324             sources = [ Filter $(sources) : $(NO_LOCAL_SRC) ] ;
 325         }
 326
 327         sources = $(1)/$(sources) ;
 328     }
 329     else
 330         sources = [ Glob $(1) : *.S *.c ] ;
 331
 332     for source in $(sources) {
 333         local name = $(source:B) ;
 334
 335         if $(source:S) = ".S" {
 336             # record the list of assembler sources
 337             ASSEMBLER_SOURCES += $(name) ;
 338         }
 339         else if $(source:S) = ".c" && $(name) in $(ASSEMBLER_SOURCES) {
 340             # skip C source file if corresponding assembler exists
 341             continue ;
 342         }
 343
 344         objname = <$(arch)>$(name).o  ;
 345
 346         Compile $(objname) : $(source) ;
 347         ALL_OBJECTS += $(objname) ;
 348     }
 349 }
 350
 351 rule ProcessDirs
 352 {
 353     local  dir ;
 354     for dir in $(1) {
 355         ProcessDir $(dir) ;
 356     }
 357 }
 358
 359 INCLUDES_x86 = /usr/src/linux/include ;
 360
 361 INCLUDES_arm = ../kernel_headers
 362                include/arch/arm
 363                include/bits32
 364                ;
 365
 366 INCLUDES = include stdio string stdlib .
 367            ../msun/include
 368            ;
 369
 370 DEFINES  = ANDROID_CHANGES
 371            USE_LOCKS
 372            REALLOC_ZERO_BYTES_FREES
 373            _LIBC=1
 374            SOFTFLOAT
 375            FLOATING_POINT
 376            NEED_PSELECT=1
 377            ANDROID
 378            ;
 379
 380 CFLAGS_x86 = ;
 381
 382
 383 for arch in $(ARCH)
 384 {
 385     local ARCH_DIR = $(BIONIC_TOP)/arch-$(arch) ;
 386     local INCLUDES = $(INCLUDES_$(arch)) $(ARCH_DIR)/include $(INCLUDES) ;
 387     local DEFINES  = $(DEFINES_$(arch)) $(DEFINES) ARCH=$(arch)  ;
 388     local CFLAGS   = $(CFLAGS) $(CFLAGS_$(arch)) ;
 389     local OUT      = out/$(arch) ;
 390     local ASSEMBLER_SOURCES ALL_OBJECTS ;
 391
 392     ProcessDirs [ ListSubDirs $(ARCH_DIR) ] ;
 393     ProcessDirs stdlib stdio unistd string tzcode inet ;
 394     ProcessDirs [ ListSubDirs netbsd ] ;
 395     ProcessDirs bionic ;
 396
 397     Library bionic : $(ALL_OBJECTS) ;
 398 }
 399
 400 BIONIC_SEARCH = $(BIONIC_TOP)/include ;
 401
 402
 403
 404 # /HdrRule source : headers ;
 405 #
 406 # Arranges the proper dependencies when the file _source_ includes the files
 407 # _headers_ through the #include C preprocessor directive
 408 #
 409 # this rule is not intendend to be called explicitely. It is called
 410 # automatically during header scanning on sources handled by the @Object
 411 # rule (e.g. sources in @Main or @Library rules)
 412 #
 413 rule HdrRule
 414 {
 415     # HdrRule source : headers ;
 416
 417     # N.B.  This rule is called during binding, potentially after
 418     # the fate of many targets has been determined, and must be
 419     # used with caution: don't add dependencies to unrelated
 420     # targets, and don't set variables on $(<).
 421
 422     # Tell Jam that anything depending on $(<) also depends on $(>),
 423     # set SEARCH so Jam can find the headers, but then say we don't
 424     # care if we can't actually find the headers (they may have been
 425     # within ifdefs),
 426
 427     local s = $(>:G=$(HDRGRIST:E)) ;
 428
 429     Includes $(<) : $(s) ;
 430     SEARCH on $(s) = $(HDRSEARCH) ;
 431     NoCare $(s) ;
 432
 433     # Propagate on $(<) to $(>)
 434
 435     HDRSEARCH on $(s) = $(HDRSEARCH) ;
 436     HDRSCAN on $(s) = $(HDRSCAN) ;
 437     HDRRULE on $(s) = $(HDRRULE) ;
 438     HDRGRIST on $(s) = $(HDRGRIST) ;
 439 }
 440
 441