IMP: Support for numbers inside 'mov' instructions (AMD64)

Signed-off-by: Amlal <amlal.elmahrouss@icloud.com>

13 files changed, 181 insertions, 173 deletions

diff --git a/dev/ToolchainKit/AAL/CPU/amd64.h b/dev/ToolchainKit/AAL/CPU/amd64.h
index d576af2..a69d517 100644
--- a/dev/ToolchainKit/AAL/CPU/amd64.h
+++ b/dev/ToolchainKit/AAL/CPU/amd64.h
@@ -39,18 +39,19 @@ struct CpuOpcodeAMD64
 
 inline std::vector<CpuOpcodeAMD64> kOpcodesAMD64 = {
 	kAsmOpcodeDecl("int", 0xCD)
-		kAsmOpcodeDecl("into", 0xCE)
-			kAsmOpcodeDecl("intd", 0xF1)
-				kAsmOpcodeDecl("int3", 0xC3)
-					kAsmOpcodeDecl("iret", 0xCF)
-						kAsmOpcodeDecl("retf", 0xCB)
-							kAsmOpcodeDecl("retn", 0xC3)
-								kAsmOpcodeDecl("ret", 0xC3)
-									kAsmOpcodeDecl("sti", 0xfb)
-										kAsmOpcodeDecl("cli", 0xfa)
-											kAsmOpcodeDecl("hlt", 0xf4)
-												kAsmOpcodeDecl("nop", 0x90)
-													kAsmOpcodeDecl("mov", 0x48)
-														kAsmOpcodeDecl("call", 0xFF)};
+	kAsmOpcodeDecl("into", 0xCE)
+	kAsmOpcodeDecl("intd", 0xF1)
+	kAsmOpcodeDecl("int3", 0xC3)
+	kAsmOpcodeDecl("iret", 0xCF)
+	kAsmOpcodeDecl("retf", 0xCB)
+	kAsmOpcodeDecl("retn", 0xC3)
+	kAsmOpcodeDecl("ret", 0xC3)
+	kAsmOpcodeDecl("sti", 0xfb)
+	kAsmOpcodeDecl("cli", 0xfa)
+	kAsmOpcodeDecl("hlt", 0xf4)
+	kAsmOpcodeDecl("nop", 0x90)
+	kAsmOpcodeDecl("mov", 0x48)
+	kAsmOpcodeDecl("call", 0xFF)}
+;
 
 #define kAsmRegisterLimit 15
diff --git a/dev/ToolchainKit/Defines.h b/dev/ToolchainKit/Defines.h
index 7ce9c9e..c41882e 100644
--- a/dev/ToolchainKit/Defines.h
+++ b/dev/ToolchainKit/Defines.h
@@ -15,6 +15,14 @@
 #define No false
 #endif // ifndef No
 
+#ifndef YES
+#define YES true
+#endif // ifndef YES
+
+#ifndef NO
+#define NO false
+#endif // ifndef NO
+
 #define SizeType size_t
 
 #define VoidPtr void*
@@ -85,6 +93,9 @@
 	KLASS& operator=(KLASS&&) = default; \
 	KLASS(KLASS&&)			  = default;
 
+#define TK_IMPORT_C extern "C"
+#define TK_IMPORT extern
+
 #include <ctime>
 #include <fstream>
 #include <string>
@@ -92,7 +103,7 @@
 
 namespace ToolchainKit
 {
-	inline constexpr int cBaseYear = 1900;
+	inline constexpr int kBaseYear = 1900;
 
 	typedef std::string String;
 
@@ -101,7 +112,7 @@ namespace ToolchainKit
 		auto time_data	 = time(nullptr);
 		auto time_struct = gmtime(&time_data);
 
-		String fmt = std::to_string(cBaseYear + time_struct->tm_year);
+		String fmt = std::to_string(kBaseYear + time_struct->tm_year);
 
 		fmt += "-";
 		fmt += std::to_string(time_struct->tm_mon + 1);
diff --git a/dev/ToolchainKit/NFC/PEF.h b/dev/ToolchainKit/NFC/PEF.h
index 2e8fc68..cef7bf7 100644
--- a/dev/ToolchainKit/NFC/PEF.h
+++ b/dev/ToolchainKit/NFC/PEF.h
@@ -14,9 +14,8 @@
 #define kPefMagic	 "Joy!"
 #define kPefMagicFat "yoJ!"
 
-/* not mandatory, only for non fork based filesystems */
-#define kPefExt		  ".exe"
-#define kPefDylibExt  ".dll"
+#define kPefExt		  ".o"
+#define kPefDylibExt  ".dylib"
 #define kPefLibExt	  ".lib"
 #define kPefObjectExt ".obj"
 #define kPefDebugExt  ".dbg"
@@ -58,17 +57,18 @@ namespace ToolchainKit
 	{
 		kPefSubArchAMD,
 		kPefSubArchIntel,
+		kPefSubArchARM,
 		kPefSubArchGeneric,
 		kPefSubArchIBM,
 	};
 
 	enum
 	{
-		kPefKindExec		 = 1, /* .exe */
-		kPefKindSharedObject = 2, /* .lib */
-		kPefKindObject		 = 4, /* .obj */
-		kPefKindDebug		 = 5, /* .dbg */
-		kPefKindDriver		 = 6,
+		kPefKindExec   = 1, /* .o */
+		kPefKindDylib  = 2, /* .dylib */
+		kPefKindObject = 4, /* .obj */
+		kPefKindDebug  = 5, /* .dbg */
+		kPefKindDriver = 6,
 		kPefKindCount,
 	};
 
diff --git a/dev/ToolchainKit/src/Assembler64x0.cc b/dev/ToolchainKit/src/Assembler64x0.cc
index 3873092..6dbcfbd 100644
--- a/dev/ToolchainKit/src/Assembler64x0.cc
+++ b/dev/ToolchainKit/src/Assembler64x0.cc
@@ -111,7 +111,7 @@ namespace detail
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-TOOLCHAINKIT_MODULE(ZKAAssemblerMain64000)
+TOOLCHAINKIT_MODULE(AssemblerMain64x0)
 {
 	for (size_t i = 1; i < argc; ++i)
 	{
diff --git a/dev/ToolchainKit/src/AssemblerAMD64.cc b/dev/ToolchainKit/src/AssemblerAMD64.cc
index 1dee916..21f0344 100644
--- a/dev/ToolchainKit/src/AssemblerAMD64.cc
+++ b/dev/ToolchainKit/src/AssemblerAMD64.cc
@@ -58,7 +58,7 @@ static Boolean kOutputAsBinary = false;
 static UInt32 kErrorLimit		= 10;
 static UInt32 kAcceptableErrors = 0;
 
-constexpr auto cAMD64IPAlignment = 0x4U;
+constexpr auto kIPAlignement = 0x4U;
 
 static std::size_t kCounter = 1UL;
 
@@ -93,7 +93,7 @@ static bool asm_read_attributes(std::string& line);
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-TOOLCHAINKIT_MODULE(ZKAAssemblerMainAMD64)
+TOOLCHAINKIT_MODULE(AssemblerAMD64)
 {
 	//////////////// CPU OPCODES BEGIN ////////////////
 
@@ -175,12 +175,14 @@ TOOLCHAINKIT_MODULE(ZKAAssemblerMainAMD64)
 		}
 
 		std::string object_output(argv[i]);
+		std::string asm_input(argv[i]);
 
 		for (auto& ext : kAsmFileExts)
 		{
-			if (object_output.find(ext) != std::string::npos)
+			if (object_output.ends_with(ext))
 			{
 				object_output.erase(object_output.find(ext), std::strlen(ext));
+				break;
 			}
 		}
 
@@ -195,6 +197,8 @@ TOOLCHAINKIT_MODULE(ZKAAssemblerMainAMD64)
 			{
 				kStdOut << "AssemblerAMD64: error: " << strerror(errno) << "\n";
 			}
+
+			return 1;
 		}
 
 		std::string line;
@@ -216,8 +220,15 @@ TOOLCHAINKIT_MODULE(ZKAAssemblerMainAMD64)
 
 		ToolchainKit::EncoderAMD64 asm64;
 
+		if (kVerbose)
+		{
+			kStdOut << "Compiling: " + asm_input << "\n";
+		}
+
 		while (std::getline(file_ptr, line))
 		{
+			kStdOut << "Compiling: " + line << "\n";
+
 			if (auto ln = asm64.CheckLine(line, argv[i]); !ln.empty())
 			{
 				detail::print_error_asm(ln, argv[i]);
@@ -1158,7 +1169,7 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 		i64_byte_t	fModRM;
 	};
 
-	std::vector<RegMapAMD64> REGISTER_LIST{
+	std::vector<RegMapAMD64> kRegisterList{
 		{.fName = "ax", .fModRM = 0x0},
 		{.fName = "cx", .fModRM = 1},
 		{.fName = "dx", .fModRM = 0x2},
@@ -1188,7 +1199,8 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 			std::string name(opcodeAMD64.fName);
 
 			/// Move instruction handler.
-			if (name.find("mov") != std::string::npos)
+			if (line.find(name) != std::string::npos &&
+				name == "mov")
 			{
 				std::string substr = line.substr(line.find(name) + name.size());
 
@@ -1196,7 +1208,7 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 
 				if (substr.find(",") == std::string::npos)
 				{
-					detail::print_error_asm("Syntax error.", "ToolchainKit");
+					detail::print_error_asm("Syntax error: missing right operand.", "ToolchainKit");
 					throw std::runtime_error("syntax_err");
 				}
 
@@ -1204,7 +1216,7 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 
 				std::vector<RegMapAMD64> currentRegList;
 
-				for (auto& reg : REGISTER_LIST)
+				for (auto& reg : kRegisterList)
 				{
 					std::vector<char> regExt = {'e', 'r'};
 
@@ -1273,7 +1285,8 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 						kAppBytes.emplace_back(opcodeAMD64.fOpcode);
 					}
 
-					kAppBytes.emplace_back(0x89);
+					if (!onlyOneReg)
+						kAppBytes.emplace_back(0x89);
 				}
 				else if (bits == 16)
 				{
@@ -1290,6 +1303,29 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 					}
 				}
 
+				if (onlyOneReg)
+				{
+					auto num = GetNumber32(line, ",");
+
+					for (auto& num_idx: num.number)
+					{
+						if (num_idx == 0)
+							num_idx = 0xFF;
+					}
+
+					auto modrm = (0x3 << 6 |
+								  currentRegList[0].fModRM);
+
+					kAppBytes.emplace_back(0xc7);
+					kAppBytes.emplace_back(modrm);
+					kAppBytes.emplace_back(num.number[0]);
+					kAppBytes.emplace_back(num.number[1]);
+					kAppBytes.emplace_back(num.number[2]);
+					kAppBytes.emplace_back(num.number[3]);
+
+					break;
+				}
+
 				if (currentRegList[1].fName[0] == 'r' &&
 					currentRegList[0].fName[0] == 'e')
 				{
@@ -1443,7 +1479,7 @@ bool ToolchainKit::EncoderAMD64::WriteLine(std::string&		 line,
 		this->WriteNumber16(line.find(".word") + strlen(".word") + 1, line);
 	}
 
-	kOrigin += cAMD64IPAlignment;
+	kOrigin += kIPAlignement;
 
 	return true;
 }
diff --git a/dev/ToolchainKit/src/AssemblerPower.cc b/dev/ToolchainKit/src/AssemblerPower.cc
index f32f6b6..519186c 100644
--- a/dev/ToolchainKit/src/AssemblerPower.cc
+++ b/dev/ToolchainKit/src/AssemblerPower.cc
@@ -81,7 +81,7 @@ static bool asm_read_attributes(std::string& line);
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-TOOLCHAINKIT_MODULE(ZKAAssemblerMainPowerPC)
+TOOLCHAINKIT_MODULE(AssemblerMainPower64)
 {
 	for (size_t i = 1; i < argc; ++i)
 	{
diff --git a/dev/ToolchainKit/src/AssemblyFactory.cc b/dev/ToolchainKit/src/AssemblyFactory.cc
index 71f12f9..1fffe3c 100644
--- a/dev/ToolchainKit/src/AssemblyFactory.cc
+++ b/dev/ToolchainKit/src/AssemblyFactory.cc
@@ -9,7 +9,7 @@
 
 /**
  * @file AssemblyFactory.cxx
- * @author amlal (amlal@zeta.com)
+ * @author amlal (amlal@zka.com)
  * @brief Assembler Kit
  * @version 0.1
  * @date 2024-01-27
diff --git a/dev/ToolchainKit/src/CCompilerPower64.cc b/dev/ToolchainKit/src/CCompilerPower64.cc
index 824f4ff..301f351 100644
--- a/dev/ToolchainKit/src/CCompilerPower64.cc
+++ b/dev/ToolchainKit/src/CCompilerPower64.cc
@@ -38,7 +38,7 @@
 
 /////////////////////////////////////
 
-/// INTERNAL STRUCT OF THE C COMPILER
+/// INTERNAL STRUCTURES OF THE C COMPILER
 
 /////////////////////////////////////
 
diff --git a/dev/ToolchainKit/src/CPlusPlusCompilerAMD64.cc b/dev/ToolchainKit/src/CPlusPlusCompilerAMD64.cc
index 55f8d12..349b056 100644
--- a/dev/ToolchainKit/src/CPlusPlusCompilerAMD64.cc
+++ b/dev/ToolchainKit/src/CPlusPlusCompilerAMD64.cc
@@ -735,7 +735,7 @@ ndk_compile_ok:
 /////////////////////////////////////////////////////////////////////////////////////////
 
 /**
- * @brief C To Assembly mount-point.
+ * @brief C++ assembler class.
  */
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -836,7 +836,7 @@ static void cxx_print_help()
 {
 	kSplashCxx();
 	kPrintF("%s", "No help available, see:\n");
-	kPrintF("%s", "www.zeta.com/developer/c++-drv\n");
+	kPrintF("%s", "www.zws.zka.com/help/c++lang\n");
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////
@@ -921,7 +921,7 @@ TOOLCHAINKIT_MODULE(CompilerCPlusPlusX8664)
 				continue;
 			}
 
-			if (strcmp(argv[index], "--cl:ver") == 0)
+			if (strcmp(argv[index], "--cl:version") == 0)
 			{
 				kSplashCxx();
 				return kExitOK;
@@ -934,7 +934,7 @@ TOOLCHAINKIT_MODULE(CompilerCPlusPlusX8664)
 				continue;
 			}
 
-			if (strcmp(argv[index], "--cl:?") == 0)
+			if (strcmp(argv[index], "--cl:h") == 0)
 			{
 				cxx_print_help();
 
diff --git a/dev/ToolchainKit/src/Detail/AsmUtils.h b/dev/ToolchainKit/src/Detail/AsmUtils.h
index 519c1fe..736598d 100644
--- a/dev/ToolchainKit/src/Detail/AsmUtils.h
+++ b/dev/ToolchainKit/src/Detail/AsmUtils.h
@@ -25,11 +25,6 @@ static NumberCast32 GetNumber32(std::string lineBuffer, std::string numberKey)
 {
 	auto pos = lineBuffer.find(numberKey) + numberKey.size();
 
-	if (lineBuffer.find(",") != std::string::npos)
-	{
-		lineBuffer.erase(lineBuffer.find(","), 1);
-	}
-
 	while (lineBuffer[pos] == ' ')
 	{
 		++pos;
diff --git a/dev/ToolchainKit/src/IdlCompiler.cc b/dev/ToolchainKit/src/IdlCompiler.cc
deleted file mode 100644
index 675b328..0000000
--- a/dev/ToolchainKit/src/IdlCompiler.cc
+++ /dev/null
@@ -1,33 +0,0 @@
-/* -------------------------------------------
-
-	Copyright ZKA Web Services Co
-
-	FILE: XIDL.cxx
-	PURPOSE: XPCOM IDL COMPILER.
-
-------------------------------------------- */
-
-#include <ToolchainKit/NFC/ErrorID.h>
-
-//! Assembler Kit
-#include <ToolchainKit/AAL/Asm.h>
-
-//! Preferred Executable Format
-#include <ToolchainKit/NFC/PEF.h>
-#include <ToolchainKit/UUID.h>
-
-//! Dist version
-#include <ToolchainKit/Version.h>
-
-//! Advanced Executable Object Format
-#include <ToolchainKit/NFC/AE.h>
-
-/***
-	@brief IDL compiler maih.
-*/
-
-TOOLCHAINKIT_MODULE(ZKAIdlMain)
-{
-
-	return 0;
-}
diff --git a/dev/ToolchainKit/src/Linker.cc b/dev/ToolchainKit/src/Linker.cc
index 0a0819d..b1f1fb5 100644
--- a/dev/ToolchainKit/src/Linker.cc
+++ b/dev/ToolchainKit/src/Linker.cc
@@ -63,7 +63,7 @@ static Bool		   kStartFound		 = false;
 static Bool		   kDuplicateSymbols = false;
 static Bool		   kVerbose			 = false;
 
-/* link is to be found, mld is to be found at runtime. */
+/* ld64 is to be found, mld is to be found at runtime. */
 static const char* kLdDefineSymbol = ":UndefinedSymbol:";
 static const char* kLdDynamicSym   = ":RuntimeSymbol:";
 
@@ -72,13 +72,14 @@ static std::vector<ToolchainKit::String> kObjectList;
 static std::vector<char>		kObjectBytes;
 
 static uintptr_t kMIBCount = 8;
+static uintptr_t kByteCount	= 1024;
 
 #define kPrintF			printf
 #define kLinkerSplash() kPrintF(kWhite kLinkerVersion, kDistVersion)
 
 ///	@brief ZKA 64-bit Linker.
 /// @note This linker is made for PEF executable, thus ZKA based OSes.
-TOOLCHAINKIT_MODULE(ZKALinkerMain)
+TOOLCHAINKIT_MODULE(Linker64Main)
 {
 	bool is_executable = true;
 
@@ -87,79 +88,79 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	 */
 	for (size_t linker_arg = 1;	linker_arg < argc; ++linker_arg)
 	{
-		if (StringCompare(argv[linker_arg], "--link:?") == 0)
+		if (StringCompare(argv[linker_arg], "--ld64:?") == 0)
 		{
 			kLinkerSplash();
 
-			kStdOut << "--link:ver: Show linker version.\n";
-			kStdOut << "--link:?: Show linker help.\n";
-			kStdOut << "--link:verbose: Enable linker trace.\n";
-			kStdOut << "--link:dll: Output as a shared PEF.\n";
-			kStdOut << "--link:fat: Output as a FAT PEF.\n";
-			kStdOut << "--link:32k: Output as a 32x0 PEF.\n";
-			kStdOut << "--link:64k: Output as a 64x0 PEF.\n";
-			kStdOut << "--link:amd64: Output as a AMD64 PEF.\n";
-			kStdOut << "--link:rv64: Output as a RISC-V PEF.\n";
-			kStdOut << "--link:power64: Output as a POWER PEF.\n";
-			kStdOut << "--link:arm64: Output as a ARM64 PEF.\n";
-			kStdOut << "--link:output: Select the output file name.\n";
+			kStdOut << "--ld64:ver: Show linker version.\n";
+			kStdOut << "--ld64:?: Show linker help.\n";
+			kStdOut << "--ld64:verbose: Enable linker trace.\n";
+			kStdOut << "--ld64:dylib: Output as a Dylib PEF.\n";
+			kStdOut << "--ld64:fat: Output as a FAT PEF.\n";
+			kStdOut << "--ld64:32k: Output as a 32x0 PEF.\n";
+			kStdOut << "--ld64:64k: Output as a 64x0 PEF.\n";
+			kStdOut << "--ld64:amd64: Output as a AMD64 PEF.\n";
+			kStdOut << "--ld64:rv64: Output as a RISC-V PEF.\n";
+			kStdOut << "--ld64:power64: Output as a POWER PEF.\n";
+			kStdOut << "--ld64:arm64: Output as a ARM64 PEF.\n";
+			kStdOut << "--ld64:output: Select the output file name.\n";
 
 			return 0;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:ver") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:ver") == 0)
 		{
 			kLinkerSplash();
 			return 0;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:fat-binary") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:fat-binary") == 0)
 		{
 			kFatBinaryEnable = true;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:64k") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:64k") == 0)
 		{
 			kArch = ToolchainKit::kPefArch64000;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:amd64") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:amd64") == 0)
 		{
 			kArch = ToolchainKit::kPefArchAMD64;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:32k") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:32k") == 0)
 		{
 			kArch = ToolchainKit::kPefArch32000;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:power64") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:power64") == 0)
 		{
 			kArch = ToolchainKit::kPefArchPowerPC;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:riscv64") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:riscv64") == 0)
 		{
 			kArch = ToolchainKit::kPefArchRISCV;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:arm64") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:arm64") == 0)
 		{
 			kArch = ToolchainKit::kPefArchARM64;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:verbose") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:verbose") == 0)
 		{
 			kVerbose = true;
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:dll") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:dylib") == 0)
 		{
 			if (kOutput.empty())
 			{
@@ -175,7 +176,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 
 			continue;
 		}
-		else if (StringCompare(argv[linker_arg], "--link:output") == 0)
+		else if (StringCompare(argv[linker_arg], "--ld64:output") == 0)
 		{
 			kOutput = argv[linker_arg + 1];
 			++linker_arg;
@@ -186,7 +187,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 		{
 			if (argv[linker_arg][0] == '-')
 			{
-				kStdOut << "link: unknown flag: " << argv[linker_arg] << "\n";
+				kStdOut << "ld64: unknown flag: " << argv[linker_arg] << "\n";
 				continue;
 			}
 
@@ -198,14 +199,14 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 
 	if (kOutput.empty())
 	{
-		kStdOut << "link: no output filename set." << std::endl;
+		kStdOut << "ld64: no output filename set." << std::endl;
 		return TOOLCHAINKIT_EXEC_ERROR;
 	}
 
 	// sanity check.
 	if (kObjectList.empty())
 	{
-		kStdOut << "link: no input files." << std::endl;
+		kStdOut << "ld64: no input files." << std::endl;
 		return TOOLCHAINKIT_EXEC_ERROR;
 	}
 	else
@@ -219,7 +220,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 			{
 				// if filesystem doesn't find file
 				//          -> throw error.
-				kStdOut << "link: no such file: " << obj << std::endl;
+				kStdOut << "ld64: no such file: " << obj << std::endl;
 				return TOOLCHAINKIT_EXEC_ERROR;
 			}
 		}
@@ -228,7 +229,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	// PEF expects a valid target architecture when outputing a binary.
 	if (kArch == 0)
 	{
-		kStdOut << "link: no target architecture set, can't continue." << std::endl;
+		kStdOut << "ld64: no target architecture set, can't continue." << std::endl;
 		return TOOLCHAINKIT_EXEC_ERROR;
 	}
 
@@ -237,7 +238,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	int32_t archs = kArch;
 
 	pef_container.Count	   = 0UL;
-	pef_container.Kind	   = ToolchainKit::kPefKindExec;
+	pef_container.Kind	   = is_executable ? ToolchainKit::kPefKindExec : ToolchainKit::kPefKindDylib;
 	pef_container.SubCpu   = kSubArch;
 	pef_container.Linker   = kLinkerId; // ZKA Web Services Co Linker
 	pef_container.Abi	   = kAbi;		// Multi-Processor UX ABI
@@ -257,7 +258,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	{
 		if (kVerbose)
 		{
-			kStdOut << "link: error: " << strerror(errno) << "\n";
+			kStdOut << "ld64: error: " << strerror(errno) << "\n";
 		}
 
 		return TOOLCHAINKIT_FILE_NOT_FOUND;
@@ -268,14 +269,14 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	std::vector<ToolchainKit::PEFCommandHeader> command_headers;
 	ToolchainKit::Utils::AEReadableProtocol	   readProto{};
 
-	for (const auto& i : kObjectList)
+	for (const auto& objectFile : kObjectList)
 	{
-		if (!std::filesystem::exists(i))
+		if (!std::filesystem::exists(objectFile))
 			continue;
 
 		ToolchainKit::AEHeader hdr{};
 
-		readProto.FP = std::ifstream(i, std::ifstream::binary);
+		readProto.FP = std::ifstream(objectFile, std::ifstream::binary);
 		readProto.FP >> hdr;
 
 		auto ae_header = hdr;
@@ -286,26 +287,25 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 			if (ae_header.fArch != kArch)
 			{
 				if (kVerbose)
-					kStdOut << "link: info: is this a FAT binary? : ";
+					kStdOut << "ld64: info: is this a FAT binary? : ";
 
 				if (!kFatBinaryEnable)
 				{
 					if (kVerbose)
 						kStdOut << "No.\n";
 
-					kStdOut << "link: error: object " << i
+					kStdOut << "ld64: error: object " << objectFile
 							<< " is a different kind of architecture and output isn't "
 							   "treated as a FAT binary."
 							<< std::endl;
 
-					std::remove(kOutput.c_str());
 					return TOOLCHAINKIT_FAT_ERROR;
 				}
 				else
 				{
 					if (kVerbose)
 					{
-						kStdOut << "Architecture matches.\n";
+						kStdOut << "Architecture matches what we expect.\n";
 					}
 				}
 			}
@@ -315,20 +315,22 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 			std::size_t cnt = ae_header.fCount;
 
 			if (kVerbose)
-				kStdOut << "link: object header found, record count: " << cnt << "\n";
+				kStdOut << "ld64: object header found, record count: " << cnt << "\n";
 
 			pef_container.Count = cnt;
 
 			char_type* raw_ae_records =
 				new char_type[cnt * sizeof(ToolchainKit::AERecordHeader)];
+
 			memset(raw_ae_records, 0, cnt * sizeof(ToolchainKit::AERecordHeader));
 
 			auto* ae_records = readProto.Read(raw_ae_records, cnt);
+
 			for (size_t ae_record_index = 0; ae_record_index < cnt;
 				 ++ae_record_index)
 			{
 				ToolchainKit::PEFCommandHeader command_header{0};
-				size_t				  offsetOfData = ae_records[ae_record_index].fOffset + ae_header.fSize;
+				size_t				  offset_of_obj = ae_records[ae_record_index].fOffset;
 
 				memcpy(command_header.Name, ae_records[ae_record_index].fName,
 					   kPefNameLen);
@@ -368,7 +370,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 				}
 
 			ld_mark_header:
-				command_header.Offset = offsetOfData;
+				command_header.Offset = offset_of_obj;
 				command_header.Kind	  = ae_records[ae_record_index].fKind;
 				command_header.Size	  = ae_records[ae_record_index].fSize;
 				command_header.Cpu	  = ae_header.fArch;
@@ -376,10 +378,10 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 
 				if (kVerbose)
 				{
-					kStdOut << "link: object record: "
-							<< ae_records[ae_record_index].fName << " was marked.\n";
+					kStdOut << "ld64: record: "
+							<< ae_records[ae_record_index].fName << " is marked.\n";
 
-					kStdOut << "link: object record offset: " << command_header.Offset << "\n";
+					kStdOut << "ld64: record offset: " << command_header.Offset << "\n";
 				}
 
 				command_headers.emplace_back(command_header);
@@ -405,9 +407,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 			continue;
 		}
 
-		kStdOut << "link: not an object: " << i << std::endl;
-		std::remove(kOutput.c_str());
-
+		kStdOut << "ld64: not an object file: " << objectFile << std::endl;
 		// don't continue, it is a fatal error.
 		return TOOLCHAINKIT_EXEC_ERROR;
 	}
@@ -418,7 +418,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 
 	if (kVerbose)
 	{
-		kStdOut << "link: wrote container header.\n";
+		kStdOut << "ld64: wrote container header.\n";
 	}
 
 	output_fc.seekp(std::streamsize(pef_container.HdrSz));
@@ -436,7 +436,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 			ToolchainKit::String(command_hdr.Name).find(kLdDynamicSym) == ToolchainKit::String::npos)
 		{
 			if (kVerbose)
-				kStdOut << "link: found undefined symbol: " << command_hdr.Name << "\n";
+				kStdOut << "ld64: found undefined symbol: " << command_hdr.Name << "\n";
 
 			if (auto it = std::find(not_found.begin(), not_found.end(),
 									ToolchainKit::String(command_hdr.Name));
@@ -493,7 +493,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 					not_found.erase(it);
 
 					if (kVerbose)
-						kStdOut << "link: found symbol: " << command_hdr.Name << "\n";
+						kStdOut << "ld64: found symbol: " << command_hdr.Name << "\n";
 
 					break;
 				}
@@ -510,32 +510,32 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	{
 		if (kVerbose)
 			kStdOut
-				<< "link: undefined entrypoint: " << kPefStart << ", you may have forget to link "
+				<< "ld64: undefined entrypoint: " << kPefStart << ", you may have forget to ld64 "
 																  "against your compiler's runtime library.\n";
 
-		kStdOut << "link: undefined entrypoint " << kPefStart
+		kStdOut << "ld64: undefined entrypoint " << kPefStart
 				<< " for executable: " << kOutput << "\n";
 	}
 
 	// step 4: write all PEF commands.
 
-	ToolchainKit::PEFCommandHeader dateHeader{};
+	ToolchainKit::PEFCommandHeader date_cmd_hdr{};
 
 	time_t timestamp = time(nullptr);
 
 	ToolchainKit::String timeStampStr = "Container:BuildEpoch:";
 	timeStampStr += std::to_string(timestamp);
 
-	strncpy(dateHeader.Name, timeStampStr.c_str(), timeStampStr.size());
+	strncpy(date_cmd_hdr.Name, timeStampStr.c_str(), timeStampStr.size());
 
-	dateHeader.Flags  = 0;
-	dateHeader.Kind	  = ToolchainKit::kPefZero;
-	dateHeader.Offset = output_fc.tellp();
-	dateHeader.Size	  = timeStampStr.size();
+	date_cmd_hdr.Flags  = 0;
+	date_cmd_hdr.Kind	  = ToolchainKit::kPefZero;
+	date_cmd_hdr.Offset = output_fc.tellp();
+	date_cmd_hdr.Size	  = timeStampStr.size();
 
-	command_headers.push_back(dateHeader);
+	command_headers.push_back(date_cmd_hdr);
 
-	ToolchainKit::PEFCommandHeader abiHeader{};
+	ToolchainKit::PEFCommandHeader abi_cmd_hdr{};
 
 	ToolchainKit::String abi = kLinkerAbiContainer;
 
@@ -551,7 +551,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	}
 	case ToolchainKit::kPefArch32000:
 	case ToolchainKit::kPefArch64000: {
-		abi += "MHRA";
+		abi += " ZWS";
 		break;
 	}
 	default: {
@@ -560,26 +560,26 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	}
 	}
 
-	memcpy(abiHeader.Name, abi.c_str(), abi.size());
+	memcpy(abi_cmd_hdr.Name, abi.c_str(), abi.size());
 
-	abiHeader.Size	 = abi.size();
-	abiHeader.Offset = output_fc.tellp();
-	abiHeader.Flags	 = 0;
-	abiHeader.Kind	 = ToolchainKit::kPefLinkerID;
+	abi_cmd_hdr.Size	 = abi.size();
+	abi_cmd_hdr.Offset = output_fc.tellp();
+	abi_cmd_hdr.Flags	 = 0;
+	abi_cmd_hdr.Kind	 = ToolchainKit::kPefLinkerID;
 
-	command_headers.push_back(abiHeader);
+	command_headers.push_back(abi_cmd_hdr);
 
-	ToolchainKit::PEFCommandHeader stackHeader{0};
+	ToolchainKit::PEFCommandHeader stack_cmd_hdr{0};
 
-	stackHeader.Cpu	   = kArch;
-	stackHeader.Flags  = 0;
-	stackHeader.Size   = sizeof(uintptr_t);
-	stackHeader.Offset = (kMIBCount * 1024 * 1024);
-	memcpy(stackHeader.Name, kLinkerStackSizeSymbol, strlen(kLinkerStackSizeSymbol));
+	stack_cmd_hdr.Cpu	   = kArch;
+	stack_cmd_hdr.Flags  = 0;
+	stack_cmd_hdr.Size   = sizeof(uintptr_t);
+	stack_cmd_hdr.Offset = (kMIBCount * kByteCount * kByteCount);
+	memcpy(stack_cmd_hdr.Name, kLinkerStackSizeSymbol, strlen(kLinkerStackSizeSymbol));
 
-	command_headers.push_back(stackHeader);
+	command_headers.push_back(stack_cmd_hdr);
 
-	ToolchainKit::PEFCommandHeader uuidHeader{};
+	ToolchainKit::PEFCommandHeader uuid_cmd_hdr{};
 
 	std::random_device rd;
 
@@ -592,16 +592,16 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	uuids::uuid id		= gen();
 	auto		uuidStr = uuids::to_string(id);
 
-	memcpy(uuidHeader.Name, "Container:GUID:4:", strlen("Container:GUID:4:"));
-	memcpy(uuidHeader.Name + strlen("Container:GUID:4:"), uuidStr.c_str(),
+	memcpy(uuid_cmd_hdr.Name, "Container:GUID:4:", strlen("Container:GUID:4:"));
+	memcpy(uuid_cmd_hdr.Name + strlen("Container:GUID:4:"), uuidStr.c_str(),
 		   uuidStr.size());
 
-	uuidHeader.Size	  = strlen(uuidHeader.Name);
-	uuidHeader.Offset = output_fc.tellp();
-	uuidHeader.Flags  = ToolchainKit::kPefLinkerID;
-	uuidHeader.Kind	  = ToolchainKit::kPefZero;
+	uuid_cmd_hdr.Size	  = strlen(uuid_cmd_hdr.Name);
+	uuid_cmd_hdr.Offset = output_fc.tellp();
+	uuid_cmd_hdr.Flags  = ToolchainKit::kPefLinkerID;
+	uuid_cmd_hdr.Kind	  = ToolchainKit::kPefZero;
 
-	command_headers.push_back(uuidHeader);
+	command_headers.push_back(uuid_cmd_hdr);
 
 	// prepare a symbol vector.
 	std::vector<ToolchainKit::String> undef_symbols;
@@ -655,8 +655,8 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 
 		if (kVerbose)
 		{
-			kStdOut << "link: command header name: " << name << "\n";
-			kStdOut << "link: real address of command header content: " << command_headers[commandHeaderIndex].Offset << "\n";
+			kStdOut << "ld64: command header name: " << name << "\n";
+			kStdOut << "ld64: real address of command header content: " << command_headers[commandHeaderIndex].Offset << "\n";
 		}
 
 		output_fc << command_headers[commandHeaderIndex];
@@ -675,7 +675,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 			{
 				if (kVerbose)
 				{
-					kStdOut << "link: ignore :UndefinedSymbol: command header...\n";
+					kStdOut << "ld64: ignore :UndefinedSymbol: command header...\n";
 				}
 
 				// ignore :UndefinedSymbol: headers, they do not contain code.
@@ -694,7 +694,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 				}
 
 				if (kVerbose)
-					kStdOut << "link: found duplicate symbol: " << command_hdr.Name
+					kStdOut << "ld64: found duplicate symbol: " << command_hdr.Name
 							<< "\n";
 
 				kDuplicateSymbols = true;
@@ -706,10 +706,9 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	{
 		for (auto& symbol : dupl_symbols)
 		{
-			kStdOut << "link: multiple symbols of " << symbol << ".\n";
+			kStdOut << "ld64: multiple symbols of " << symbol << ".\n";
 		}
 
-		std::remove(kOutput.c_str());
 		return TOOLCHAINKIT_EXEC_ERROR;
 	}
 
@@ -721,7 +720,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	}
 
 	if (kVerbose)
-		kStdOut << "link: wrote contents of: " << kOutput << "\n";
+		kStdOut << "ld64: wrote contents of: " << kOutput << "\n";
 
 	// step 3: check if we have those symbols
 
@@ -741,7 +740,7 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 	{
 		for (auto& unreferenced_symbol : unreferenced_symbols)
 		{
-			kStdOut << "link: undefined symbol " << unreferenced_symbol << "\n";
+			kStdOut << "ld64: undefined symbol " << unreferenced_symbol << "\n";
 		}
 	}
 
@@ -749,10 +748,9 @@ TOOLCHAINKIT_MODULE(ZKALinkerMain)
 		!unreferenced_symbols.empty())
 	{
 		if (kVerbose)
-			kStdOut << "link: file: " << kOutput
+			kStdOut << "ld64: file: " << kOutput
 					<< ", is corrupt, removing file...\n";
 
-		std::remove(kOutput.c_str());
 		return TOOLCHAINKIT_EXEC_ERROR;
 	}
 
diff --git a/dev/ToolchainKit/src/String.cc b/dev/ToolchainKit/src/String.cc
index 34e309f..4a31bbd 100644
--- a/dev/ToolchainKit/src/String.cc
+++ b/dev/ToolchainKit/src/String.cc
@@ -136,7 +136,7 @@ namespace ToolchainKit
 
 				for (auto y_idx = 0; y_idx < res_len; ++y_idx)
 				{
-					ret[y_idxcnt] = result[result_idx];
+					ret[y_idx] = result[result_cnt];
 					++result_cnt;
 				}