initial commit

[ROCm/clr commit: 3694ab2ce8]

projects/clr/rocclr/runtime/device/hsa/hsabinary.cpp

@@ -0,0 +1,152 @@
+//
+// Copyright (c) 2009 Advanced Micro Devices, Inc. All rights reserved.
+//
+
+
+#ifndef WITHOUT_FSA_BACKEND
+
+
+#include "hsabinary.hpp"
+#include "hsaprogram.hpp"
+#include "hsakernel.hpp"
+#include "utils/options.hpp"
+#include "os/os.hpp"
+#include <string>
+#include <sstream>
+
+
+
+namespace oclhsa {
+    /*
+bool
+ClBinary::loadKernels(FSAILProgram& program, NameKernelMap &kernels)
+{
+    return true;
+
+ 
+    const char _kernel[] = "_kernel";
+    const char __FSA_[] = "__FSA_";
+    const char _header[] = "_header";
+    const char _fsail[] = "_fsail";
+    bool hasKernels = false;
+
+    // TODO : jugu
+    // Target should be 15 bit maximum. Should check this somewhere.
+    uint32_t    target = static_cast<uint32_t>(21);//dev().calTarget());
+    uint16_t elf_target;
+    amd::OclElf::oclElfPlatform platform;
+    if (!elfIn()->getTarget(elf_target, platform) ||
+        (platform != amd::OclElf::CAL_PLATFORM)     ||
+        ((uint32_t)target != elf_target)) {
+        // warning !
+        // LogError("The OCL binary image loading failed: different target");
+
+        // LHOWES TODO: target in kannan's elf is wrong so skip this for now
+        // We may want a special HSA target or a similar more substantial change.
+       // return false;
+    }
+
+    for (amd::Sym_Handle sym = elfIn()->nextSymbol(NULL);
+         sym != NULL;
+         sym = elfIn()->nextSymbol(sym)) {
+        amd::OclElf::SymbolInfo symInfo;
+        if (!elfIn()->getSymbolInfo(sym, &symInfo)) {
+            LogError("LoadKernelFromElf: getSymbolInfo() fails");
+            return false;
+        }
+
+        std::string elfSymName(symInfo.sym_name);
+
+        const size_t offset = sizeof(__FSA_) - 1;
+        if (elfSymName.compare(0, offset, __FSA_) != 0) {
+            continue;
+        }
+
+        // Assume this elfSymName is associated with a kernel name. The folloiwng code will adjust
+        // If it isn't.
+        const size_t suffixPos = elfSymName.rfind('_');
+        bool isKernel = true;  // assume it is a kernel
+        std::string functionName = elfSymName.substr(sizeof(__FSA_)-1, suffixPos-(sizeof(__FSA_)-1));
+        //"__OpenCL_";
+        //functionName.append(elfSymName.substr(sizeof(__FSA_)-1, suffixPos-(sizeof(__FSA_)-1)));
+        //functionName.append("_kernel");  // make the kernel's linkage name
+
+        // Find kernel in map and get its kernel representation
+        NameKernelMap::iterator searchIterator = kernels.find(functionName);
+        Kernel *currentKernel = 0;
+        if( searchIterator == kernels.end() ) {
+            // TODO: note, this will need to be decided on based on the the device type. As we have no CPU yet...
+            //currentKernel = new Kernel(functionName);
+            //kernels[functionName] = currentKernel;
+        } else {
+            currentKernel = static_cast<oclhsa::Kernel*>(searchIterator->second);
+        }
+
+
+        // Add info for this elf symbol into tempobj's functionNameMap[]
+        if (elfSymName.compare(suffixPos, sizeof(_fsail) - 1, _fsail) == 0) {
+            
+            assert (currentKernel->hasFSAIL() &&
+                    "More than one fsail symbol for a kernel");
+            // LHOWES TODO: Currently this is using the section address and size because 
+            // we only have a single kernel and there is a bug in the current AMP compiler.
+            // Kannan is working on fixing this and once we have the symbol address and size 
+            // correct in the metadata then we can change this and it'll work properly for
+            // multiple kernels.
+            std::string options("");
+            std::string fsailString(symInfo.sec_addr, symInfo.sec_addr + symInfo.sec_size);
+            currentKernel->setFSAIL(fsailString);
+            //currentKernel->compile(options);
+            
+        }
+
+
+        // LHOWES
+        // Hack to assume that this is the AMP path for now
+        // until we have kernel metadata we need a way to generate the parameter list.
+        {
+            device::Kernel::parameters_t parameterList;
+            // Is AMP code
+
+            amd::KernelParameterDescriptor  desc;
+            desc.name_      = "Functor";
+            desc.type_      = T_POINTER;
+
+            desc.size_      = sizeof(void*);
+            desc.offset_    = 0;
+
+            // BKENDALL HACK
+            desc.typeName_   = "";
+            desc.typeQualifier_ = 0;
+            desc.accessQualifier_ = 0;
+            desc.addressQualifier_ = 0;
+            // !BKENDALL HACK
+
+            parameterList.push_back(desc);
+           // oclhsa OpenCL integration	
+      }
+
+        hasKernels = true;
+    }
+    
+
+    return hasKernels;
+
+}
+    */
+/*
+bool
+ClBinary::clearElfOut()
+{
+    // Recreate libelf elf object
+    if (!elfOut()->Clear()) {
+        return false;
+    }
+
+    // Need to re-setup target
+    return setElfTarget();
+}
+*/
+} // namespace oclhsa
+
+#endif // WITHOUT_FSA_BACKEND