build/jam/SystemLibraryRules

   1 rule Libstdc++ForImage
   2 {
   3         # Libstdc++ForImage
   4         #
   5         # Returns the c++-standard-library to be put onto the image.
   6
   7         if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
   8                 # the libstdc++.so for our legacy compiler (needs to be built)
   9                 return libstdc++.r4.so ;
  10         }
  11
  12         # libstdc++.so for other architectures comes with the gcc_syslibs
  13         # package, so there's no library to put onto the image directly.
  14         return ;
  15 }
  16
  17
  18 rule TargetLibstdc++ asPath
  19 {
  20         # TargetLibstdc++ [ <asPath> ]
  21         #
  22         # Returns the c++-standard-library for the target.
  23         # Invoking with <asPath> = true will return the full library path.
  24
  25         if $(TARGET_PLATFORM) = haiku {
  26                 if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
  27                         # the libstdc++.so for our legacy compiler (needs to be built)
  28                         return libstdc++.r4.so ;
  29                 }
  30                 # return libstdc++.so from the gcc_syslibs build feature.
  31                 local flags ;
  32                 if $(asPath) = true {
  33                         flags += path ;
  34                 }
  35                 return [
  36                         BuildFeatureAttribute gcc_syslibs : libstdc++.so : $(flags)
  37                 ] ;
  38         } else {
  39                 if $(TARGET_PLATFORM) = libbe_test {
  40                         # Use the existing host library
  41                         return stdc++.r4 ;
  42                 }
  43                 # TODO: return libstdc++.so for non-Haiku target platform if needed
  44         }
  45 }
  46
  47
  48 rule TargetLibsupc++ asPath
  49 {
  50         # TargetLibsupc++ [ <asPath> ]
  51         #
  52         # Returns the c++-support-library for the target.
  53         # Invoking with <asPath> = true will return the full library path.
  54
  55         if $(TARGET_PLATFORM) = haiku {
  56                 if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
  57                         # there is no libsupc++.so for the legacy compiler
  58                         return ;
  59                 }
  60                 # return libstdc++.so (which includes libsupc++) from the gcc_syslibs
  61                 # build feature.
  62                 local flags ;
  63                 if $(asPath) = true {
  64                         flags += path ;
  65                 }
  66                 return [
  67                         BuildFeatureAttribute gcc_syslibs : libstdc++.so : $(flags)
  68                 ] ;
  69         } else {
  70                 # TODO: return libsupc++.so for non-Haiku target platform if needed
  71         }
  72 }
  73
  74
  75 rule TargetStaticLibsupc++ asPath
  76 {
  77         # TargetStaticLibsupc++ [ <asPath> ]
  78         #
  79         # Returns the static c++-support-library for the target.
  80         # Invoking with <asPath> = true will return the full library path.
  81
  82         if $(TARGET_PLATFORM) = haiku {
  83                 # return libsupc++.a from the gcc_syslibs_devel build feature.
  84                 local flags ;
  85                 if $(asPath) = true {
  86                         flags += path ;
  87                 }
  88                 return [
  89                         BuildFeatureAttribute gcc_syslibs_devel : libsupc++.a : $(flags)
  90                 ] ;
  91         } else {
  92                 # TODO: return libsupc++.a for non-Haiku target platform if needed
  93         }
  94 }
  95
  96
  97 rule TargetKernelLibsupc++ asPath
  98 {
  99         # TargetKernelLibsupc++ [ <asPath> ]
 100         #
 101         # Returns the static kernel c++-support-library for the target.
 102         # Invoking with <asPath> = true will return the full library path.
 103
 104         if $(TARGET_PLATFORM) = haiku {
 105                 # return libsupc++-kernel.a from the gcc_syslibs_devel build feature.
 106                 local flags ;
 107                 if $(asPath) = true {
 108                         flags += path ;
 109                 }
 110                 return [
 111                         BuildFeatureAttribute gcc_syslibs_devel
 112                                 : libsupc++-kernel.a : $(flags)
 113                 ] ;
 114         } else {
 115                 # There is no libsupc++-kernel.a for non-Haiku target platform
 116         }
 117 }
 118
 119
 120 rule TargetBootLibsupc++ asPath
 121 {
 122         # TargetBootLibsupc++ [ <asPath> ]
 123         #
 124         # Returns the static bootloader c++-support-library for the target.
 125         # Invoking with <asPath> = true will return the full library path.
 126
 127         if $(TARGET_PLATFORM) = haiku {
 128                 if $(TARGET_PACKAGING_ARCH) = x86_64 {
 129                         # we need to use the 32-bit libsupc++.a built by the cross-compiler
 130                         return $(TARGET_BOOT_LIBSUPC++) ;
 131
 132                         # TODO: ideally, we would build this as part of gcc_syslibs_devel,
 133                         #       but that isn't currently possible, as that would require
 134                         #       32-bit support (libraries and glue-code) on x86_64-Haiku.
 135                 }
 136                 # no special boot version of libsupc++.a needed, so we return
 137                 # libsupc++-kernel.a from the gcc_syslibs_devel build feature.
 138                 local flags ;
 139                 if $(asPath) = true {
 140                         flags += path ;
 141                 }
 142                 return [
 143                         BuildFeatureAttribute gcc_syslibs_devel
 144                                 : libsupc++-kernel.a : $(flags)
 145                 ] ;
 146         } else {
 147                 # There is no libsupc++-boot.a for non-Haiku target platform
 148         }
 149 }
 150
 151
 152 rule TargetLibgcc asPath
 153 {
 154         # TargetLibgcc [ <asPath> ]
 155         #
 156         # Returns the default libgcc(s) for the target. On x86_gcc2, this is the
 157         # static libgcc, on everything else this will return the shared libgcc_s
 158         # followed by the static libgcc (both are needed as they do not contain
 159         # the same set of symbols).
 160         # Invoking with <asPath> = true will return the full library path.
 161
 162         if $(TARGET_PLATFORM) = haiku {
 163                 local flags ;
 164                 if $(asPath) = true {
 165                         flags += path ;
 166                 }
 167                 if $(TARGET_PACKAGING_ARCH) = x86_gcc2 {
 168                         # return libgcc.a from the gcc_syslibs_devel build feature.
 169                         return [
 170                                 BuildFeatureAttribute gcc_syslibs_devel : libgcc.a : $(flags)
 171                         ] ;
 172                 } else {
 173                         # return libgcc_s.so from the gcc_syslibs build feature and libgcc.a
 174                         # from the gcc_syslibs_devel build feature.
 175                         return [
 176                                 BuildFeatureAttribute gcc_syslibs : libgcc_s.so : $(flags)
 177                         ] [
 178                                 BuildFeatureAttribute gcc_syslibs_devel : libgcc.a : $(flags)
 179                         ] ;
 180                 }
 181         } else {
 182                 # TODO: return libgcc for non-Haiku target platform if needed
 183         }
 184 }
 185
 186
 187 rule TargetStaticLibgcc asPath
 188 {
 189         # TargetStaticLibgcc [ <asPath> ]
 190         #
 191         # Returns the static libgcc for the target.
 192         # Invoking with <asPath> = true will return the full library path.
 193
 194         if $(TARGET_PLATFORM) = haiku {
 195                 # return libgcc.a from the gcc_syslibs_devel build feature.
 196                 local flags ;
 197                 if $(asPath) = true {
 198                         flags += path ;
 199                 }
 200                 return [
 201                         BuildFeatureAttribute gcc_syslibs_devel : libgcc.a : $(flags)
 202                 ] ;
 203         } else {
 204                 # TODO: return libgcc.a for non-Haiku target platform if needed
 205         }
 206 }
 207
 208
 209 rule TargetKernelLibgcc asPath
 210 {
 211         # TargetKernelLibgcc [ <asPath> ]
 212         #
 213         # Returns the static kernel libgcc for the target.
 214         # Invoking with <asPath> = true will return the full library path.
 215
 216         if $(TARGET_PLATFORM) = haiku {
 217                 # return libgcc-kernel.a from the gcc_syslibs_devel build feature.
 218                 local flags ;
 219                 if $(asPath) = true {
 220                         flags += path ;
 221                 }
 222                 return [
 223                         BuildFeatureAttribute gcc_syslibs_devel
 224                                 : libgcc-kernel.a : $(flags)
 225                 ] ;
 226         } else {
 227                 # there is no libgcc-kernel.a for non-Haiku target platform
 228         }
 229 }
 230
 231
 232 rule TargetBootLibgcc asPath
 233 {
 234         # TargetBootLibgcc [ <asPath> ]
 235         #
 236         # Returns the static bootloader libgcc for the target.
 237         # Invoking with <asPath> = true will return the full library path.
 238
 239         if $(TARGET_PLATFORM) = haiku {
 240                 if $(TARGET_PACKAGING_ARCH) = x86_64 {
 241                         # we need to use the 32-bit libgcc.a built by the cross-compiler
 242                         return $(TARGET_BOOT_LIBGCC) ;
 243
 244                         # TODO: ideally, we would build this as part of gcc_syslibs_devel,
 245                         #       but that isn't currently possible, as that would require
 246                         #       32-bit support (libraries and glue-code) on x86_64-Haiku.
 247                 }
 248                 # no special boot version of libgcc needed, so we return
 249                 # libgcc-kernel.a from the gcc_syslibs_devel build feature.
 250                 local flags ;
 251                 if $(asPath) = true {
 252                         flags += path ;
 253                 }
 254                 return [
 255                         BuildFeatureAttribute gcc_syslibs_devel
 256                                 : libgcc-kernel.a : $(flags)
 257                 ] ;
 258         } else {
 259                 # there is no libgcc-boot.a for non-Haiku target platform
 260         }
 261 }
 262
 263
 264 rule TargetStaticLibgcceh asPath
 265 {
 266         # TargetStaticLibgcceh [ <asPath> ]
 267         #
 268         # Returns the static libgcc_eh for the target.
 269         # Invoking with <asPath> = true will return the full library path.
 270
 271         if $(TARGET_PLATFORM) = haiku {
 272                 # return libgcc.a from the gcc_syslibs_devel build feature.
 273                 local flags ;
 274                 if $(asPath) = true {
 275                         flags += path ;
 276                 }
 277                 return [
 278                         BuildFeatureAttribute gcc_syslibs_devel : libgcc_eh.a : $(flags)
 279                 ] ;
 280         } else {
 281                 # TODO: return libgcc_eh.a for non-Haiku target platform if needed
 282         }
 283 }
 284
 285
 286 rule TargetKernelLibgcceh asPath
 287 {
 288         # TargetKernelLibgcceh [ <asPath> ]
 289         #
 290         # Returns the static kernel libgcc_eh for the target.
 291         # Invoking with <asPath> = true will return the full library path.
 292
 293         if $(TARGET_PLATFORM) = haiku {
 294                 # return libgcc_eh-kernel.a from the gcc_syslibs_devel build feature.
 295                 local flags ;
 296                 if $(asPath) = true {
 297                         flags += path ;
 298                 }
 299                 return [
 300                         BuildFeatureAttribute gcc_syslibs_devel
 301                                 : libgcc_eh-kernel.a : $(flags)
 302                 ] ;
 303         } else {
 304                 # there is no libgcc_eh-kernel.a for non-Haiku target platform
 305         }
 306 }
 307
 308
 309 rule C++HeaderDirectories architecture
 310 {
 311         # C++HeaderDirectories
 312         #
 313         # Returns the c++ header directories to use for the given architecture.
 314
 315         local c++HeaderDirs ;
 316         if $(architecture) = x86_gcc2 {
 317                 c++HeaderDirs = [ FDirName $(HAIKU_TOP) headers cpp ] ;
 318         } else if $(PLATFORM) = bootstrap_stage0 {
 319                 # Currently, no c++-headers are needed for stage0 of the boostrap.
 320         } else {
 321                 local baseDir = [
 322                         BuildFeatureAttribute gcc_syslibs_devel : c++-headers : path
 323                 ] ;
 324                 if $(baseDir) {
 325                         c++HeaderDirs =
 326                                 $(baseDir)
 327                                 [ FDirName $(baseDir) $(HAIKU_GCC_MACHINE_$(architecture)) ]
 328                                 [ FDirName $(baseDir) backward ]
 329                                 [ FDirName $(baseDir) ext ]
 330                                 ;
 331                 }
 332         }
 333
 334         return $(c++HeaderDirs) ;
 335 }
 336
 337 rule GccHeaderDirectories architecture
 338 {
 339         # GccHeaderDirectories
 340         #
 341         # Returns the gcc header directories to use for the given architecture.
 342
 343         local gccHeaderDirs ;
 344         if $(architecture) = x86_gcc2 {
 345                 gccHeaderDirs = [ FDirName $(HAIKU_TOP) headers build gcc-2.95.3 ] ;
 346         } else if $(PLATFORM) = bootstrap_stage0 {
 347                 gccHeaderDirs =
 348                         [ FDirName $(HAIKU_GCC_LIB_DIR_$(architecture)) include ]
 349                         [ FDirName $(HAIKU_GCC_LIB_DIR_$(architecture)) include-fixed ]
 350                         ;
 351         } else {
 352                 local baseDir = [
 353                         BuildFeatureAttribute gcc_syslibs_devel : gcc-headers : path
 354                 ] ;
 355                 if $(baseDir) {
 356                         gccHeaderDirs =
 357                                 [ FDirName $(baseDir) include ]
 358                                 [ FDirName $(baseDir) include-fixed ]
 359                                 ;
 360                 }
 361         }
 362
 363         return $(gccHeaderDirs) ;
 364 }