Jamrules

NOARSCAN = true ;
ALL_LOCATE_TARGET ?= build ;

################################################################################
# Save the host toolset information

HOST_TOOLSET    = $(TOOLSET) ;
HOST_AS         = $(AS) ;
HOST_AR         = $(AR) ;
HOST_CC         = $(CC) ;
HOST_CCFLAGS    = $(CCFLAGS) ;
HOST_C++        = $(C++)     ;
HOST_C++FLAGS   = $(C++FLAGS) ;
HOST_LINK       = $(LINK) ;
HOST_LINKFLAGS  = $(LINKFLAGS) ;
HOST_LINKLIBS   = $(LINKLIBS) ;
HOST_OPTIM      = $(OPTIM) ;
HOST_STDHDRS    = $(STDHDRS) ;
HOST_SUFEXE     = $(SUFEXE) ;
HOST_SUFLIB     = $(SUFLIB) ;
HOST_SUFOBJ     = $(SUFOBJ) ;
HOST_UNDEFFLAG  = $(UNDEFFLAG) ;
HOST_PICFLAGS   = $(PICFLAG) ;

################################################################################
# Include a file only once

rule SubIncludeOnce {
    if ! $($(1:J=__)_INCLUDED) {
        #ECHO Including $(1) ;
        SubInclude $(1) ;
    } else {
        #ECHO Not including $(1) ;
    }
}

# Set the flag that SubIncludeOnce uses
rule _SubSetIncluded {
    #ECHO Included $(1) ;
    if ! $($(1:J=__)_INCLUDED) {
        $(1:J=__)_INCLUDED = 1 ;
    }
}

# Add the Gandr include dirs to headers
rule _AddHeaders {
    PDCLibConfig ;
    SUBDIRHDRS += $(GD_INCLUDE_DIRS) ;
}

################################################################################
# PDCLib

PDCLIB_NO_TEST          = 1 ;
PDCLIB_PLATFORM         = gandr ;

################################################################################
# Gandr special rules

# Adds Bal source files
rule GdBalSources {
    local _obj = $(1:S=$(SUFOBJ)) ;
    MakeLocate $(_obj) : $(LOCATE_TARGET) ;
    GD_BAL_OBJECTS += [ FGristFiles $(_obj) ] ;
    Objects $(1) ;
    ObjectHdrs $(1) : $(GD_INCLUDE_DIRS) ;
}


# Add an include dir (Config.jam)
# GdIncludeDir $(GD_TOP) dir dir dir ;
rule GdIncludeDir {
    GD_INCLUDE_DIRS += [ FDirName $(1) ] ;
}

GD_STUB_GEN = [ FDirName $(GD_TOP) tools gd_stub_gen ] ;
# Parse the ioctl definition
# GdIoctls lib : <source> ;
rule GdIoctls {
    local files = [ COMMAND $(GD_STUB_GEN) ioctl $(>) -stubdir ioctl_stubs -list ] ;
    files = [ FGristFiles $(files) ] ;
    ECHO ioctl files are $(files) ;

    GdIoctlGen $(files) gd_ioctl.h : $(>) : include/gd_ioctl.h : include/gd_ioctl_map.h : ioctl_stubs ;
    Library $(<) : $(files) ioctl_stubs/gd_ioctl_stub.S ;
}

# Internal
# GdIoctlGen $(< stubs) : $(> input) : $(3 hdr) : $(4 map) $(5 dir) ;
rule GdIoctlGen {
    ECHO $(<) from $(>) ;
    MakeLocate $(<) $(3) $(4) $(5) : $(LOCATE_TARGET) ;
    DEPENDS $(<) (3) $(4) $(5) : $(>) $(GD_STUB_GEN) ;
    DIR on $(<) = [ FDirName $(LOCATE_TARGET) $(5) ] ;
    MAP on $(<) = [ FDirName $(LOCATE_TARGET) $(4) ] ;
    HDR on $(<) = [ FDirName $(LOCATE_TARGET) $(3) ] ;
}

actions GdIoctlGen {
    $(GD_STUB_GEN) ioctl $(>) -stubdir $(DIR) -stubs -hdr $(HDR) -map $(MAP)
}

# Parse the syscall definition
# GdIoctls lib : <source> ;
rule GdSyscalls {
    local files = [ COMMAND $(GD_STUB_GEN) syscall $(>) -stubdir syscall_stubs -list ] ;
    files = [ FGristFiles $(files) ] ;
    ECHO syscall files are $(files) ;

    GdSyscallGen $(files) gd_syscall.h gd_syscall.c : $(>) : include/gd_syscall.h : gd_syscall.c : syscall_stubs ;
    Library $(<) : $(files) syscall_stubs/gd_syscall_stub.S ;
}

# Internal
# GdSyscallGen $(< outputs) : $(> input) : $(3 hdr) : $(4 dispatcher) $(5 dir) ;
rule GdSyscallGen {
    ECHO $(<) from $(>) ;
    MakeLocate $(<) $(3) $(4) $(5) : $(LOCATE_TARGET) ;
    DEPENDS $(<) $(3) $(3:D=) $(4) $(5) : $(>) $(GD_STUB_GEN) ;
    DIR  on $(<) = [ FDirName $(LOCATE_TARGET) $(5) ] ;
    DISP on $(<) = [ FDirName $(LOCATE_TARGET) $(4) ] ;
    HDR  on $(<) = [ FDirName $(LOCATE_TARGET) $(3) ] ;
}

actions GdSyscallGen {
    $(GD_STUB_GEN) syscall $(>) -stubdir $(DIR) -stubs -hdr $(HDR) -dispatcher $(DISP)
}

################################################################################
# Extra rules and toolchain functionality

# Invoke objcopy
# ObjCopy dest : src : opts ;
rule ObjCopy {
    Depends $(<) : $(>) ;
    MakeLocate $(<) : $(LOCATE_TARGET) ;
    OPTS on $(<) = $(3) ;
}

actions ObjCopy {
    $(OBJCOPY) $(OPTS) $(>) $(<)
}

# Link using a linker script
# LinkWithScript output : objects : script [: extraflags] ;
rule LinkWithScript {
    # Can't use MainFromObjects as it regrists the files
    Depends $(<) : $(>) $(3) ;
    MakeLocate $(<) : $(LOCATE_TARGET) ;
    Clean clean : $(<) ;
    LINKFLAGS on $(<) += -T$(3) $(4) ;
}

# We also generate output useful for debugging
actions LinkWithScript bind NEEDLIBS {
    $(LINK) $(LINKFLAGS) -o $(<) $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS) --cref -Map $(<:S=.map.txt)
    $(OBJDUMP) -C -t $(<) > $(<:S=.syms.txt)
    $(OBJDUMP) -C -S $(<) > $(<:S=.sdsm.txt)
    $(OBJDUMP) -C -d $(<) > $(<:S=.dsm.txt)
    $(OBJCOPY) --only-keep-debug $(<) $(<:S=.gdb)
    $(STRIP) --strip-debug $(<)
    $(OBJCOPY) --add-gnu-debuglink=$(<:S=.gdb) $(<)
}

# Add support to Jam for .S preprocessed assembly files
# Doesn't recognize S: preprocessed assembly file
rule UserObject {
    switch $(>:S) {
        case .S :   AsCpp $(<) : $(>) ;
    }
}

# Add support for preprocessed assembly
rule AsCpp
{
    Depends $(<) : $(>) ;

    ASFLAGS on $(<) += $(ASFLAGS) $(SUBDIRASFLAGS) ;

    CCHDRS on $(<) = [ on $(<) FIncludes $(HDRS) ] ;
    CCDEFS on $(<) = [ on $(<) FDefines $(DEFINES) ] ;
}

# Pass them to GCC
actions AsCpp
{
    $(CC) -c $(ASFLAGS) $(CCHDRS) $(CCDEFS) -o $(<) $(>)
}

################################################################################
# Platform, SoC, architecture functionality

# Determine the platform, soc, arch information
# Do so in that order; platform can imply soc can imply arch

# XXX These paths may need consideration once we have KL!

GdIncludeDir $(ALL_LOCATE_TARGET) bal include ;
GdIncludeDir $(GD_TOP) include ;

if ! $(PLATFORM) {
    ECHO "Must specify a platform" ;
    EXIT ;
} else {
    include [ FDirName $(GD_TOP) bal platform $(PLATFORM) Config.jam ] ;
}

# SoC specification is optional (e.g: i386-bios doesnt' need nor want one)
if $(SOC) {
	include [ FDirName $(GD_TOP) bal soc $(SOC) Config.jam ] ;
}

if ! $(ARCH) {
    ECHO "Must specify an architecture " ;
    ECHO "Platform supports: " $(SUPPORTED_ARCHITECTURES:J=", ") ;
    EXIT ;
} else if ! $(ARCH) in $(SUPPORTED_ARCHITECTURES) {
    ECHO "Architecture \"$(ARCH)\" not supported by $(PLATFORM)" ;
    ECHO "Supported architectures are: " $(SUPPORTED_ARCHITECTURES:J=", ") ;
    EXIT ;
} else {
    include [ FDirName $(GD_TOP) bal arch $(ARCH) Config.jam ] ;
}

# All of our toolchains are GCC-alikes
TOOLSET = gcc ;
CCFLAGS  += -ffreestanding -fbuiltin -g ;
C++FLAGS += -ffreestanding -fbuiltin -g ;

AS         = $(TOOLPREFIX)gcc ;
AR         = $(TOOLPREFIX)ar cru ;
CC         = $(TOOLPREFIX)gcc ;
OPTIM      = -Os ;
C++        = $(TOOLPREFIX)g++ ;
LINK       = $(TOOLPREFIX)ld ;
STDHDRS    = ;
SUFEXE     = ;
SUFLIB     = .a ;
SUFOBJ     = .o ;
UNDEFFLAG  = -U ;
PICFLAGS   = -fPIC ;
OBJDUMP    = $(TOOLPREFIX)objdump ;
OBJCOPY    = $(TOOLPREFIX)objcopy ;
STRIP      = $(TOOLPREFIX)strip ;
RANLIB     = $(TOOLPREFIX)ranlib ;

# Find libgcc
LIBGCC = [ COMMAND $(CC) $(CCFLAGS) $(OPTIM) $(CCDEFS) -print-libgcc-file-name ] ;

################################################################################
# Include the Jamrules files for our dependencies
SubRules GD_TOP pdclib : PDCLIB_TOP ;


# JamBase invokes all rules specified in SUBDIRRULES when a new subdir is
# entered
#
# We deferred adding these till here else _AddHeaders gets invoked by the above
# before PDClibConfig is defined
SUBDIRRULES += _SubSetIncluded _AddHeaders ;

################################################################################
# Work around a bug in Jambase
# XXX This should go into ejam

# Fix to work on targets in subdirs
rule MakeLocate
{
    # Note we grist the directory name with 'dir',
    # so that directory path components and other
    # targets don't conflict.

    if $(>)
    {
        for file in $(<) {
            local _rev = [ FReverse $(>) ] ;
            if $(_rev[1]) = "." {
              _rev = $(_rev[2-]) ;
            }
            local _dir = [ FDirName [ FReverse $(_rev) ] $(file:D) ] ;

            LOCATE on $(file) = [ FDirName $(>) ] ;
            Depends $(<) : $(_dir:G=dir) ;
            MkDir $(_dir:G=dir) ;
        }
    }
}