IGA fix for Fedora build and several code cleanup

DianaChen · igcbot · commit 0add92f4b1eb · 2021-08-25T00:39:38.000+02:00
- Fix build break on Fedora
- Improved the iga::FixupPath
- Fix possible nullptr
- Minor fix for send decoder
diff --git a/visa/iga/IGAExe/io.hpp b/visa/iga/IGAExe/io.hpp
@@ -13,14 +13,15 @@ SPDX-License-Identifier: MIT
 #include <fstream>
 #include <iostream>
 #include <locale>
+#include <string>
 #include <vector>
 
 #include "fatal.hpp"
 #include "system.hpp"
 
 
 static inline void readBinaryStream(
-    const char *streamName,
+    const std::string &streamName,
     std::istream &is,
     std::vector<unsigned char> &bin)
 {
@@ -33,7 +34,8 @@ static inline void readBinaryStream(
         }
         bin.push_back((char)chr);
     }
-    fatalExitWithMessage(streamName, ": error reading ");
+    fatalExitWithMessage(
+        streamName, ": error reading  (", iga::LastErrorString(), ")");
 }
 
 #define IGA_STDIN_FILENAME std::string("std::cin")
@@ -47,84 +49,91 @@ static inline std::vector<unsigned char> readBinaryStreamStdin()
 }
 
 static inline void readBinaryFile(
-    const char *fileName, std::vector<unsigned char> &bin)
+    const std::string &fileName, std::vector<unsigned char> &bin)
 {
     std::ifstream is(fileName, std::ios::binary);
-    if (!is.is_open()) {
-        fatalExitWithMessage(fileName, ": failed to open file");
+    if (!is.good()) {
+        fatalExitWithMessage(
+            fileName, ": failed to open file (", iga::LastErrorString(), ")");
     }
     readBinaryStream(fileName, is, bin);
 }
 
 static inline std::string readTextStream(
-    const char *streamName,
+    const std::string &streamName,
     std::istream &is)
 {
     std::string s;
     is.clear();
     s.append(std::istreambuf_iterator<char>(is),
              std::istreambuf_iterator<char>());
     if (!is.good()) {
-        fatalExitWithMessage(streamName, ": error reading");
+        fatalExitWithMessage(
+            streamName, ": error reading (", iga::LastErrorString(), ")");
     }
     return s;
 }
 
-static inline std::string readTextFile(
-    const char *fileName)
+static inline std::string readTextFile(const std::string &fileName)
 {
     std::ifstream file(fileName);
     if (!file.good()) {
-        fatalExitWithMessage(fileName, ": failed to open file");
+        fatalExitWithMessage(
+            fileName, ": failed to open file (", iga::LastErrorString(), ")");
     }
-    return readTextStream(fileName,file);
+    return readTextStream(fileName, file);
 }
 
 static inline void writeTextStream(
-    const char *streamName, std::ostream &os, const char *output)
+    const std::string &streamName, std::ostream &os, const char *output)
 {
     os.clear();
     os << output;
     if (!os.good()) {
-        fatalExitWithMessage(streamName, ": error writing");
+        fatalExitWithMessage(
+            streamName, ": error writing (", iga::LastErrorString(), ")");
     }
 }
 
-static inline void writeTextFile(const char *fileName, const char *output)
+static inline void writeTextFile(
+    const std::string &fileName, const char *output)
 {
     std::ofstream file(fileName);
     if (!file.good()) {
-        fatalExitWithMessage(fileName, ": failed to open file");
+        fatalExitWithMessage(
+            fileName, ": failed to open file (", iga::LastErrorString(), ")");
     }
     writeTextStream(fileName, file, output);
 }
 
 static inline void writeBinaryStream(
-    const char *streamName,
+    const std::string &streamName,
     std::ostream &os,
     const void *bits,
     size_t bitsLen)
 {
     os.clear();
     os.write((const char *)bits, bitsLen);
     if (!os.good()) {
-        fatalExitWithMessage(streamName, ": error writing stream");
+        fatalExitWithMessage(
+            streamName, ": error writing stream (", iga::LastErrorString(), ")");
     }
 }
 
 static inline void writeBinaryFile(
-  const char *fileName,
-  const void *bits,
-  size_t bitsLen)
+    const std::string &fileName,
+    const void *bits,
+    size_t bitsLen)
 {
-    std::ofstream file(fileName,std::ios::binary);
+    std::ofstream file(fileName, std::ios::binary);
     if (!file.good()) {
-        fatalExitWithMessage(fileName, ": failed to open file");
+        fatalExitWithMessage(
+            fileName, ": failed to open file (", iga::LastErrorString(), ")");
     }
-    writeBinaryStream(fileName,file,bits,bitsLen);
+    writeBinaryStream(fileName, file, bits, bitsLen);
 }
 
-static inline bool doesFileExist(const char *fileName) {
+static inline bool doesFileExist(const std::string &fileName) {
     return iga::DoesFileExist(fileName);
 }
 
diff --git a/visa/iga/IGALibrary/IR/RegDeps.cpp b/visa/iga/IGALibrary/IR/RegDeps.cpp
@@ -10,9 +10,9 @@ SPDX-License-Identifier: MIT
 #include "../asserts.hpp"
 #include "../bits.hpp"
 
+#include <cstring>
 #include <limits>
 #include <sstream>
-#include <cstring>
 
 using namespace iga;
 
diff --git a/visa/iga/IGALibrary/api/kv.cpp b/visa/iga/IGALibrary/api/kv.cpp
@@ -365,6 +365,7 @@ uint32_t kv_get_send_descs(
     return n;
 }
 
+
 void kv_get_send_indirect_descs(
     const kv_t *kv, int32_t pc,
     uint8_t *ex_desc_reg, uint8_t *ex_desc_subreg,
@@ -396,6 +397,7 @@ void kv_get_send_indirect_descs(
     }
 }
 
+
 /******************** KernelView analysis APIs *******************************/
 static const Instruction *getInstruction(const kv_t *kv, int32_t pc)
 {
diff --git a/visa/iga/IGALibrary/api/kv.h b/visa/iga/IGALibrary/api/kv.h
@@ -212,6 +212,13 @@ IGA_API uint32_t kv_get_send_descs(
     uint32_t *ex_desc,
     uint32_t *desc);
 
+
+/*
+ * Returns the indirect descriptor registers for a send message.
+ * The function fails silently if the PC is invalid or a nullptr is passed.
+ * Registers are assigned KV_INVALID_REG on other failures otherwise they
+ * hold the index register and subregister (e.g. a0.2) would have 0 and 2.
+ */
 IGA_API void kv_get_send_indirect_descs(
     const kv_t *kv,
     int32_t pc,
diff --git a/visa/iga/IGALibrary/api/kv.hpp b/visa/iga/IGALibrary/api/kv.hpp
@@ -279,13 +279,23 @@ class KernelView
         return kv_get_send_descs(m_kv, pc, ex_desc, desc);
     }
 
+
     /*************************Analysis APIs **********************************/
 
     // Returns the number of expicit sources this instruction has.
     int32_t getNumberOfSources(int32_t pc) const {
         return kv_get_number_sources(m_kv, pc);
     }
 
+    // Determines if the given send instruction is on ExBSO mode.
+    // Return 1 if true, 0 if false
+    // Return -1 if not success
+    int32_t getSendExBso(int32_t pc) const {
+        int32_t exbso = -1;
+        if (kv_get_send_exbso(m_kv, pc, &exbso) != kv_status_t::KV_SUCCESS)
+            return -1;
+        return exbso;
+    }
 
     // Fetches the message type for send/sends instructions.
     //
diff --git a/visa/iga/IGALibrary/system.cpp b/visa/iga/IGALibrary/system.cpp
@@ -6,6 +6,7 @@ SPDX-License-Identifier: MIT
 
 ============================= end_copyright_notice ===========================*/
 
+#include "asserts.hpp"
 #include "system.hpp"
 
 #ifdef _WIN32
@@ -23,8 +24,14 @@ SPDX-License-Identifier: MIT
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
+#include <errno.h>
+#include <string.h> // strerror_r
 #endif
+#include <algorithm>
 #include <iostream>
+#include <sstream>
+#include <string>
+#include <vector>
 
 using namespace iga;
 
@@ -94,15 +101,15 @@ void iga::SetStdinBinary()
 #endif
 }
 
-bool iga::DoesFileExist(const char *path)
+bool iga::DoesFileExist(const std::string &path)
 {
 #ifdef _WIN32
-    DWORD dwAttrib = GetFileAttributesA(path);
+    DWORD dwAttrib = GetFileAttributesA(path.c_str());
     return (dwAttrib != INVALID_FILE_ATTRIBUTES &&
         !(dwAttrib & FILE_ATTRIBUTE_DIRECTORY));
 #else
     struct stat sb = {0};
-    if (stat(path, &sb) != 0) {
+    if (stat(path.c_str(), &sb) != 0) {
         return false;
     }
     return S_ISREG(sb.st_mode);
@@ -225,3 +232,112 @@ void iga::EmitYellowText(std::ostream &os, const std::string &s) {
     StreamColorSetter scs(os, StreamColorSetter::YELLOW);
     os << s;
 }
+
+unsigned iga::LastError()
+{
+#ifdef _WIN32
+    return (unsigned)GetLastError();
+#else
+    return (unsigned)errno;
+#endif // _WIN32
+}
+
+std::string iga::FormatLastError(unsigned errCode)
+{
+    std::string msg;
+    char buf[256] {0};
+    char *errMsg = nullptr;
+#ifdef _WIN32
+    errMsg = &buf[0];
+    FormatMessageA(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+        NULL,
+        errCode,
+        0,
+        (LPTSTR)&errMsg,
+        sizeof(buf),
+        NULL);
+    if (errMsg)
+        msg = errMsg;
+#else
+    errMsg = strerror_r(errCode, buf, sizeof(buf));
+#endif // _WIN32
+    if (errMsg == nullptr || errMsg[0] == 0)
+        return "???";
+    return std::string(errMsg);
+}
+
+std::string iga::FixupPath(const std::string &path)
+{
+#ifdef _WIN32
+    // Windows paths can be a mess due to the 260 MAX_PATH limit.
+    // This fails in the guts on the Windows path expansion (of .) and
+    // normalization of path component separates (/ to \) etc.
+    // (You'd experience std::ofstream to just fail to open a file.)
+    // We work around this here by normalizing and expanding the path to an
+    // absolute path.
+    //
+    // The approach here is to expand the path to a normalized absolute path.
+    // This is a bit pesky because GetFullPathNameA is limited to 260 chars.
+    // So we must use GetFullPathNameW. We will.
+    //  0. manually replace / with \
+    //  1. convert the path to absolute using GetFullPathNameW
+    //     (GetFullPathNameA is still limited to 260)
+    //  2. convert back to UTF-8
+    //  3. prefix a \\?\ so that CreateFile (under std::ofstream) won't
+    //     attempt to expand any relative components and choke due to length.
+    //
+    // If someone can come up with something better please let me know.
+    if (path.substr(0, 2) == "\\\\") {
+        // Network or UNC path (e.g. \\?\...) can be ignored...
+        return path;
+    }
+
+    std::string noSlashes = path;
+    std::replace(noSlashes.begin(), noSlashes.end(), '/', '\\');
+    const char *pathCstr = noSlashes.c_str();
+    auto retMbtwc = MultiByteToWideChar(CP_ACP, 0, pathCstr, -1, nullptr, 0);
+    if (retMbtwc <= 0) {
+        auto err = GetLastError();
+        std::stringstream ess;
+        ess << "iga::FixupPath:MultiByteToWideChar: " << err;
+        IGA_FATAL(ess.str().c_str());
+    }
+    std::vector<wchar_t> wPath;
+    wPath.resize(retMbtwc);
+    MultiByteToWideChar(
+        CP_ACP, 0, pathCstr, -1, wPath.data(), (int)wPath.size());
+
+    std::wstring absPathW;
+    wchar_t wbuf[256];
+    auto retGfpn = GetFullPathNameW(
+        wPath.data(),
+        (unsigned)sizeof(wbuf)/sizeof(wbuf[0]) - 1, wbuf, nullptr);
+    if (retGfpn == 0) {
+        auto err = GetLastError();
+        std::stringstream ess;
+        ess << "iga::FixupPath:GetFullPathNameW: " << err;
+        IGA_FATAL(ess.str().c_str());
+        return "";
+    } else if (retGfpn >= sizeof(wbuf)/sizeof(wbuf[0]) - 1) {
+        std::vector<wchar_t> vec;
+        vec.resize(retGfpn + 1);
+        retGfpn = GetFullPathNameW(
+            wPath.data(),  (unsigned)vec.size() - 1, vec.data(), nullptr);
+        absPathW = vec.data();
+    } else {
+        absPathW = wbuf;
+    }
+    int sizeNeeded = WideCharToMultiByte(
+        CP_ACP, 0, &absPathW[0], (int)absPathW.size(),
+        NULL, 0, NULL, NULL);
+    std::string absPathA(sizeNeeded, 0);
+    WideCharToMultiByte(
+        CP_ACP, 0, &absPathW[0], (int)absPathW.size(),
+        &absPathA[0], sizeNeeded, NULL, NULL);
+    absPathA = "\\\\?\\" + absPathA;
+    return absPathA;
+#else
+    return path;
+#endif // _WIN32
+}
diff --git a/visa/iga/IGALibrary/system.hpp b/visa/iga/IGALibrary/system.hpp
@@ -22,14 +22,23 @@ namespace iga
 
     // bool LookupEnvironmentVariable(const char *key, std::string &value);
     // bool IsDirectory(const char *path);
-    bool DoesFileExist(const char *path);
+    bool DoesFileExist(const std::string &path);
 
     // For older Windows console compatibility
     void EmitRedText(std::ostream &os, const std::string &s);
     void EmitGreenText(std::ostream &os, const std::string &s);
     void EmitYellowText(std::ostream &os, const std::string &s);
 
     bool DebuggerAttached();
+
+    // maps to GetLastError() or errno
+    unsigned LastError();
+    std::string FormatLastError(unsigned);
+    static inline std::string LastErrorString() {return FormatLastError(LastError());}
+
+    // deals with large Windows paths on Windows platforms
+    // identity function on other platforms
+    std::string FixupPath(const std::string &path);
 }
 
 #endif // SYSTEM_HPP

Original file line number	Diff line number	Diff line change
`@@ -13,14 +13,15 @@ SPDX-License-Identifier: MIT`
`13`	`13`	`#include <fstream>`
`14`	`14`	`#include <iostream>`
`15`	`15`	`#include <locale>`
	`16`	`+#include <string>`
`16`	`17`	`#include <vector>`
`17`	`18`
`18`	`19`	`#include "fatal.hpp"`
`19`	`20`	`#include "system.hpp"`
`20`	`21`
`21`	`22`
`22`	`23`	`static inline void readBinaryStream(`
`23`		`- const char *streamName,`
	`24`	`+ const std::string &streamName,`
`24`	`25`	`std::istream &is,`
`25`	`26`	`std::vector<unsigned char> &bin)`
`26`	`27`	`{`
`@@ -33,7 +34,8 @@ static inline void readBinaryStream(`
`33`	`34`	`}`
`34`	`35`	`bin.push_back((char)chr);`
`35`	`36`	`}`
`36`		`- fatalExitWithMessage(streamName, ": error reading ");`
	`37`	`+ fatalExitWithMessage(`
	`38`	`+ streamName, ": error reading (", iga::LastErrorString(), ")");`
`37`	`39`	`}`
`38`	`40`
`39`	`41`	`#define IGA_STDIN_FILENAME std::string("std::cin")`
`@@ -47,84 +49,91 @@ static inline std::vector<unsigned char> readBinaryStreamStdin()`
`47`	`49`	`}`
`48`	`50`
`49`	`51`	`static inline void readBinaryFile(`
`50`		`- const char *fileName, std::vector<unsigned char> &bin)`
	`52`	`+ const std::string &fileName, std::vector<unsigned char> &bin)`
`51`	`53`	`{`
`52`	`54`	`std::ifstream is(fileName, std::ios::binary);`
`53`		`- if (!is.is_open()) {`
`54`		`- fatalExitWithMessage(fileName, ": failed to open file");`
	`55`	`+ if (!is.good()) {`
	`56`	`+ fatalExitWithMessage(`
	`57`	`+ fileName, ": failed to open file (", iga::LastErrorString(), ")");`
`55`	`58`	`}`
`56`	`59`	`readBinaryStream(fileName, is, bin);`
`57`	`60`	`}`
`58`	`61`
`59`	`62`	`static inline std::string readTextStream(`
`60`		`- const char *streamName,`
	`63`	`+ const std::string &streamName,`
`61`	`64`	`std::istream &is)`
`62`	`65`	`{`
`63`	`66`	`std::string s;`
`64`	`67`	`is.clear();`
`65`	`68`	`s.append(std::istreambuf_iterator<char>(is),`
`66`	`69`	`std::istreambuf_iterator<char>());`
`67`	`70`	`if (!is.good()) {`
`68`		`- fatalExitWithMessage(streamName, ": error reading");`
	`71`	`+ fatalExitWithMessage(`
	`72`	`+ streamName, ": error reading (", iga::LastErrorString(), ")");`
`69`	`73`	`}`
`70`	`74`	`return s;`
`71`	`75`	`}`
`72`	`76`
`73`		`-static inline std::string readTextFile(`
`74`		`- const char *fileName)`
	`77`	`+static inline std::string readTextFile(const std::string &fileName)`
`75`	`78`	`{`
`76`	`79`	`std::ifstream file(fileName);`
`77`	`80`	`if (!file.good()) {`
`78`		`- fatalExitWithMessage(fileName, ": failed to open file");`
	`81`	`+ fatalExitWithMessage(`
	`82`	`+ fileName, ": failed to open file (", iga::LastErrorString(), ")");`
`79`	`83`	`}`
`80`		`- return readTextStream(fileName,file);`
	`84`	`+ return readTextStream(fileName, file);`
`81`	`85`	`}`
`82`	`86`
`83`	`87`	`static inline void writeTextStream(`
`84`		`- const char streamName, std::ostream &os, const char output)`
	`88`	`+ const std::string &streamName, std::ostream &os, const char *output)`
`85`	`89`	`{`
`86`	`90`	`os.clear();`
`87`	`91`	`os << output;`
`88`	`92`	`if (!os.good()) {`
`89`		`- fatalExitWithMessage(streamName, ": error writing");`
	`93`	`+ fatalExitWithMessage(`
	`94`	`+ streamName, ": error writing (", iga::LastErrorString(), ")");`
`90`	`95`	`}`
`91`	`96`	`}`
`92`	`97`
`93`		`-static inline void writeTextFile(const char fileName, const char output)`
	`98`	`+static inline void writeTextFile(`
	`99`	`+ const std::string &fileName, const char *output)`
`94`	`100`	`{`
`95`	`101`	`std::ofstream file(fileName);`
`96`	`102`	`if (!file.good()) {`
`97`		`- fatalExitWithMessage(fileName, ": failed to open file");`
	`103`	`+ fatalExitWithMessage(`
	`104`	`+ fileName, ": failed to open file (", iga::LastErrorString(), ")");`
`98`	`105`	`}`
`99`	`106`	`writeTextStream(fileName, file, output);`
`100`	`107`	`}`
`101`	`108`
`102`	`109`	`static inline void writeBinaryStream(`
`103`		`- const char *streamName,`
	`110`	`+ const std::string &streamName,`
`104`	`111`	`std::ostream &os,`
`105`	`112`	`const void *bits,`
`106`	`113`	`size_t bitsLen)`
`107`	`114`	`{`
`108`	`115`	`os.clear();`
`109`	`116`	`os.write((const char *)bits, bitsLen);`
`110`	`117`	`if (!os.good()) {`
`111`		`- fatalExitWithMessage(streamName, ": error writing stream");`
	`118`	`+ fatalExitWithMessage(`
	`119`	`+ streamName, ": error writing stream (", iga::LastErrorString(), ")");`
`112`	`120`	`}`
`113`	`121`	`}`
`114`	`122`
`115`	`123`	`static inline void writeBinaryFile(`
`116`		`- const char *fileName,`
`117`		`- const void *bits,`
`118`		`- size_t bitsLen)`
	`124`	`+ const std::string &fileName,`
	`125`	`+ const void *bits,`
	`126`	`+ size_t bitsLen)`
`119`	`127`	`{`
`120`		`- std::ofstream file(fileName,std::ios::binary);`
	`128`	`+ std::ofstream file(fileName, std::ios::binary);`
`121`	`129`	`if (!file.good()) {`
`122`		`- fatalExitWithMessage(fileName, ": failed to open file");`
	`130`	`+ fatalExitWithMessage(`
	`131`	`+ fileName, ": failed to open file (", iga::LastErrorString(), ")");`
`123`	`132`	`}`
`124`		`- writeBinaryStream(fileName,file,bits,bitsLen);`
	`133`	`+ writeBinaryStream(fileName, file, bits, bitsLen);`
`125`	`134`	`}`
`126`	`135`
`127`		`-static inline bool doesFileExist(const char *fileName) {`
	`136`	`+static inline bool doesFileExist(const std::string &fileName) {`
`128`	`137`	`return iga::DoesFileExist(fileName);`
`129`	`138`	`}`
`130`	`139`
Original file line number	Diff line number	Diff line change
`@@ -365,6 +365,7 @@ uint32_t kv_get_send_descs(`
`365`	`365`	`return n;`
`366`	`366`	`}`
`367`	`367`
	`368`	`+`
`368`	`369`	`void kv_get_send_indirect_descs(`
`369`	`370`	`const kv_t *kv, int32_t pc,`
`370`	`371`	`uint8_t ex_desc_reg, uint8_t ex_desc_subreg,`
`@@ -396,6 +397,7 @@ void kv_get_send_indirect_descs(`
`396`	`397`	`}`
`397`	`398`	`}`
`398`	`399`
	`400`	`+`
`399`	`401`	`/****************** KernelView analysis APIs *****************************/`
`400`	`402`	`static const Instruction getInstruction(const kv_t kv, int32_t pc)`
`401`	`403`	`{`