The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/makedefs/MakeInc.dir

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 #
    2 # Install kernel header files
    3 #
    4 ifeq ($(RC_ProjectName),Libsyscall)
    5 installhdrs:
    6         bsdmake -C libsyscall installhdrs
    7 else # xnu
    8 installhdrs: exporthdrs installhdrs_mi installhdrs_md 
    9         @echo "[ $(SRCROOT) ] make installhdrs installing Kernel.framework"
   10         $(_v)kincpath=$(DSTROOT)/$(KINCDIR);                                    \
   11         krespath=$(DSTROOT)/$(KRESDIR);                                 \
   12         kframepath=$(DSTROOT)/$(KINCFRAME);                             \
   13         [ -d $$krespath ] || $(MKDIR) $$krespath;                       \
   14         [ -d $$kincpath ] || $(MKDIR) $$kincpath;                       \
   15         cd $(SRCROOT)/EXTERNAL_HEADERS;                                 \
   16                 install $(FILE_INSTALL_FLAGS) Info.plist $$krespath;    \
   17                 $(SRCROOT)/config/newvers.pl $${krespath}/Info.plist;   \
   18         cd $$kframepath/Versions;                                       \
   19             [ -L Current ] || $(LN) $(KINCVERS) Current;                \
   20         cd $$kframepath;                                                \
   21             [ -L Headers ] || $(LN) Versions/Current/Headers Headers;   \
   22             [ -L Resources ] || $(LN) Versions/Current/Resources Resources;     \
   23         [ -d $(DSTROOT)/$(KPINCDIR) ] || $(MKDIR) $(DSTROOT)/$(KPINCDIR);       \
   24         cd $$kframepath; [ -L PrivateHeaders ] ||                       \
   25             $(LN) Versions/Current/PrivateHeaders PrivateHeaders;
   26 endif
   27 
   28 #
   29 # Install header files order
   30 #
   31 .ORDER: installhdrs_mi installhdrs_md
   32 
   33 #
   34 # Install machine independent header files
   35 #
   36 installhdrs_mi:
   37         $(_v)rel_path=$(shell $(RELPATH) $(SRCROOT) $(SOURCE));                 \
   38         kernel_config=$(INSTALL_TYPE);                                  \
   39         arch_config=$(INSTALL_ARCH_DEFAULT);                                    \
   40         installinc_dir=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path};       \
   41         [ -d $${installinc_dir} ] ||$(MKDIR) $${installinc_dir};        \
   42         ${MAKE} -C $${installinc_dir}                                   \
   43                 KERNEL_CONFIG=$${kernel_config}                         \
   44                 ARCH_CONFIG=$${arch_config}                             \
   45                 MAKEFILES=${SOURCE}/Makefile                            \
   46                 SOURCE=${SOURCE}/                                       \
   47                 TARGET=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path}/       \
   48                 build_installhdrs_mi;                                   \
   49 
   50 #
   51 # Install machine dependent kernel header files 
   52 #
   53 installhdrs_md:
   54         $(_v)rel_path=$(shell $(RELPATH) $(SRCROOT) $(SOURCE));                 \
   55         kernel_config=$(INSTALL_TYPE);                                  \
   56         machine_config=$(MACHINE_CONFIG);               \
   57         for arch_config in $(INSTALL_ARCHS);                            \
   58         do                                                              \
   59         if [ $${arch_config} = ARM ] ; then     \
   60                 if [ $${machine_config} = DEFAULT ] ; then      \
   61                         machine_config=$(DEFAULT_ARM_MACHINE_CONFIG);           \
   62                 fi;             \
   63         fi;             \
   64         if [ $${machine_config} = DEFAULT ] ; then      \
   65                 objpath=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path};      \
   66         else            \
   67                 objpath=${OBJROOT}/$${kernel_config}_$${arch_config}_$${machine_config}/$${rel_path};   \
   68         fi;             \
   69         [ -d $${objpath} ] || $(MKDIR) $${objpath};     \
   70         ${MAKE} -C $${objpath}  \
   71                 KERNEL_CONFIG=$${kernel_config}                         \
   72                 ARCH_CONFIG=$${arch_config}                             \
   73                 MAKEFILES=${SOURCE}/Makefile                            \
   74                 SOURCE=${SOURCE}/                                       \
   75                 TARGET=$${objpath}/                     \
   76                 build_installhdrs_md;                                   \
   77         done;
   78 
   79 #
   80 # Install machine independent kernel header files 
   81 #
   82 do_installhdrs_mi:
   83 
   84 build_installhdrs_mi::
   85         @echo "[ $(SOURCE) ] make build_installhdrs_mi $(KERNEL_CONFIG) $(ARCH_CONFIG) $(TARGET)"
   86         $(_v)for installinc_subdir in $(INSTINC_SUBDIRS);                       \
   87         do                                                              \
   88                 [ -d $${installinc_subdir} ] || $(MKDIR) $${installinc_subdir};         \
   89                 ${MAKE} -C $${installinc_subdir}                        \
   90                         MAKEFILES=$(SOURCE)$${installinc_subdir}/Makefile       \
   91                         SOURCE=$(SOURCE)$${installinc_subdir}/          \
   92                         TARGET=$(TARGET)$${installinc_subdir}/          \
   93                 build_installhdrs_mi;                                   \
   94         done;                                                           \
   95         ${MAKE} ${MAKEJOBS} do_installhdrs_mi;
   96 
   97 #
   98 # Install machine dependent kernel header files 
   99 #
  100 do_installhdrs_md:
  101 
  102 build_installhdrs_md::
  103         @echo "[ $(SOURCE) ] make installhdrs_md $(KERNEL_CONFIG) $(ARCH_CONFIG) $(TARGET)"
  104         $(_v)for installinc_subdir in $($(addprefix INSTINC_SUBDIRS_, $(ARCH_CONFIG)));         \
  105         do                                                              \
  106                 [ -d $${installinc_subdir} ] || $(MKDIR) $${installinc_subdir};                 \
  107                 ${MAKE} -C $${installinc_subdir}                        \
  108                         MAKEFILES=$(SOURCE)$${installinc_subdir}/Makefile       \
  109                         SOURCE=$(SOURCE)$${installinc_subdir}/          \
  110                         TARGET=$(TARGET)$${installinc_subdir}/          \
  111                 build_installhdrs_md;                                   \
  112         done;                                                           \
  113         ${MAKE} ${MAKEJOBS} do_installhdrs_md;
  114 
  115 #
  116 # Install kernel header files
  117 #
  118 exporthdrs: exporthdrs_mi exporthdrs_md 
  119 
  120 #
  121 # Install header files order
  122 #
  123 .ORDER: exporthdrs_mi exporthdrs_md
  124 
  125 #
  126 # Install machine independent header files
  127 #
  128 do_exporthdrs_mi:
  129 
  130 exporthdrs_mi:
  131         $(_v)rel_path=$(shell $(RELPATH) $(SRCROOT) $(SOURCE));                 \
  132         kernel_config=$(INSTALL_TYPE);                                  \
  133         arch_config=$(INSTALL_ARCH_DEFAULT);                                    \
  134         exportinc_dir=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path};        \
  135         [ -d $${exportinc_dir} ] || $(MKDIR) $${exportinc_dir};                                 \
  136         ${MAKE} -C $${exportinc_dir}                                    \
  137                 KERNEL_CONFIG=$${kernel_config}                         \
  138                 ARCH_CONFIG=$${arch_config}                             \
  139                 MAKEFILES=${SOURCE}/Makefile                            \
  140                 SOURCE=${SOURCE}/                                       \
  141                 TARGET=$${exportinc_dir}/                               \
  142                 build_exporthdrs_mi;                                    \
  143 
  144 #
  145 # Install machine dependent kernel header files 
  146 #
  147 # Note - installation of machine dependent kernel header files only occurs for architecture
  148 # defined in INSTALL_TYPE.  We use skipit variable to skip over architectures that are not
  149 # equal to what is in the INSTALL_TYPE variable.
  150 # TARGET_CONFIGS_UC variable holds sets of three configuration options.  The first item in the
  151 # set is the kernel configuration.  The second item in the set is the architecture and the 
  152 # third item is the machine configuration.  There may be multiple sets to build.
  153 exporthdrs_md:
  154         $(_v)rel_path=$(shell $(RELPATH) $(SRCROOT) $(SOURCE));                 \
  155         my_counter=1;           \
  156         for my_config in $(TARGET_CONFIGS_UC);                          \
  157         do              \
  158         if [ $${my_counter} -eq 1 ] ; then      \
  159                 skipit=0;                       \
  160                 my_counter=2;           \
  161                 kernel_config=$${my_config};            \
  162                 if [ $${kernel_config} = DEFAULT ] ; then       \
  163                         kernel_config=$(DEFAULT_KERNEL_CONFIG);         \
  164                 fi;             \
  165                 if [ $${kernel_config} != $(INSTALL_TYPE) ] ; then      \
  166                         skipit=1;       \
  167                 fi;             \
  168         elif [ $${my_counter} -eq 2 ] ; then    \
  169                 my_counter=3;           \
  170                 arch_config=$${my_config};              \
  171                 if [ $${arch_config} = DEFAULT ] ; then \
  172                         arch_config=`arch | $(TR) a-z A-Z`;             \
  173                 fi;             \
  174         else            \
  175                 my_counter=1;           \
  176                 machine_config=$${my_config};           \
  177                 if [ $${skipit} -eq 0 ] ; then  \
  178                         if [ $${arch_config} = ARM ] ; then     \
  179                                 if [ $${machine_config} = DEFAULT ] ; then      \
  180                                         machine_config=$(DEFAULT_ARM_MACHINE_CONFIG);           \
  181                                 fi;             \
  182                         fi;             \
  183                         if [ $${machine_config} = DEFAULT ] ; then      \
  184                                 exportinc_dir=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path};        \
  185                         else            \
  186                                 exportinc_dir=${OBJROOT}/$${kernel_config}_$${arch_config}_$${machine_config}/$${rel_path};     \
  187                         fi;             \
  188                         [ -d $${exportinc_dir} ] || $(MKDIR) $${exportinc_dir};                                 \
  189                         ${MAKE} -C $${exportinc_dir}                                    \
  190                                 KERNEL_CONFIG=$${kernel_config}                         \
  191                                 ARCH_CONFIG=$${arch_config}                             \
  192                                 MAKEFILES=${SOURCE}/Makefile                            \
  193                                 SOURCE=${SOURCE}/                                       \
  194                                 TARGET=$${exportinc_dir}/                               \
  195                                 build_exporthdrs_md;                                    \
  196                 fi;             \
  197         fi;             \
  198         done;
  199 
  200 #
  201 # Install machine independent kernel header files 
  202 #
  203 do_exporthdrs_mi:
  204 
  205 build_exporthdrs_mi:
  206         $(_v)_TMP_EXPINC_SUBDIRS="$(EXPINC_SUBDIRS)";                   \
  207         for exportinc_subdir in $${_TMP_EXPINC_SUBDIRS};                \
  208         do                                                              \
  209                 [ -d $${exportinc_subdir} ] || $(MKDIR) $${exportinc_subdir};                           \
  210                 ${MAKE} -C $${exportinc_subdir}                         \
  211                         MAKEFILES=$(SOURCE)$${exportinc_subdir}/Makefile        \
  212                         SOURCE=$(SOURCE)$${exportinc_subdir}/           \
  213                         TARGET=$(TARGET)$${exportinc_subdir}/           \
  214                 build_exporthdrs_mi;                                    \
  215         done;                                                           \
  216         ${MAKE} ${MAKEJOBS} do_exporthdrs_mi;
  217 
  218 #
  219 # Install machine dependent kernel header files 
  220 #
  221 do_exporthdrs_md:
  222 
  223 build_exporthdrs_md:
  224         $(_v)_TMP_exportinc_subdir="$($(addprefix EXPINC_SUBDIRS_, $(ARCH_CONFIG)))";   \
  225         for exportinc_subdir in $${_TMP_exportinc_subdir};                      \
  226         do                                                              \
  227                 [ -d $${exportinc_subdir} ] || $(MKDIR) $${exportinc_subdir};                           \
  228                 ${MAKE} -C $${exportinc_subdir}                         \
  229                         MAKEFILES=$(SOURCE)$${exportinc_subdir}/Makefile        \
  230                         SOURCE=$(SOURCE)$${exportinc_subdir}/           \
  231                         TARGET=$(TARGET)$${exportinc_subdir}/           \
  232                 build_exporthdrs_md;                                    \
  233         done;                                                           \
  234         ${MAKE} ${MAKEJOBS} do_exporthdrs_md;
  235 
  236 #
  237 # Setup pass for  all architectures for all Configuration/Architecture options
  238 #
  239 setup:
  240         $(_v)rel_path=$(shell $(RELPATH) $(SRCROOT) $(SOURCE));                 \
  241         for kernel_config in $(KERNEL_CONFIGS);                         \
  242         do                                                              \
  243         for arch_config in $(ARCH_CONFIGS);                             \
  244         do                                                              \
  245         setup_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path}; \
  246         [ -d $${setup_subdir} ] || $(MKDIR) $${setup_subdir};                                   \
  247         ${MAKE} -C $${setup_subdir}                                     \
  248                 KERNEL_CONFIG=$${kernel_config}                         \
  249                 ARCH_CONFIG=$${arch_config}                             \
  250                 MAKEFILES=${SOURCE}/Makefile                            \
  251                 SOURCE=${SOURCE}/                                       \
  252                 TARGET=$${setup_subdir}/                                \
  253         build_setup;                                                    \
  254         done;                                                           \
  255         done;
  256 
  257 do_build_setup:
  258 
  259 build_setup:
  260         $(_v)_TMP_setup_subdir="$(SETUP_SUBDIRS) $($(addprefix SETUP_SUBDIRS_, $(ARCH_CONFIG)))";       \
  261         for setup_subdir in $${_TMP_setup_subdir};              \
  262         do                                                      \
  263         [ -d $${setup_subdir} ] || $(MKDIR) $${setup_subdir};                           \
  264         ${MAKE} -C $${setup_subdir}                             \
  265                 MAKEFILES=${SOURCE}/$${setup_subdir}/Makefile   \
  266                 SOURCE=${SOURCE}/$${setup_subdir}/              \
  267                 TARGET=${TARGET}/$${setup_subdir}/              \
  268                 build_setup;                                    \
  269         done;                                                   \
  270         ${MAKE} do_build_setup;
  271 
  272 
  273 #
  274 # Build all architectures for all Configuration/Architecture options
  275 #
  276 # Note - TARGET_CONFIGS_UC variable holds sets of three configuration options.  The first 
  277 # item in the set is the kernel configuration.  The second item in the set is the architecture  
  278 # and the third item is the machine configuration.  There may be multiple sets to build.
  279 #
  280 ifeq ($(RC_ProjectName),Libsyscall)
  281 all:
  282         bsdmake -C libsyscall install
  283 else # xnu
  284 ifeq ($(COMPONENT), .)
  285 all: exporthdrs
  286 else
  287 all:
  288 endif
  289         $(_v)my_counter=1;              \
  290         for my_config in $(TARGET_CONFIGS_UC);                          \
  291         do              \
  292         if [ $${my_counter} -eq 1 ] ; then      \
  293                 my_counter=2;           \
  294                 kernel_config=$${my_config};            \
  295                 if [ $${kernel_config} = DEFAULT ] ; then       \
  296                         kernel_config=$(DEFAULT_KERNEL_CONFIG);         \
  297                 fi;             \
  298         elif [ $${my_counter} -eq 2 ] ; then    \
  299                 my_counter=3;           \
  300                 arch_config=$${my_config};              \
  301                 if [ $${arch_config} = DEFAULT ] ; then \
  302                         arch_config=`arch | $(TR) a-z A-Z`;             \
  303                 fi;             \
  304         else            \
  305                 my_counter=1;           \
  306                 machine_config=$${my_config};           \
  307                 if [ $${arch_config} = ARM ] ; then     \
  308                         if [ $${machine_config} = DEFAULT ] ; then      \
  309                                 machine_config=$(DEFAULT_ARM_MACHINE_CONFIG);           \
  310                         fi;             \
  311                 fi;             \
  312                 if [ $${machine_config} = DEFAULT ] ; then      \
  313                         build_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path}; \
  314                 else            \
  315                         build_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}_$${machine_config}/$${rel_path}; \
  316                 fi;             \
  317                 [ -d $${build_subdir} ] || $(MKDIR) $${build_subdir};                                   \
  318                         ${MAKE} -C $${build_subdir}                                     \
  319                                 KERNEL_CONFIG=$${kernel_config}                         \
  320                                 ARCH_CONFIG=$${arch_config}                     \
  321                                 MACHINE_CONFIG=$${machine_config}                       \
  322                                 MAKEFILES=${SOURCE}/Makefile                            \
  323                                 SOURCE=${SOURCE}/                                       \
  324                                 build_all;                                              \
  325         fi;             \
  326         done;
  327 endif
  328 
  329 #
  330 # Build all architectures for all Configuration/Architecture options
  331 #
  332 do_build_all:
  333 
  334 build_all: 
  335         $(_v)if [ $(MACHINE_CONFIG) = DEFAULT ] ; then  \
  336                 TARGET=$(OBJROOT)/$(KERNEL_CONFIG)_$(ARCH_CONFIG)/$(COMPONENT); \
  337         else            \
  338                 TARGET="$(OBJROOT)/$(KERNEL_CONFIG)_$(ARCH_CONFIG)_$(MACHINE_CONFIG)/$(COMPONENT)";     \
  339         fi;             \
  340         _TMP_comp_subdir="$(COMP_SUBDIRS) $($(addprefix COMP_SUBDIRS_, $(ARCH_CONFIG)))";       \
  341         for comp_subdir in $${_TMP_comp_subdir};                        \
  342         do                                                              \
  343                 [ -d $${comp_subdir} ] || $(MKDIR) $${comp_subdir};                             \
  344                 ${MAKE} -C $${comp_subdir}                              \
  345                         MAKEFILES=${SOURCE}/$${comp_subdir}/Makefile    \
  346                         SOURCE=${SOURCE}$${comp_subdir}/                \
  347                         TARGET=$${TARGET}                               \
  348                 build_all;                                              \
  349         done;                                                           \
  350         ${MAKE} ${MAKEJOBS} INCL_MAKEDEP=TRUE TARGET=$${TARGET} do_build_all;   \
  351         _TMP_comp_subdir="$(CONFIG_SUBDIRS) $($(addprefix CONFIG_SUBDIRS_, $(ARCH_CONFIG)))";   \
  352         for comp_subdir in $${_TMP_comp_subdir};                        \
  353         do                                                              \
  354                 [ -d $${comp_subdir} ] || $(MKDIR) $${comp_subdir};                             \
  355                 ${MAKE} -C $${comp_subdir}                              \
  356                         MAKEFILES=${SOURCE}/$${comp_subdir}/Makefile    \
  357                         SOURCE=${SOURCE}$${comp_subdir}/                \
  358                         TARGET=$${TARGET}                               \
  359                 build_all;                                              \
  360         done;                                                           
  361         
  362 
  363 #
  364 # Build all architectures for all Configuration/Architecture options
  365 #
  366 # Note - TARGET_CONFIGS_UC variable holds sets of three configuration options.  The first 
  367 # item in the set is the kernel configuration.  The second item is the architecture  
  368 # and the third item is the machine configuration.  There may be multiple sets to build.
  369 #
  370 mach_kernel:
  371         $(_v)my_counter=1;              \
  372         for my_config in $(TARGET_CONFIGS_UC);                          \
  373         do              \
  374         if [ $${my_counter} -eq 1 ] ; then      \
  375                 my_counter=2;           \
  376                 kernel_config=$${my_config};            \
  377                 if [ $${kernel_config} = DEFAULT ] ; then       \
  378                         kernel_config=$(DEFAULT_KERNEL_CONFIG);         \
  379                 fi;             \
  380         elif [ $${my_counter} -eq 2 ] ; then    \
  381                 my_counter=3;           \
  382                 arch_config=$${my_config};              \
  383                 if [ $${arch_config} = DEFAULT ] ; then \
  384                         arch_config=`arch | $(TR) a-z A-Z`;             \
  385                 fi;             \
  386         else            \
  387                 my_counter=1;           \
  388                 machine_config=$${my_config};           \
  389                 if [ $${arch_config} = ARM ] ; then     \
  390                         if [ $${machine_config} = DEFAULT ] ; then      \
  391                                 machine_config=$(DEFAULT_ARM_MACHINE_CONFIG);           \
  392                         fi;             \
  393                 fi;             \
  394                 if [ $${machine_config} = DEFAULT ] ; then      \
  395                         build_subdir=${OBJROOT}/$${kernel_config}_$${arch_config};      \
  396                 else            \
  397                         build_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}_$${machine_config};   \
  398                 fi;             \
  399                 [ -d $${build_subdir} ] || $(MKDIR) $${build_subdir};                                   \
  400                 ${MAKE} -C $${build_subdir}                                     \
  401                         KERNEL_CONFIG=$${kernel_config}                         \
  402                         ARCH_CONFIG=$${arch_config}                             \
  403                         MACHINE_CONFIG=$${machine_config}                       \
  404                         MAKEFILES=${SOURCE}/Makefile                            \
  405                         SOURCE=${SOURCE}/                                       \
  406                         TARGET=$${build_subdir}/                                \
  407                         build_mach_kernel;                                      \
  408         fi;             \
  409         done;
  410 
  411 #
  412 # Build all architectures for all Configuration/Architecture options
  413 #
  414 do_build_mach_kernel:
  415 
  416 build_mach_kernel: 
  417         $(_v)${MAKE} ${MAKEJOBS} do_build_mach_kernel;
  418 
  419 
  420 #
  421 #
  422 # Install dependencies order
  423 #
  424 .ORDER: installhdrs exporthdrs all
  425 
  426 #
  427 # Install kernel based on RC_ARCHS for all INSTALL_TYPES
  428 # Install kernel header files based on RC_ARCHS
  429 #
  430 install: installhdrs all installman installmachinekernels
  431 ifeq ($(RC_ProjectName),Libsyscall)
  432 # nothing to do
  433 else # xnu
  434         $(_v)rel_path=$(shell $(RELPATH) $(SRCROOT) $(SOURCE));                 \
  435         machine_config=$(MACHINE_CONFIG);               \
  436         for kernel_config in $(INSTALL_TYPE);                           \
  437         do                                                              \
  438         for arch_config in $(INSTALL_ARCHS);                            \
  439         do                                                              \
  440         if [ $${arch_config} = ARM ] ; then     \
  441                 if [ $${machine_config} = DEFAULT ] ; then      \
  442                         machine_config=$(DEFAULT_ARM_MACHINE_CONFIG);           \
  443                 fi;             \
  444         fi;             \
  445         if [ $${machine_config} = DEFAULT ] ; then      \
  446                 install_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}/$${rel_path};       \
  447         else            \
  448                 install_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}_$${machine_config}/$${rel_path};    \
  449         fi;             \
  450         [ -d $${install_subdir} ] || $(MKDIR) $${install_subdir};                                       \
  451         ${MAKE} -C $${install_subdir}                                   \
  452                 KERNEL_CONFIG=$${kernel_config}                         \
  453                 ARCH_CONFIG=$${arch_config}                             \
  454                 MACHINE_CONFIG=$${machine_config}                       \
  455                 MAKEFILES=${SOURCE}/Makefile                            \
  456                 SOURCE=${SOURCE}/                                       \
  457                 build_install;                                          \
  458         done;                                                           \
  459         done;
  460 endif
  461 
  462 installmachinekernels:
  463         @echo "[ $(SOURCE) ] make installmachinekernels";                               \
  464         my_counter=1;           \
  465         for my_config in $(TARGET_CONFIGS_UC);                          \
  466         do              \
  467         if [ $${my_counter} -eq 1 ] ; then      \
  468                 my_counter=2;           \
  469                 kernel_config=$${my_config};            \
  470                 if [ $${kernel_config} = DEFAULT ] ; then       \
  471                         kernel_config=$(DEFAULT_KERNEL_CONFIG);         \
  472                 fi;             \
  473         elif [ $${my_counter} -eq 2 ] ; then    \
  474                 my_counter=3;           \
  475                 arch_config=$${my_config};              \
  476                 if [ $${arch_config} = DEFAULT ] ; then \
  477                         arch_config=`arch | $(TR) a-z A-Z`;             \
  478                 fi;             \
  479         else            \
  480                 my_counter=1;           \
  481                 machine_config=$${my_config};           \
  482                 if [ $${machine_config} != DEFAULT ] ; then     \
  483                         build_subdir=${OBJROOT}/$${kernel_config}_$${arch_config}_$${machine_config};   \
  484                         install_file_list=mach.`printf "%s" "$${kernel_config}" | $(TR) A-Z a-z`.`printf "%s" "$${machine_config}" | $(TR) A-Z a-z`;    \
  485                         [ -d $${build_subdir} ] || $(MKDIR) $${build_subdir};                                   \
  486                         ${MAKE} -C $${build_subdir}                                     \
  487                                 INSTALL_FILE_LIST=$${install_file_list}                 \
  488                                 KERNEL_CONFIG=$${kernel_config}                         \
  489                                 ARCH_CONFIG=$${arch_config}                             \
  490                                 MACHINE_CONFIG=$${machine_config}                       \
  491                                 MAKEFILES=${SOURCE}/Makefile                            \
  492                                 SOURCE=${SOURCE}/                                       \
  493                                 TARGET=$${build_subdir}/                                \
  494                                 do_build_install;                                       \
  495                 fi;             \
  496         fi;             \
  497         done;
  498 
  499 #
  500 # Install for all architectures for all Configuration/Architecture options
  501 #
  502 setup_build_install:
  503 
  504 do_build_install:
  505 
  506 build_install: 
  507         $(_v)if [ $(MACHINE_CONFIG) = DEFAULT ] ; then  \
  508                 TARGET=${OBJROOT}/$(KERNEL_CONFIG)_$(ARCH_CONFIG)/$(COMPONENT); \
  509         else            \
  510                 TARGET="$(OBJROOT)/$(KERNEL_CONFIG)_$(ARCH_CONFIG)_$(MACHINE_CONFIG)/$(COMPONENT)";     \
  511         fi;             \
  512         ${MAKE} TARGET=$${TARGET} setup_build_install;                  \
  513         kernel_config=$(KERNEL_CONFIG);                                 \
  514         for install_subdir in $(INST_SUBDIRS);                          \
  515         do                                                              \
  516                 [ -d $${install_subdir} ] || $(MKDIR) $${install_subdir};                               \
  517                 ${MAKE} -C $${install_subdir}                           \
  518                         KERNEL_CONFIG=$${kernel_config}                 \
  519                         MAKEFILES=${SOURCE}/$${install_subdir}/Makefile \
  520                         SOURCE=${SOURCE}$${install_subdir}/             \
  521                         TARGET=$${TARGET}                               \
  522                 build_install;                                          \
  523         done;                                                           \
  524         ${MAKE} ${MAKEJOBS} TARGET=$${TARGET} do_build_install;
  525 
  526 
  527 #
  528 # Install source tree
  529 #
  530 installsrc:
  531         $(_v)(tar -c --mode go=r,+X --no-ignore-case --exclude .svn --exclude cscope.\* --exclude BUILD --exclude \*~ -f - .) | (cd $(SRCROOT) && tar --no-same-owner -xf -)
  532 
  533 
  534 #
  535 # Clean up source tree
  536 #
  537 clean:
  538 
  539 #
  540 # Build source file list for cscope database and tags
  541 #
  542 cscope.files:
  543         @echo "Building file list for cscope and tags"
  544         @find . -name '*.h' -type f | grep -v ^..BUILD > _cscope.files 2> /dev/null
  545         @find . -name '*.defs' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
  546         @find . -name '*.c' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
  547         @find . -name '*.cpp' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
  548         @find . -name '*.s' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
  549         @find . -name '*.h.template' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
  550         @echo -k -q -c > cscope.files 2> /dev/null
  551         @sort -u < _cscope.files >> cscope.files 2> /dev/null
  552         @rm -f _cscope.files _cscope.files2 2> /dev/null
  553 
  554 #
  555 # Build cscope database
  556 #
  557 cscope: cscope.files
  558         @echo "Building cscope database"
  559         @cscope -bvU 2> /dev/null
  560 
  561 #
  562 # Build tags
  563 #
  564 
  565 tags: cscope.files
  566         @echo "Building ctags"
  567         @-sed 1d cscope.files | xargs ctags -dtw 2> /dev/null || \
  568                 echo "Phantom files detected!" 2>&1 > /dev/null
  569         @-[ -f TAGS ] || ${MAKE} TAGS
  570 
  571 TAGS: cscope.files
  572         @echo "Building etags"
  573         @-cat cscope.files | etags -l auto -S - 2> /dev/null
  574 
  575 #
  576 # Install Man Pages
  577 #
  578 installman:
  579 ifeq ($(RC_ProjectName),Libsyscall)
  580         bsdmake -C libsyscall install-man
  581 else # xnu
  582         @echo "[ $(SRCROOT) ] Installing man pages"
  583         $(_v)manpath=$(DSTROOT)/$(MANDIR);   \
  584         [ -d $$manpath ] || $(MKDIR) $$manpath;             \
  585         ${MAKE} MAKEFILES=${SOURCE}/Makefile \
  586                 SOURCE=${SOURCE}/ \
  587                 TARGET=${DSTROOT}/ \
  588                 build_installman
  589         ${SOURCE}/config/compress-man-pages.pl ${DSTROOT}/${MANDIR}
  590 endif
  591 
  592 do_installman:
  593 
  594 build_installman:
  595         @echo "[ $(SOURCE) ] make build_installman"
  596         $(_v)if [ -n "$(strip $(INSTMAN_SUBDIRS))" ]; then \
  597                 for installman_subdir in $(INSTMAN_SUBDIRS); do \
  598                         ${MAKE} -C $${installman_subdir} -r \
  599                                 MAKEFILES=$(SOURCE)$${installman_subdir}/Makefile \
  600                                 SOURCE=$(SOURCE)$${installman_subdir}/ \
  601                                 TARGET=$(TARGET)$${installman_subdir}/ \
  602                                 build_installman; \
  603                 done; \
  604         fi; \
  605         if [ -n "$(strip $(INSTALL_MAN_LIST))" ]; then \
  606                 ${MAKE} ${MAKEJOBS} do_installman; \
  607         fi
  608 
  609 # vim: set ft=make:

Cache object: 6cdeaa7231a47864286b11d549a3c26c


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.