linker fairly usable

Makefile

@@ -27,18 +27,25 @@ SRCDIR := src
 # Add inputs and outputs from these tool invocations to the build variables
 C_SRCS += $(wildcard $(SRCDIR)/*.c)
 
-TARGETDIR_BR := $(TARGETDIR)/br.o
-OBJS_BR   += $(patsubst $(SRCDIR)/%.c,$(TARGETDIR_BR)/%.o,$(C_SRCS))
-C_DEPS_BR :=
-C_DEPS_BR += $(wildcard $(TARGETDIR_BR)/*.d)
+OBJS_CR   :=
 TARGETDIR_CR := $(TARGETDIR)/cr.o
 OBJS_CR   += $(patsubst $(SRCDIR)/%.c,$(TARGETDIR_CR)/%.o,$(C_SRCS))
 C_DEPS_CR :=
 C_DEPS_CR += $(wildcard $(TARGETDIR_CR)/*.d)
+
+OBJS_LR   :=
 TARGETDIR_LR := $(TARGETDIR)/lr.o
 OBJS_LR   += $(patsubst $(SRCDIR)/%.c,$(TARGETDIR_LR)/%.o,$(C_SRCS))
 C_DEPS_LR :=
 C_DEPS_LR += $(wildcard $(TARGETDIR_LR)/*.d)
+
+OBJS_BR   :=
+TARGETDIR_BR := $(TARGETDIR)/br.o
+OBJS_BR   += $(patsubst $(SRCDIR)/%.c,$(TARGETDIR_BR)/%.o,$(C_SRCS))
+C_DEPS_BR :=
+C_DEPS_BR += $(wildcard $(TARGETDIR_BR)/*.d)
+
+OBJS_LIB   :=
 TARGETDIR_LIB := $(TARGETDIR)/lib.o
 OBJS_LIB   += $(patsubst $(SRCDIR)/%.c,$(TARGETDIR_LIB)/%.o,$(C_SRCS))
 C_DEPS_LIB :=
@@ -64,23 +71,32 @@ $(TARGETDIR_LIB)/%.o: $(SRCDIR)/%.c
 
 # Add inputs and outputs from these tool invocations to the build variables
 # All Target
-all: oclh_compiler oclh_builder
+all: oclh_compiler oclh_linker oclh_builder
 # Tool invocations
-oclh_builder: DEFS= -D__OCLH_BUILDER_FLAG -D__OCLH_BUILD_LOG_TO_STDOUT_FLAG
-oclh_builder: OUTPUTNAME=$(OCLH_BUILDER_NAME)
-oclh_builder: $(OBJS_BR)
+oclh_compiler: DEFS := -D__OCLH_COMPILER_ONLY_FLAG -D__OCLH_BUILD_LOG_TO_STDOUT_FLAG
+oclh_compiler: OUTPUTNAME=$(OCLH_COMPILER_NAME)
+oclh_compiler: $(OBJS_CR)
 	@echo 'Building target: $@'
 	@echo 'Invoking C Linker'
-	$(LINKER) $(LDFLAGS) $(MISCFLAGS) $(LIBS) $(OBJS_BR) \
+	$(LINKER) $(LDFLAGS) $(MISCFLAGS) $(LIBS) $(OBJS_CR) \
 	-o "$(TARGETDIR)/$(OUTPUTNAME)"
 	@echo 'Finished building target: $@'
 	@echo ' '
-oclh_compiler: DEFS= -D__OCLH_COMPILER_ONLY_FLAG -D__OCLH_BUILD_LOG_TO_STDOUT_FLAG
-oclh_compiler: OUTPUTNAME=$(OCLH_COMPILER_NAME)
-oclh_compiler: $(OBJS_CR)
+oclh_linker: DEFS := -D__OCLH_LINKER_ONLY_FLAG -D__OCLH_BUILD_LOG_TO_STDOUT_FLAG
+oclh_linker: OUTPUTNAME=$(OCLH_LINKER_NAME)
+oclh_linker: $(OBJS_LR)
 	@echo 'Building target: $@'
 	@echo 'Invoking C Linker'
-	$(LINKER) $(LDFLAGS) $(MISCFLAGS) $(LIBS) $(OBJS_CR) \
+	$(LINKER) $(LDFLAGS) $(MISCFLAGS) $(LIBS) $(OBJS_LR) \
+	-o "$(TARGETDIR)/$(OUTPUTNAME)"
+	@echo 'Finished building target: $@'
+	@echo ' '
+oclh_builder: DEFS := -D__OCLH_BUILDER_FLAG -D__OCLH_BUILD_LOG_TO_STDOUT_FLAG
+oclh_builder: OUTPUTNAME=$(OCLH_BUILDER_NAME)
+oclh_builder: $(OBJS_BR)
+	@echo 'Building target: $@'
+	@echo 'Invoking C Linker'
+	$(LINKER) $(LDFLAGS) $(MISCFLAGS) $(LIBS) $(OBJS_BR) \
 	-o "$(TARGETDIR)/$(OUTPUTNAME)"
 	@echo 'Finished building target: $@'
 	@echo ' '

src/include_h/oclh_h_clapi_callbacks.h

@@ -11,5 +11,6 @@ void CL_CALLBACK _ghf_CtxEvent(const char*  pcErrInfo,
                                const void*  pvPrivInfo,
                                      size_t szPrivInfo,
                                      void*  pvUserData);
+void CL_CALLBACK _ghf_LinkEvent(cl_program Program, void*  pvUserData);
 
 #endif /* OCLH_H_CLAPI_CALLBACKS_H_ */

src/include_h/oclh_h_externals.h

@@ -18,9 +18,10 @@ cl_mem  _ghf_wdcAllocDevBuf( _GHT_WRKSET  wSet,
 void    _ghf_freeDevZ(_GHT_WRKSET wSet, cl_mem* const pCLMem);
 int32_t _ghf_addCharPtrToCharPtrList(      char*** const pppcLst,
                                      const char*   const pcStr);
-int32_t _ghf_addFileToCharPtrList(      char*** const pppcLst,
-                                  const char*   const pcFileName,
-                                  const uint64_t      u64Align);
-void    _ghf_wipeCharPtrList(char*** const pppcLst);
+int32_t _ghf_addFileToCharPtrListWithSizes(      char*** const pppcLst,
+                                           const char*   const pcFileName,
+                                           const uint64_t      u64Align);
+void    _ghf_wipeCharPtrList(         char*** const pppcLst);
+void    _ghf_wipeCharPtrListWithSizes(char*** const pppcLst);
 
 #endif /* OCLH_H_EXTERNALS_H_ */

src/include_h/oclh_h_ws_base.h

@@ -25,6 +25,11 @@ typedef enum _GHE_BUILD_LOG_MODE {
     _GHE_BUILD_LOG_IN_SEPARATED_FILES = 2
 } _GHE_BUILD_LOG_MODE;
 
+typedef enum _GHE_OUTPUT_NAME_TYPE {
+    _GHE_VOLATILE_OUTPUT_NAME = 0,
+    _GHE_VERBATIM_OUTPUT_NAME = 1
+} _GHE_OUTNAME_TYPE;
+
 #pragma pack(push,1)
 typedef struct _GHT_WORKINGSET {
     void*            pwSetAddr;    /* self */
@@ -56,7 +61,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET*  const pwSet,
                     const _GHT_LOG            Log,
                     const int32_t             i32ExclusiveLogFlag,
                     const cl_device_id        clWrkDev,
-                    const void*         const pvCLProgramSources,
+                    const char**        const ppcCLProgramSources,
                     const _GHE_SRCTYPE        SourceType,
                     const char*         const pcOCLBuildOpts,
                     const _GHE_LOGLVL         LogLvl,
@@ -84,7 +89,8 @@ cl_uint         _ghf_getWS_RefCntOfMem(_GHT_WRKSET wSet,const cl_mem clMem);
 size_t          _ghf_getWS_MaxWIinWG(  _GHT_WRKSET wSet);
 cl_uint         _ghf_getWS_MaxCmpUnits(_GHT_WRKSET wSet);
 int32_t         _ghf_saveWS_ProgramBinaries(_GHT_WRKSET wSet,
-                                            char* const pcOutputPrefix);
+                                            char* const pcOutputName,
+                                            _GHE_OUTNAME_TYPE OutNameType);
 int32_t         _ghf_wdcChkWS_APIErr (  _GHT_WRKSET wSet,
                                   const char* const pcAPICall,
                                   const int32_t i32FlashFlag);
@@ -121,20 +127,20 @@ typedef struct _GHT_ALL_OF_WORKING_SETS {
 #pragma pack(pop)
 _GHT_AWSS _ghf_declAWSs(const _GHE_LOGLVL  LogLvl,
                         const _GHE_BUILD_LOG_MODE BuildLogMode);
-int32_t _ghf_genrAWSs(      _GHT_AWSS*  const pAWSs,
-                      const _GHT_LOG          Log,
-                      const _GHT_DEVLIST_DESC DevLstDesc,
-                      const void*       const pvCLProgramSources,
-                      const _GHE_SRCTYPE      SourceType,
-                      const char*       const OCLBuildOpts
+int32_t _ghf_genrAWSs(      _GHT_AWSS*   const pAWSs,
+                      const _GHT_LOG           Log,
+                      const _GHT_DEVLIST_DESC  DevLstDesc,
+                      const char**       const ppcCLProgramSources,
+                      const _GHE_SRCTYPE       SourceType,
+                      const char*        const OCLBuildOpts
 #if defined(__OCLH_BUILDER_FLAG) || \
     defined(__OCLH_COMPILER_ONLY_FLAG) || \
     defined(__OCLH_LINKER_ONLY_FLAG)
-                    ,       char*       const pcOutputPrefix
+                    ,       char*        const pcOutputPrefix
 #endif /* defined(__OCLH_BUILDER_FLAG) ||
           defined(__OCLH_COMPILER_ONLY_FLAG) ||
           defined(__OCLH_LINKER_ONLY_FLAG) */
-                                                           );
+                                                      );
 int32_t _ghf_wipeAWSs(_GHT_AWSS* const pAWSs);
 
 int32_t _ghf_buildDevList(_GHT_WRKSET wSet, cl_device_id** ppDevLst);

src/oclh_cc.c

@@ -17,13 +17,15 @@ int32_t main(int32_t argc, char *argv[]) {
     _GHT_AWSS AWSs=_ghf_declAWSs(_GHE_LOG_ALL,
                                  _GHE_BUILD_LOG_IN_SEPARATED_FILES);
     _GHT_DEVLIST_DESC DevLstDesc=_ghf_declDevLstDesc();
+    _GHE_OUTNAME_TYPE OutNameType=_GHE_VOLATILE_OUTPUT_NAME;
     {
         uint64_t i=1ul;
         for(i=1ul; i<(uint64_t)argc; i++) {
             if(argv[i][0]=='-') { /* key-value */
                 if(argv[i][1]=='o' ||
                    !strncmp(argv[i],"--dev-idxs=",11ul) ||
-                   !strncmp(argv[i],"--dev-name=",11ul)) {
+                   !strncmp(argv[i],"--dev-name=",11ul) ||
+                   !strncmp(argv[i],"--verbatim-output-name",22ul)   ) {
                     if(argv[i][1]=='o') { /* output prefix */
                         if(!argv[i][2]) { pcOutputPrefix=argv[++i]; }
                         else { pcOutputPrefix=argv[i]+2ul; }
@@ -51,6 +53,8 @@ int32_t main(int32_t argc, char *argv[]) {
                                                               argv[++i]);
                         }
                     }
+                    if(!strncmp(argv[i],"--verbatim-output-name",22ul))
+                        OutNameType=_GHE_VERBATIM_OUTPUT_NAME;
                 } else { /* compiler and linker options */
                     err=__ghf_concatHeapStrAndCharPtr(&pcOCLBuildOpts,
                                                        argv[i]);
@@ -89,15 +93,15 @@ int32_t main(int32_t argc, char *argv[]) {
         return(1);
     }
     err=_ghf_genrLog(&Log,
-#if defined(__OCLH_BUILDER_FLAG)
-                     _GHM_OCLH_BUILDER_LOG_FILENAME
-#endif /* defined(__OCLH_BUILDER_FLAG) */
 #if defined(__OCLH_COMPILER_ONLY_FLAG)
                      _GHM_OCLH_COMPILER_LOG_FILENAME
 #endif /* defined(__OCLH_COMPILER_ONLY_FLAG) */
 #if defined(__OCLH_LINKER_ONLY_FLAG)
                      _GHM_OCLH_LINKER_LOG_FILENAME
 #endif /* defined(__OCLH_LINKER_ONLY_FLAG) */
+#if defined(__OCLH_BUILDER_FLAG)
+                     _GHM_OCLH_BUILDER_LOG_FILENAME
+#endif /* defined(__OCLH_BUILDER_FLAG) */
                     );
     if(err) {
         _ghf_wipeDevLstDesc(&DevLstDesc);
@@ -112,15 +116,16 @@ int32_t main(int32_t argc, char *argv[]) {
         char** ppcSources=NULL;
         uint64_t i=0ul;
         while(ppcSrcFilenames[i]) {
-            err|=_ghf_addFileToCharPtrList(&ppcSources,ppcSrcFilenames[i],
+            err|=_ghf_addFileToCharPtrListWithSizes(&ppcSources,
+                                                    ppcSrcFilenames[i],
 #if defined(__OCLH_BUILDER_FLAG) || defined(__OCLH_COMPILER_ONLY_FLAG)
-                                           8);
+                                                    8);
 #else
-                                           1);
+                                                    1);
 #endif /* defined(__OCLH_BUILDER_FLAG) || defined(__OCLH_COMPILER_ONLY_FLAG) */
             i++;
         }
-        err=_ghf_genrAWSs(&AWSs, Log, DevLstDesc, ppcSources,
+        err=_ghf_genrAWSs(&AWSs,Log,DevLstDesc,(const char** const)ppcSources,
 #if defined(__OCLH_BUILDER_FLAG) || defined(__OCLH_COMPILER_ONLY_FLAG)
                           _GHE_HL_LISTINGS,
 #endif /* defined(__OCLH_BUILDER_FLAG) || defined(__OCLH_COMPILER_ONLY_FLAG) */
@@ -130,17 +135,17 @@ int32_t main(int32_t argc, char *argv[]) {
                           pcOCLBuildOpts, pcOutputPrefix);
         _ghf_wipeDevLstDesc(&DevLstDesc);
         _ghf_wipeCharPtrList(&ppcSrcFilenames);
-        _ghf_wipeCharPtrList(&ppcSources);
+        _ghf_wipeCharPtrListWithSizes(&ppcSources);
         _ghf_freeHostZ(&pcOCLBuildOpts);
         if(err) fprintf(stderr,"Check the log file\n");
     }
     {
         uint64_t i=0ul;
-        for(i=0ul; i<AWSs.u64NofWSs; i++) {
-            _ghf_saveWS_ProgramBinaries(AWSs.pWSet[i],pcOutputPrefix);
-        }
+        for(i=0ul; i<AWSs.u64NofWSs; i++)
+            _ghf_saveWS_ProgramBinaries(AWSs.pWSet[i],
+                                        pcOutputPrefix, OutNameType);
     }
     _ghf_wipeAWSs(&AWSs);
     _ghf_wipeLog(&Log);
-    return(0);
+    return(err);
 }

src/oclh_h_base_clapi_strings.c

@@ -194,6 +194,22 @@ char* _ghf_CLAPIErrString(const cl_int clErr) {
 #ifdef CL_INVALID_DEVICE_PARTITION_COUNT
   case CL_INVALID_DEVICE_PARTITION_COUNT:
                                     return("CL_INVALID_DEVICE_PARTITION_COUNT");
+#endif
+#ifdef CL_PLATFORM_NOT_FOUND_KHR
+  case CL_PLATFORM_NOT_FOUND_KHR:
+                                    return("CL_PLATFORM_NOT_FOUND_KHR");
+#endif
+#ifdef CL_DEVICE_PARTITION_FAILED_EXT
+  case CL_DEVICE_PARTITION_FAILED_EXT:
+                                    return("CL_DEVICE_PARTITION_FAILED_EXT");
+#endif
+#ifdef CL_INVALID_PARTITION_COUNT_EXT
+  case CL_INVALID_PARTITION_COUNT_EXT:
+                                    return("CL_INVALID_PARTITION_COUNT_EXT");
+#endif
+#ifdef CL_INVALID_PARTITION_NAME_EXT
+  case CL_INVALID_PARTITION_NAME_EXT:
+                                    return("CL_INVALID_PARTITION_NAME_EXT");
 #endif
   case -9999:                       return("NVIDIA_CL_SEGMENTATION_FAULT");
   default:                          return("Unknown OpenCL error");

src/oclh_h_clapi_callbacks.c

@@ -3,18 +3,37 @@
  *      Author: havock
  */
 #include <stdio.h>
+#include <oclh_h_settings.h>
+#include <oclh_h_ws_base.h>
+#include <oclh_h_ws_base_log.h>
 #include <oclh_h_clapi_callbacks.h>
 
 void CL_CALLBACK _ghf_CtxEvent(const char*  pcErrInfo,
                                const void*  pvPrivInfo,
                                      size_t szPrivInfo,
                                      void*  pvUserData) {
-    printf("Ctx callback | ");
-    if(pcErrInfo) printf("err: %s", pcErrInfo);
-    printf("priv_inf_addr:0x%lx ", (uint64_t)pvPrivInfo);
-    printf("priv_inf_sz: %f MiB/%f KiB/%lu B ",
-           ((float)szPrivInfo)/1024e0f/1024e0f, ((float)szPrivInfo)/1024e0f,
-           (uint64_t)szPrivInfo);
-    printf("user_data_addr:0x%lx\n", (uint64_t)pvUserData);
+    char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG];
+    _GHT_WRKSET* pwSet=(_GHT_WRKSET*)pvUserData;
+    snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+             "Ctx callback | err: %s",
+             pcErrInfo?pcErrInfo:"Undefined");
+    _ghf_logWS_Msg(*pwSet, pcLogMsg);
+    snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+             "Ctx callback | priv_inf_addr:0x%lx "
+             "priv_inf_sz: %f MiB/%f KiB/%lu B user_data_addr:0x%lx",
+             (uint64_t)pvPrivInfo,
+             ((float)szPrivInfo)/1024e0f/1024e0f, ((float)szPrivInfo)/1024e0f,
+             (uint64_t)szPrivInfo, (uint64_t)pvUserData);
+    _ghf_logWS_Msg(*pwSet, pcLogMsg);
+    return;
+}
+
+void CL_CALLBACK _ghf_LinkEvent(cl_program Program, void*  pvUserData) {
+    char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG];
+    _GHT_WRKSET* pwSet=(_GHT_WRKSET*)pvUserData;
+    snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+             "Linker callback| program: 0x%lx user_data_addr:0x%lx",
+             (uint64_t)Program, (uint64_t)pvUserData);
+    _ghf_logWS_Msg(*pwSet, pcLogMsg);
     return;
 }

src/oclh_h_externals.c

@@ -97,9 +97,14 @@ int32_t _ghf_addCharPtrToCharPtrList(char*** const pppcLst,
     } else return(_GHM_NULL_POINTER_RECEIVED_ERROR);
 }
 
-int32_t _ghf_addFileToCharPtrList(      char*** const pppcLst,
-                                  const char*   const pcFileName,
-                                  const uint64_t      u64Align) {
+int32_t _ghf_addFileToCharPtrListWithSizes(      char*** const pppcLst,
+                                           const char*   const pcFileName,
+                                           const uint64_t      u64Align) {
+/**/
+#define __ALIGNED_SIZE \
+    (((szFileLen+1)%u64Align)? \
+        szFileLen+(u64Align-szFileLen%u64Align):szFileLen+1)
+/**/
     if(pppcLst && pcFileName) {
         FILE* pFile=NULL;
         size_t szFileLen=0ul;
@@ -123,14 +128,23 @@ int32_t _ghf_addFileToCharPtrList(      char*** const pppcLst,
             fclose(pFile);
             return(_GHM_SEEK_FILE_ERROR);
         }
-        pcSource=malloc((szFileLen%u64Align)?szFileLen+
-                        (u64Align-szFileLen%u64Align):szFileLen); /* align */
+        pcSource=malloc(__ALIGNED_SIZE);
         if(!pcSource) {
             fprintf(stderr,"Unable to allocate host memory\n");
             perror("");
             fclose(pFile);
             return(_GHM_HOST_MEMALLOC_ERROR);
         }
+        { /* тонкий момент: выделено памяти на один байт больше, чем размер
+           * файла, чтобы установить в него нуль-терминатор, если программа
+           * представлена в виде исходного кода. Если программа представлена в
+           * бинарном виде, то её чтение ограничивается длиной и нуль-терминатор
+           * игнорируется. */
+            uint64_t i=0ul;
+            for(i=__ALIGNED_SIZE-1; i>0 && i>__ALIGNED_SIZE-17ul; i--)
+                pcSource[i]='\0';
+            pcSource[0]='\0';
+        }
         if(fread(pcSource,szFileLen,1,pFile)!=1) {
             fprintf(stderr,"Unable to read the source file %s\n",pcFileName);
             perror("");
@@ -143,17 +157,18 @@ int32_t _ghf_addFileToCharPtrList(      char*** const pppcLst,
             char** ppcTmp=NULL;
             uint64_t i=0ul;
             if(*pppcLst) while((*pppcLst)[i]) i++;
-            if(!*pppcLst) {
-                *pppcLst=malloc(sizeof(char*));
-                if(!pcSource) {
+            if(!i) {
+                *pppcLst=malloc(sizeof(char*)*2ul);
+                if(!*pppcLst) {
                     fprintf(stderr,"Unable to allocate host memory\n");
                     perror("");
                     _ghf_freeHostZ(pcSource);
                     return(_GHM_HOST_MEMALLOC_ERROR);
                 }
                 (*pppcLst)[0]=NULL;
+                (*pppcLst)[1]=NULL;
             }
-            ppcTmp=realloc(*pppcLst,sizeof(char*)*(i+2ul));
+            ppcTmp=realloc(*pppcLst,sizeof(char*)*(i+3ul));
             if(!ppcTmp) {
                 fprintf(stderr,"Unable to allocate host memory\n");
                 perror("");
@@ -162,10 +177,25 @@ int32_t _ghf_addFileToCharPtrList(      char*** const pppcLst,
             }
             *pppcLst=ppcTmp;
             (*pppcLst)[i]=pcSource;
+            (*pppcLst)[i+2]=(*pppcLst)[i+1];
             (*pppcLst)[i+1]=NULL;
+            {
+                size_t* pszTmp=NULL;
+                pszTmp=realloc((*pppcLst)[i+2],sizeof(uint64_t)*(i+1));
+                if(!pszTmp) {
+                    fprintf(stderr,"Unable to allocate host memory\n");
+                    perror("");
+                    return(_GHM_HOST_MEMALLOC_ERROR);
+                }
+                pszTmp[i]=szFileLen;
+                (*pppcLst)[i+2]=(char*)pszTmp;
+            }
         }
         return(_GHM_OK);
     } else return(_GHM_NULL_POINTER_RECEIVED_ERROR);
+/**/
+#undef __ALIGNED_SIZE
+/**/
 }
 
 void _ghf_wipeCharPtrList(char*** const pppcLst) {
@@ -176,3 +206,14 @@ void _ghf_wipeCharPtrList(char*** const pppcLst) {
     _ghf_freeHostZ(pppcLst);
     return;
 }
+
+void _ghf_wipeCharPtrListWithSizes(char*** const pppcLst) {
+    uint64_t i=0ul;
+    if(pppcLst && *pppcLst) {
+        for(i=0ul; (*pppcLst)[i]; i++)
+            _ghf_freeHostZ(&(*pppcLst)[i]);
+        _ghf_freeHostZ(&(*pppcLst)[i+1]);
+    }
+    _ghf_freeHostZ(pppcLst);
+    return;
+}

src/oclh_h_ws_base.c

@@ -32,7 +32,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                     const _GHT_LOG            Log,
                     const int32_t             i32ExclusiveLogFlag,
                     const cl_device_id        clWrkDev,
-                    const void*        const  pvCLProgramSources,
+                    const char**       const  ppcCLProgramSources,
                     const _GHE_SRCTYPE        SourceType,
                     const char*        const  pcOCLBuildOpts,
                     const _GHE_LOGLVL         LogLvl,
@@ -104,7 +104,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                     CL_CONTEXT_INTEROP_USER_SYNC, CL_FALSE, 0l };
                 clCtx=
                     clCreateContext(pclCtxProps,   1u,   &clWrkDev,
-                                    _ghf_CtxEvent, NULL, &pwSet->APIErr);
+                                    _ghf_CtxEvent, pwSet,&pwSet->APIErr);
                     /* TODO: ^[Valg] 8 bytes in 1 blocks are definitely lost
                      * in loss record 12 of 1,583 by Intel library
                      * Intel::OpenCL::TaskExecutor::TBBTaskExecutor::Init */
@@ -114,7 +114,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                     pclCtxProps[2]=(cl_context_properties)0l;
                     if(clCtx) pwSet->APIErr=clReleaseContext(clCtx);
                     clCtx=clCreateContext(pclCtxProps,   1u,   &clWrkDev,
-                                          _ghf_CtxEvent, NULL, &pwSet->APIErr);
+                                          _ghf_CtxEvent, pwSet,&pwSet->APIErr);
                     /* TODO: ^[Valg] 4 bytes in 1 blocks are definitely lost
                      * in loss record 1 of 1,587 */
                     if(pwSet->APIErr)
@@ -137,56 +137,172 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
         }
         if(LogLvl==_GHE_LOG_DEFAULT)
             _ghf_logWS_DevInfoShort(*pwSet, _ghf_getWS_Dev(*pwSet), NULL);
-        if(pvCLProgramSources) { /* program */
+        if(ppcCLProgramSources) { /* program */
             cl_device_id clWrkDev=_ghf_getWS_Dev(*pwSet);
             switch(SourceType) {
             case _GHE_HL_LISTINGS:
-                {
-                    cl_uint cluNofListings=0u;
-                    while(((char**)pvCLProgramSources)[cluNofListings]) {
-                        if(_GHM_SHOW_PROGRAM_LISTING_IN_LOG) {
-                            char pcLogMsg[64];
-                            snprintf(pcLogMsg, 64ul,
-                                     "Program: #%u", cluNofListings);
-                            _ghf_logWS_Hdr(*pwSet, pcLogMsg);
-                            _ghf_logWS_Raw(*pwSet,
-                                  ((char**)pvCLProgramSources)[cluNofListings]);
-                            _ghf_logWS_Hdr(*pwSet, "End of program");
-                        }
-                        cluNofListings++;
+              { cl_uint cluNofListings=0u;
+                while(((char**)ppcCLProgramSources)[cluNofListings]) {
+                    if(_GHM_SHOW_PROGRAM_LISTING_IN_LOG) {
+                        char pcLogMsg[64];
+                        snprintf(pcLogMsg, 64ul,
+                                 "Program: #%u", cluNofListings);
+                        _ghf_logWS_Hdr(*pwSet, pcLogMsg);
+                        _ghf_logWS_Raw(*pwSet,
+                                 ((char**)ppcCLProgramSources)[cluNofListings]);
+                        _ghf_logWS_Hdr(*pwSet, "End of program");
                     }
-                    pwSet->Program=
-                        clCreateProgramWithSource(
-                                          _ghf_getWS_Ctx(*pwSet),cluNofListings,
-                                          (const char**)pvCLProgramSources,
-                                          NULL, &pwSet->APIErr);
-                    if(pwSet->APIErr)
-                       __CLAPI_ERR_ROUTINE_WITH_RET("clCreateProgramWithSource")
+                    cluNofListings++;
                 }
-                break;
+                pwSet->Program=
+                    clCreateProgramWithSource(
+                              _ghf_getWS_Ctx(*pwSet),cluNofListings,
+                              (const char**)ppcCLProgramSources,
+                              NULL,
+                              /* TODO: стоило бы использовать размеры вместо
+                               * NULL, но по неясной причине передача длин
+                               * исходных текстов препятствует созданию
+                               * ядерных функций. Необходимо разобраться в
+                               * причинах. */
+                            /*((size_t**)ppcCLProgramSources)[cluNofListings+1],*/
+                              &pwSet->APIErr);
+                if(pwSet->APIErr) {
+#ifdef __OCLH_BUILD_LOG_TO_STDOUT_FLAG
+                    {
+                        FILE* pTmpFilePtr=pwSet->Log.pfOut;
+                        pwSet->Log.pfOut=stdout;
+                        _ghf_logWS_DevInfoShort(*pwSet,_ghf_getWS_Dev(*pwSet),
+                                                NULL);
+                        snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                                 "clCreateProgramWithSource");
+                        _ghf_logWS_APIErr(*pwSet, pcLogMsg);
+                        _ghf_logWS_Delim(*pwSet);
+                        pwSet->Log.pfOut=pTmpFilePtr;
+                    }
+#endif /* __OCLH_BUILD_LOG_TO_STDOUT_FLAG */
+                    __CLAPI_ERR_ROUTINE_WITH_RET("clCreateProgramWithSource")
+                } }
+            break;
             case _GHE_IR_LISTINGS:
-                {
-                    _ghf_logWS_Msg(*pwSet, "_GHE_IR_LISTINGS");
-                    _ghf_wipeWS(pwSet); return(1);
-                }
-                break;
+              { /* TODO: make IR output and processing */
+                _ghf_logWS_Msg(*pwSet, "_GHE_IR_LISTINGS");
+                _ghf_wipeWS(pwSet); return(1); }
+            break;
             case _GHE_SEPARATED_OBJECTS:
-            case _GHE_LINKED_OBJECTS:
-                {
-                _ghf_logWS_Msg(*pwSet,
-                               "_GHE_SEPARATED_OBJECTS or _GHE_LINKED_OBJECTS");
-                _ghf_wipeWS(pwSet); return(1);
-                }
-                break;
-            default:
-                {
+              { cl_device_id cldev=_ghf_getWS_Dev(*pwSet);
+                cl_program* pPrograms=NULL;
+                cl_uint cluNofBinaries=0u,
+                        i=0u;
+                while(((char**)ppcCLProgramSources)[cluNofBinaries])
+                    cluNofBinaries++;
+                pPrograms=malloc(sizeof(cl_program)*cluNofBinaries);
+                if(!pPrograms) {
                     char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG];
                     snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                             "Unknown program source");
-                    _ghf_logWS_APIErr(*pwSet, pcLogMsg);
-                    _ghf_wipeWS(pwSet);
-                    return(_GHM_UNKNOWN_PROGRAM_SOURCE_ERROR);
+                             "%s/Host memory allocation failed", __func__);
+                    _ghf_logWS_Msg(*pwSet, pcLogMsg); _ghf_wipeWS(pwSet);
+                    return(_GHM_HOST_MEMALLOC_ERROR);
+                }
+                for(i=0u; i<cluNofBinaries; i++) pPrograms[i]=NULL;
+                for(i=0u; i<cluNofBinaries; i++) {
+                    cl_int cliBinStatus=CL_SUCCESS;
+                    pPrograms[i]=
+                        clCreateProgramWithBinary(
+                          _ghf_getWS_Ctx(*pwSet),1u,&cldev,
+                          &((size_t**)ppcCLProgramSources)[cluNofBinaries+1][i],
+                          &((const uint8_t**)ppcCLProgramSources)[i],
+                          &cliBinStatus, &pwSet->APIErr);
+                    if(pwSet->APIErr) {
+                        cl_int err=pwSet->APIErr;
+                        for(i=0u; i<cluNofBinaries; i++)
+                            if(pPrograms[i])
+                                pwSet->APIErr=clReleaseProgram(pPrograms[i]);
+                        _ghf_freeHostZ(&pPrograms);
+                        pwSet->APIErr=err;
+#ifdef __OCLH_BUILD_LOG_TO_STDOUT_FLAG
+                    {
+                        FILE* pTmpFilePtr=pwSet->Log.pfOut;
+                        pwSet->Log.pfOut=stdout;
+                        _ghf_logWS_DevInfoShort(*pwSet,_ghf_getWS_Dev(*pwSet),
+                                                NULL);
+                        snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                                 "clCreateProgramWithBinary");
+                        _ghf_logWS_APIErr(*pwSet, pcLogMsg);
+                        _ghf_logWS_Delim(*pwSet);
+                        pwSet->Log.pfOut=pTmpFilePtr;
+                    }
+#endif /* __OCLH_BUILD_LOG_TO_STDOUT_FLAG */
+                       __CLAPI_ERR_ROUTINE_WITH_RET("clCreateProgramWithBinary")
+                    }
                 }
+                pwSet->Program=clLinkProgram(_ghf_getWS_Ctx(*pwSet), 1u, &cldev,
+                                             pcOCLBuildOpts?pcOCLBuildOpts:"",
+                                             cluNofBinaries, pPrograms,
+                                             _ghf_LinkEvent, pwSet,
+                                             &pwSet->APIErr);
+                if(pwSet->APIErr) {
+                    cl_int err=pwSet->APIErr;
+                    for(i=0u; i<cluNofBinaries; i++)
+                        if(pPrograms[i])
+                            pwSet->APIErr=clReleaseProgram(pPrograms[i]);
+                    _ghf_freeHostZ(&pPrograms);
+                    pwSet->APIErr=err;
+#ifdef __OCLH_BUILD_LOG_TO_STDOUT_FLAG
+                    {
+                        FILE* pTmpFilePtr=pwSet->Log.pfOut;
+                        pwSet->Log.pfOut=stdout;
+                        _ghf_logWS_DevInfoShort(*pwSet,_ghf_getWS_Dev(*pwSet),
+                                                NULL);
+                        snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                                 "clLinkProgram");
+                        _ghf_logWS_APIErr(*pwSet, pcLogMsg);
+                        _ghf_logWS_Delim(*pwSet);
+                        pwSet->Log.pfOut=pTmpFilePtr;
+                    }
+#endif /* __OCLH_BUILD_LOG_TO_STDOUT_FLAG */
+                    __CLAPI_ERR_ROUTINE_WITH_RET("clLinkProgram")
+                }
+                for(i=0u; i<cluNofBinaries; i++)
+                    if(pPrograms[i])
+                        pwSet->APIErr=clReleaseProgram(pPrograms[i]);
+                _ghf_freeHostZ(&pPrograms); }
+            break;
+            case _GHE_LINKED_OBJECTS:
+              { cl_device_id cldev=_ghf_getWS_Dev(*pwSet);
+                cl_uint cluNofBinaries=0u;
+                cl_int cliBinStatus=CL_SUCCESS;
+                while(((char**)ppcCLProgramSources)[cluNofBinaries])
+                    cluNofBinaries++;
+                pwSet->Program=
+                    clCreateProgramWithBinary(
+                              _ghf_getWS_Ctx(*pwSet),1u,&cldev,
+                              ((size_t**)ppcCLProgramSources)[cluNofBinaries+1],
+                              (const uint8_t**)ppcCLProgramSources,
+                              &cliBinStatus, &pwSet->APIErr);
+                if(pwSet->APIErr) {
+#ifdef __OCLH_BUILD_LOG_TO_STDOUT_FLAG
+                    {
+                        FILE* pTmpFilePtr=pwSet->Log.pfOut;
+                        pwSet->Log.pfOut=stdout;
+                        _ghf_logWS_DevInfoShort(*pwSet,_ghf_getWS_Dev(*pwSet),
+                                                NULL);
+                        snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                                 "clCreateProgramWithBinary");
+                        _ghf_logWS_APIErr(*pwSet, pcLogMsg);
+                        _ghf_logWS_Delim(*pwSet);
+                        pwSet->Log.pfOut=pTmpFilePtr;
+                    }
+#endif /* __OCLH_BUILD_LOG_TO_STDOUT_FLAG */
+                    __CLAPI_ERR_ROUTINE_WITH_RET("clCreateProgramWithBinary")
+                } }
+            break;
+            default:
+              { char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG];
+                snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                         "Unknown program source");
+                _ghf_logWS_APIErr(*pwSet, pcLogMsg);
+                _ghf_wipeWS(pwSet);
+                return(_GHM_UNKNOWN_PROGRAM_SOURCE_ERROR); }
             }
             {
                 cl_int cliBuildCLAPIErr=CL_SUCCESS;
@@ -226,11 +342,11 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                                      LogLvl, _GHE_NO_BUILD_LOG);
                 {
                     _GHT_LOG TmpLog=_ghf_declLog();
-                    cl_uint cluNofKernels=0u;
-#ifndef __OCLH_COMPILER_ONLY_FLAG
+                    /* cl_uint cluNofKernels=0u; */
+                    size_t szNofKernels=0ul;
                     cl_build_status clBuildStatus=
                                         _ghf_getWS_BuildStatus(*pwSet);
-#endif /* __OCLH_COMPILER_ONLY_FLAG */
+                    cl_program_binary_type clBinType=0u;
                     if(BuildLogMode==_GHE_BUILD_LOG_IN_SEPARATED_FILES) {
                         TmpLog=pwSet->Log;
                         int32_t err=0;
@@ -283,17 +399,39 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                     pwSet->APIErr=cliBuildCLAPIErr;
                     if(pwSet->APIErr) {
                         if(_ghf_isLog_Valid(TmpLog)) {
-                            _ghf_logWS_APIErr(*pwSet, pcLogMsg);
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                            _ghf_logWS_APIErr(*pwSet, "clCompileProgram");
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
+                            _ghf_logWS_APIErr(*pwSet, "clBuildProgram");
+#endif
                             _ghf_wipeLog(&pwSet->Log); }
                         pwSet->Log=TmpLog;
                         if(pcBldOpts) { free(pcBldOpts); pcBldOpts=NULL; }
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                        __CLAPI_ERR_ROUTINE_WITH_RET("clCompileProgram")
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                         __CLAPI_ERR_ROUTINE_WITH_RET("clBuildProgram")
+#endif
                     }
-#ifndef __OCLH_COMPILER_ONLY_FLAG
-                    if(!clBuildStatus) {
-                        pwSet->APIErr=
+                    pwSet->APIErr=
+                        clGetProgramBuildInfo(pwSet->Program, clWrkDev,
+                                              CL_PROGRAM_BINARY_TYPE,
+                                              sizeof(cl_program_binary_type),
+                                              &clBinType, NULL);
+                    if(pwSet->APIErr) clBinType=CL_PROGRAM_BINARY_TYPE_NONE;
+                    if(!clBuildStatus &&
+                       (clBinType&CL_PROGRAM_BINARY_TYPE_EXECUTABLE)) {
+                        /* another approach to get the number of kernels */
+                        /* pwSet->APIErr=
                             clCreateKernelsInProgram(pwSet->Program, 0u, NULL,
-                                                     &cluNofKernels);
+                                                     &cluNofKernels); */
+                        pwSet->APIErr=
+                            clGetProgramInfo(pwSet->Program,
+                                             CL_PROGRAM_NUM_KERNELS,
+                                             sizeof(size_t), &szNofKernels,
+                                             NULL);
                         if(pwSet->APIErr) {
                             if(_ghf_isLog_Valid(TmpLog)) {
                                 _ghf_logWS_APIErr(*pwSet, pcLogMsg);
@@ -301,10 +439,10 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                             pwSet->Log=TmpLog;
                             if(pcBldOpts) { free(pcBldOpts); pcBldOpts=NULL; }
                             __CLAPI_ERR_ROUTINE_WITH_RET(
-                                                     "clCreateKernelsInProgram")
+                                                     "clGetProgramInfo")
                         }
                         pwSet->pKernels=malloc(
-                                      sizeof(cl_kernel)*(cluNofKernels+1));
+                                      sizeof(cl_kernel)*(szNofKernels+1ul));
                         if(!pwSet->pKernels) {
                             char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG];
                             snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
@@ -319,11 +457,12 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                             _ghf_wipeWS(pwSet);
                             return(_GHM_HOST_MEMALLOC_ERROR);
                         }
-                        {
+                        pwSet->pKernels[szNofKernels]=NULL;
+                        if(szNofKernels) {
                             cl_uint ctrlVal=0u;
                             pwSet->APIErr=
                                 clCreateKernelsInProgram(pwSet->Program,
-                                                         cluNofKernels,
+                                                         (cl_uint)szNofKernels,
                                                          pwSet->pKernels,
                                                          &ctrlVal);
                             /* TODO: ^[Valg] 192 (32 direct, 160 indirect) bytes
@@ -342,7 +481,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                                 __CLAPI_ERR_ROUTINE_WITH_RET(
                                                      "clCreateKernelsInProgram")
                             }
-                            if(ctrlVal!=cluNofKernels) {
+                            if(ctrlVal!=(cl_uint)szNofKernels) {
                                 char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG];
                                 snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
                                          "%s/The number of created kernels "
@@ -357,7 +496,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                                     free(pcBldOpts); pcBldOpts=NULL; }
                                 return(_GHM_CREATING_KERNELS_ERROR);
                             }
-                            pwSet->pKernels[cluNofKernels]=NULL;
+                            pwSet->pKernels[szNofKernels]=NULL;
                             /*
                              * TODO: make sort of kernel list for tree search
                              *       for GetKernelByName
@@ -365,7 +504,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                         }
                     }
                     snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                             "%u kernels registered", cluNofKernels);
+                             "%lu kernels registered", szNofKernels);
                     _ghf_logWS_Msg(*pwSet, pcLogMsg);
 #ifdef __OCLH_BUILD_LOG_TO_STDOUT_FLAG
                     {
@@ -375,7 +514,7 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                         pwSet->Log.pfOut=pTmpFilePtr;
                     }
 #endif /* __OCLH_BUILD_LOG_TO_STDOUT_FLAG */
-                    {
+                    if(pwSet->pKernels) {
                         cl_uint i=0u;
                         for(i=0u; pwSet->pKernels[i]; i++) {
                             _ghf_logWS_KerInfo(*pwSet,pwSet->pKernels[i]);
@@ -397,14 +536,13 @@ int32_t _ghf_genrWS(      _GHT_WRKSET* const  pwSet,
                         pwSet->Log.pfOut=pTmpFilePtr;
                     }
 #endif /* __OCLH_BUILD_LOG_TO_STDOUT_FLAG */
-#endif /* __OCLH_COMPILER_ONLY_FLAG */
                     if(BuildLogMode==_GHE_BUILD_LOG_IN_SEPARATED_FILES) {
                         _ghf_wipeLog(&pwSet->Log);
                         pwSet->Log=TmpLog;
                     }
                     if(_ghf_isLog_Valid(TmpLog)) {
                         snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                             "%u kernels registered", cluNofKernels);
+                             "%lu kernels registered", szNofKernels);
                         _ghf_logWS_Msg(*pwSet, pcLogMsg);
                     }
                 }
@@ -723,7 +861,8 @@ cl_uint _ghf_getWS_MaxCmpUnits(_GHT_WRKSET wSet) {
 }
 
 int32_t _ghf_saveWS_ProgramBinaries(_GHT_WRKSET wSet,
-                                    char* const pcOutputPrefix) {
+                                    char* const pcOutputName,
+                                    _GHE_OUTNAME_TYPE OutNameType) {
     char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG]="\0";
     int32_t err=0;
     size_t szRes=0ul,
@@ -793,19 +932,53 @@ int32_t _ghf_saveWS_ProgramBinaries(_GHT_WRKSET wSet,
         for(i=0ul; i<u64NofBinsBySizes; i++) {
             FILE* pFile=NULL;
             char pcBinFileName[_GHM_MAX_PATH_LENGTH]="\0",
-                 pcTextProgramID[_GHM_MAX_PATH_LENGTH]="\0";
-            __ghf_setWS_TextProgramId(wSet, pcTextProgramID, pcOutputPrefix);
-            snprintf(pcBinFileName, _GHM_MAX_PATH_LENGTH,
+                 pcTextProgramID[_GHM_MAX_PATH_LENGTH]="\0",
+                *pcFileExtension=NULL;
+            if(OutNameType==_GHE_VOLATILE_OUTPUT_NAME) {
+                __ghf_setWS_TextProgramId(wSet, pcTextProgramID, pcOutputName);
 #if defined(__OCLH_COMPILER_ONLY_FLAG)
-                     "%s/%s.%lu.clo",
-#else
-                     "%s/%s.%lu.clb",
-#endif /* defined(__OCLH_COMPILER_ONLY_FLAG) */
-                     _GHM_LOG_PATH, pcTextProgramID, i);
+                pcFileExtension=".clo";
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                {
+                    cl_program_binary_type clBinType=0u;
+                    size_t szRes=0ul;
+                    wSet.APIErr=
+                        clGetProgramBuildInfo(wSet.Program,_ghf_getWS_Dev(wSet),
+                                              CL_PROGRAM_BINARY_TYPE,
+                                              sizeof(cl_program_binary_type),
+                                              &clBinType, &szRes);
+                    if(wSet.APIErr) clBinType=CL_PROGRAM_BINARY_TYPE_NONE;
+                    pcFileExtension=".clout";
+                    if(clBinType&CL_PROGRAM_BINARY_TYPE_LIBRARY)
+                        pcFileExtension=".clso";
+                    if(clBinType&CL_PROGRAM_BINARY_TYPE_EXECUTABLE)
+                        pcFileExtension=".clexe";
+                }
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
+                /* TODO: It is assumed that by default executable binary
+                 * is built but actually it is not always so */
+                pcFileExtension=".clexe";
+#endif
+                snprintf(pcBinFileName, _GHM_MAX_PATH_LENGTH, "%s/%s.%lu%s",
+                         _GHM_LOG_PATH, pcTextProgramID, i, pcFileExtension);
+            }
+            if(OutNameType==_GHE_VERBATIM_OUTPUT_NAME) {
+                if(pcOutputName && pcOutputName[0]) {
+                    snprintf(pcBinFileName, _GHM_MAX_PATH_LENGTH, "%s/%s",
+                         _GHM_LOG_PATH, pcOutputName);
+                } else {
+                    snprintf(pcBinFileName, _GHM_MAX_PATH_LENGTH, "%s/%s",
+                         _GHM_LOG_PATH, "a.clout");
+                }
+            }
             pFile=fopen(pcBinFileName,"wb");
             if(!pFile) {
-                fprintf(stderr,
-                        "Unable to open the binary file %s\n", pcBinFileName);
+                snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                         "Unable to open the binary file %s", pcBinFileName);
+                _ghf_logWS_Msg(wSet,pcLogMsg);
+                fprintf(stderr,"%s\n", pcLogMsg);
                 perror("");
                 { uint64_t i=0ul;
                   for(i=0; i<u64NofBinsBySizes; i++)
@@ -814,8 +987,10 @@ int32_t _ghf_saveWS_ProgramBinaries(_GHT_WRKSET wSet,
                 return(_GHM_OPEN_FILE_ERROR);
             }
             if(fwrite(ppcBins[i],pszOfBins[i],1,pFile)!=1) {
-                fprintf(stderr,
-                        "Unable to write the binary file %s\n", pcBinFileName);
+                snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                         "Unable to write the binary file %s", pcBinFileName);
+                _ghf_logWS_Msg(wSet,pcLogMsg);
+                fprintf(stderr,"%s\n", pcLogMsg);
                 perror("");
                 { uint64_t i=0ul;
                   for(i=0; i<u64NofBinsBySizes; i++)
@@ -825,6 +1000,10 @@ int32_t _ghf_saveWS_ProgramBinaries(_GHT_WRKSET wSet,
                 return(_GHM_WRITE_FILE_ERROR);
             }
             fclose(pFile);
+            snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                     "The program binary have been written to %s",
+                     pcBinFileName);
+            _ghf_logWS_Msg(wSet,pcLogMsg);
         }
     }
     { uint64_t i=0ul;
@@ -962,16 +1141,16 @@ _GHT_AWSS _ghf_declAWSs(const _GHE_LOGLVL  LogLvl,
     return(AWSs);
 }
 
-int32_t _ghf_genrAWSs(      _GHT_AWSS*  const pAWSs,
-                      const _GHT_LOG          Log,
-                      const _GHT_DEVLIST_DESC DevLstDesc,
-                      const void*       const pvCLProgramSources,
-                      const _GHE_SRCTYPE      SourceType,
-                      const char*       const OCLBuildOpts
+int32_t _ghf_genrAWSs(      _GHT_AWSS*   const pAWSs,
+                      const _GHT_LOG           Log,
+                      const _GHT_DEVLIST_DESC  DevLstDesc,
+                      const char**       const ppcCLProgramSources,
+                      const _GHE_SRCTYPE       SourceType,
+                      const char*        const OCLBuildOpts
 #if defined(__OCLH_BUILDER_FLAG) || \
     defined(__OCLH_COMPILER_ONLY_FLAG) || \
     defined(__OCLH_LINKER_ONLY_FLAG)
-                    ,       char* const pcOutputPrefix
+                    ,       char*        const pcOutputPrefix
 #endif /* defined(__OCLH_BUILDER_FLAG) ||
           defined(__OCLH_COMPILER_ONLY_FLAG) ||
           defined(__OCLH_LINKER_ONLY_FLAG) */
@@ -1079,7 +1258,7 @@ int32_t _ghf_genrAWSs(      _GHT_AWSS*  const pAWSs,
                                 DevLst[TmpDevLstDesc.pcluIdxs[i]]:
                                 DevLst[DevLstDesc.pcluIdxs?
                                            DevLstDesc.pcluIdxs[i]:i],
-                            pvCLProgramSources, SourceType, OCLBuildOpts,
+                            ppcCLProgramSources, SourceType, OCLBuildOpts,
                             pAWSs->LogLevel, pAWSs->BuildLogMode
 #if defined(__OCLH_BUILDER_FLAG) || \
     defined(__OCLH_COMPILER_ONLY_FLAG) || \

src/oclh_h_ws_log_clapi_reps.c

@@ -10,6 +10,7 @@
 #include <oclh_h_ws_base_log.h>
 #include <oclh_h_ws_log_clapi_reps.h>
 #include <oclh_hd_std_types.clh>
+#include <oclh_h_internals.h>
 
 int32_t _ghf_logWS_PlatfInfo(const _GHT_WRKSET    wSet,
                              const cl_platform_id Platform,
@@ -886,34 +887,35 @@ int32_t _ghf_logWS_DevInfoShort(      _GHT_WRKSET  wSet,
                                    &wSet.APIErr)?"little-endian":"big-endian");
     _ghf_logWS_Msg(wSet, pcLogMsg);
     snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-             "%s Memory: %.3f MiB/%u bits address ", pcDevPrefix,
+             "%s Mem: %.3f MiB/%u bits address ", pcDevPrefix,
              ((flt32_t)_ghf_getDevInf_clulong(clDev, CL_DEVICE_GLOBAL_MEM_SIZE,
                                               &wSet.APIErr))/1024e0f/1024e0f,
              _ghf_getDevInf_cluint(clDev, CL_DEVICE_ADDRESS_BITS,&wSet.APIErr));
     _ghf_logWS_Msg(wSet, pcLogMsg);
-    _ghf_logWS_DevInf_charptr(wSet,clDev, CL_DEVICE_VENDOR,
-                              pcDevPrefix, "Vendor:","");
-    _ghf_logWS_DevInf_charptr(wSet,clDev, CL_DEVICE_NAME, pcDevPrefix,
-                              "Model:","");
     {
-        char* pcHWvers=NULL, *pcHWlang=NULL;
-        pcStr[0]='\0';
+        char* pcVendor=_ghf_getDevInf_charptr(_ghf_getWS_Dev(wSet),
+                                              CL_DEVICE_VENDOR, &wSet.APIErr),
+             *pcModel=_ghf_getDevInf_charptr(_ghf_getWS_Dev(wSet),
+                                              CL_DEVICE_NAME, &wSet.APIErr);
+        __ghf_removePreNPostSpacesFromCharPtr(pcVendor);
+        __ghf_removePreNPostSpacesFromCharPtr(pcModel);
+        snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+                 "%s Vendor/model: %s / %s ", pcDevPrefix,
+                 pcVendor?pcVendor:"Undefined",pcModel?pcModel:"Undefined");
+        _ghf_logWS_Msg(wSet, pcLogMsg);
+        if(pcVendor) { free(pcVendor); pcVendor=NULL; }
+        if(pcModel)  { free(pcModel);  pcModel =NULL; }
+    }
+    {
+        char* pcHWvers=_ghf_getDevInf_charptr(clDev, CL_DEVICE_VERSION,
+                                              &wSet.APIErr),
+             *pcHWlang=_ghf_getDevInf_charptr(clDev, CL_DEVICE_OPENCL_C_VERSION,
+                                              &wSet.APIErr);;
         pcHWvers=_ghf_getDevInf_charptr(clDev, CL_DEVICE_VERSION, &wSet.APIErr);
-        if(wSet.APIErr || !pcHWvers)
-            snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG,
-                     "Undefined! clGetDeviceInfo/CL_DEVICE_VERSION "
-                     "returned %s(%d)",
-                     _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
-        pcHWlang=_ghf_getDevInf_charptr(clDev, CL_DEVICE_OPENCL_C_VERSION,
-                                        &wSet.APIErr);
-        if(wSet.APIErr || !pcHWlang)
-            snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG,
-                     "Undefined! clGetDeviceInfo/CL_DEVICE_OPENCL_C_VERSION "
-                     "returned %s(%d)",
-                     _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
         snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                 "%s HW/lang versions: %s / %s",
-                 pcDevPrefix, pcHWvers?pcHWvers:pcStr, pcHWlang?pcHWlang:pcStr);
+                 "%s HW ver./lang ver.: %s / %s", pcDevPrefix,
+                 pcHWvers?pcHWvers:"Undefined",
+                 pcHWlang?pcHWlang:"Undefined");
         if(pcHWvers) { free(pcHWvers); pcHWvers=NULL; }
         if(pcHWlang) { free(pcHWlang); pcHWlang=NULL; }
         _ghf_logWS_Msg(wSet, pcLogMsg);
@@ -921,70 +923,43 @@ int32_t _ghf_logWS_DevInfoShort(      _GHT_WRKSET  wSet,
     {
         char* pcDRVvers=
             _ghf_getDevInf_charptr(clDev, CL_DRIVER_VERSION, &wSet.APIErr);
-        if(wSet.APIErr || !pcDRVvers)
-            snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG,
-                     "Undefined! clGetDeviceInfo/CL_DRIVER_VERSION "
-                     "returned %s(%d)",
-                     _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
-        snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                 "%s Driver version: %s",pcDevPrefix,pcDRVvers?pcDRVvers:pcStr);
-        if(pcDRVvers) { free(pcDRVvers); pcDRVvers=NULL; }
-        _ghf_logWS_Msg(wSet, pcLogMsg);
-    }
-    {
         uint64_t off=0ul;
         cl_platform_id clplidPlatf=
             (cl_platform_id)_ghf_getDevInf_uintptr(clDev,CL_DEVICE_PLATFORM,
                                                    &wSet.APIErr);
         if(wSet.APIErr)
-            off+=(uint64_t)snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG,
-                                    "Undefined! "
-                                    "clGetDeviceInfo/CL_PLATFORM_NAME "
-                                    "returned %s(%d)",
-                                    _ghf_CLAPIErrString(wSet.APIErr),
-                                    wSet.APIErr);
+            off+=(uint64_t)snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG, "Undefined");
         wSet.APIErr=clGetPlatformInfo(clplidPlatf, CL_PLATFORM_NAME, 0ul,
                                       NULL, &szRes);
         if(wSet.APIErr) {
             off+=(uint64_t)snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG,
-                                    "Undefined! "
-                                    "clGetPlatformInfo/CL_PLATFORM_NAME "
-                                    "returned %s(%d)",
-                                    _ghf_CLAPIErrString(wSet.APIErr),
-                                    wSet.APIErr);
+                                    "Undefined");
         } else {
             wSet.APIErr=clGetPlatformInfo(clplidPlatf, CL_PLATFORM_NAME,
                                           _GHM_MAXLEN_OF_LOGMSG-1ul, pcStr,
                                           &szRes);
             if(wSet.APIErr) {
                 off+=(uint64_t)snprintf(pcStr, _GHM_MAXLEN_OF_LOGMSG,
-                                        "Undefined! "
-                                        "clGetPlatformInfo/CL_PLATFORM_NAME "
-                                        "returned %s(%d)",
-                                        _ghf_CLAPIErrString(wSet.APIErr),
-                                        wSet.APIErr);
+                                        "Undefined");
             } else off+=(szRes-1ul);
         }
-        off+=(uint64_t)snprintf(&pcStr[off], _GHM_MAXLEN_OF_LOGMSG, " - ver. ");
+        off+=(uint64_t)snprintf(&pcStr[off], _GHM_MAXLEN_OF_LOGMSG, "-ver.");
         wSet.APIErr=clGetPlatformInfo(clplidPlatf, CL_PLATFORM_VERSION, 0ul,
                                       NULL, &szRes);
         if(wSet.APIErr) {
-            snprintf(&pcStr[off], _GHM_MAXLEN_OF_LOGMSG,
-                     "Undefined! clGetPlatformInfo/CL_PLATFORM_VERSION "
-                     "returned %s(%d)",
-                     _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
+            snprintf(&pcStr[off], _GHM_MAXLEN_OF_LOGMSG, "Undefined");
         } else {
             wSet.APIErr=clGetPlatformInfo(clplidPlatf, CL_PLATFORM_VERSION,
                                           _GHM_MAXLEN_OF_LOGMSG-off,&pcStr[off],
                                           &szRes);
             if(wSet.APIErr)
-                snprintf(&pcStr[off], _GHM_MAXLEN_OF_LOGMSG,
-                         "Undefined! clGetPlatformInfo/CL_PLATFORM_VERSION "
-                         "returned %s(%d)",
-                         _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
+                snprintf(&pcStr[off], _GHM_MAXLEN_OF_LOGMSG, "Undefined");
         }
         snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                 "%s SW-version: %s", pcDevPrefix, pcStr);
+                 "%s Drv ver./SW: %s / %s", pcDevPrefix,
+                 pcDRVvers?pcDRVvers:"Undefined",
+                 pcStr);
+        if(pcDRVvers) { free(pcDRVvers); pcDRVvers=NULL; }
         _ghf_logWS_Msg(wSet, pcLogMsg);
     }
     {
@@ -1164,7 +1139,7 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                              const cl_device_id clDev,
                              const _GHE_LOGLVL  LogLevel,
                              const _GHE_BUILD_LOG_MODE BuildLogMode) {
-    /* TODO: make ifdefs */
+    /* TODO: make ifdefs for queries */
     char pcLogMsg[_GHM_MAXLEN_OF_LOGMSG],
          pcProgram[64];
     cl_build_status clStatus=0;
@@ -1178,7 +1153,15 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                                   CL_PROGRAM_BUILD_OPTIONS, 0ul, NULL, &szRes);
         if(wSet.APIErr)
             snprintf(pcLogMsg,_GHM_MAXLEN_OF_LOGMSG,
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                     "%s Compiler options: Undefined! "
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                     "%s Linker options: Undefined! "
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                      "%s Build options: Undefined! "
+#endif
                      "clGetDeviceInfo returned oclerr %s(%d)",
                      pcProgram, _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
         else {
@@ -1190,19 +1173,44 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                                           szRes, pcVal, &szRes);
                 if(wSet.APIErr)
                     snprintf(pcLogMsg,_GHM_MAXLEN_OF_LOGMSG,
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                             "%s Compiler options: Undefined! "
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                             "%s Linker options: Undefined! "
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                              "%s Build options: Undefined! "
+#endif
                              "clGetDeviceInfo returned oclerr %s(%d)",
                              pcProgram,
                              _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
                 else {
                     pcVal[szRes-1]='\0';
                     snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                             "%s Build options: %s", pcProgram, pcVal);
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                             "%s Compiler options: %s",
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                             "%s Linker options: %s",
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
+                             "%s Build options: %s",
+#endif
+                             pcProgram, pcVal);
                 }
                 if(pcVal) { free(pcVal); pcVal=NULL; }
             } else
                 snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                         "%s Compiler options: Undefined! "
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                         "%s Linker options: Undefined! "
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                          "%s Build options: Undefined! "
+#endif
                          "Host memory allocation failed", pcProgram);
         }
         _ghf_logWS_Msg(wSet, pcLogMsg);
@@ -1229,7 +1237,16 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                 default: strncpy(pcVal,"Unknown", _GHM_MAXLEN_OF_LOGMSG);
             }
         snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
-                 "%s Build status: %s", pcProgram, pcVal);
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                 "%s Compilation status: %s",
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                 "%s Linker status: %s",
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
+                 "%s Build status: %s",
+#endif
+                 pcProgram, pcVal);
         _ghf_logWS_Msg(wSet, pcLogMsg);
     }
     if(LogLevel>=_GHE_LOG_KEY_PARS) { /* binary type */
@@ -1245,15 +1262,18 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                      "Undefined! clGetProgramBuildInfo returned oclerr %s(%d)",
                      _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
         else {
-            if(clBinType==0)
+            if(clBinType==CL_PROGRAM_BINARY_TYPE_NONE)
                 strncat(pcVal, "none ", _GHM_MAXLEN_OF_LOGMSG-strlen(pcVal));
-            if(((clBinType>>1)%2))
+            if(clBinType&CL_PROGRAM_BINARY_TYPE_COMPILED_OBJECT)
                 strncat(pcVal, "object ", _GHM_MAXLEN_OF_LOGMSG-strlen(pcVal));
-            if(((clBinType>>2)%2))
+            if(clBinType&CL_PROGRAM_BINARY_TYPE_LIBRARY)
                 strncat(pcVal, "library ", _GHM_MAXLEN_OF_LOGMSG-strlen(pcVal));
-            if(((clBinType>>3)%2))
+            if(clBinType&CL_PROGRAM_BINARY_TYPE_EXECUTABLE)
                 strncat(pcVal, "executable ",
                         _GHM_MAXLEN_OF_LOGMSG-strlen(pcVal));
+            /* TODO: уточнить так ли идентифицируется SPIR */
+            if(clBinType==CL_PROGRAM_BINARY_TYPE_INTERMEDIATE)
+                snprintf(pcVal, _GHM_MAXLEN_OF_LOGMSG, "IR ");
         }
         snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
                  "%s Binary type: %s", pcProgram, pcVal);
@@ -1267,7 +1287,15 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                                   CL_PROGRAM_BUILD_LOG, 0ul, NULL, &szRes);
         if(wSet.APIErr) {
             snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                     "%s Compilation Log: Undefined! "
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                     "%s Linker Log: Undefined! "
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                      "%s Build Log: Undefined! "
+#endif
                      "clGetDeviceInfo returned oclerr %s(%d)",
                      pcProgram, _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
             _ghf_logWS_Msg(wSet, pcLogMsg);
@@ -1275,7 +1303,15 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
             pcVal=malloc(szRes);
             if(!pcVal) {
                 snprintf(pcLogMsg, _GHM_MAXLEN_OF_LOGMSG,
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                         "%s Compilation Log: Undefined! "
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                         "%s Linker Log: Undefined! "
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                          "%s Build Log: Undefined! "
+#endif
                          "Host memory allocation failed", pcProgram);
                 _ghf_logWS_Msg(wSet, pcLogMsg);
             } else {
@@ -1285,7 +1321,15 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                                           szRes, pcVal, &szRes);
                 if(wSet.APIErr) {
                     snprintf(pcLogMsg,_GHM_MAXLEN_OF_LOGMSG,
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                             "%s Compilation Log: Undefined! "
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                             "%s Linker Log: Undefined! "
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                              "%s Build Log: Undefined! "
+#endif
                              "clGetDeviceInfo returned oclerr %s(%d)",
                              pcProgram,
                              _ghf_CLAPIErrString(wSet.APIErr), wSet.APIErr);
@@ -1293,9 +1337,25 @@ int32_t _ghf_logWS_BuildInfo(      _GHT_WRKSET  wSet,
                 } else {
                     if(clStatus || BuildLogMode) {
                         pcVal[szRes-1]='\0';
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                        _ghf_logWS_Hdr(wSet, "Compilation Log:");
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                        _ghf_logWS_Hdr(wSet, "Linker Log:");
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                         _ghf_logWS_Hdr(wSet, "Build Log:");
+#endif
                         _ghf_logWS_Raw(wSet, pcVal);
+#if defined(__OCLH_COMPILER_ONLY_FLAG)
+                        _ghf_logWS_Hdr(wSet, "End of compilation log");
+#endif
+#if defined(__OCLH_LINKER_ONLY_FLAG)
+                        _ghf_logWS_Hdr(wSet, "End of linker log");
+#endif
+#if !defined(__OCLH_COMPILER_ONLY_FLAG) && !defined(__OCLH_LINKER_ONLY_FLAG)
                         _ghf_logWS_Hdr(wSet, "End of build log");
+#endif
                     }
                 }
                 if(pcVal) { free(pcVal); pcVal=NULL; }