diff --git a/0001-Pin-gcc-client-BugFix-for-SwitchOp-change-it-to-term.patch b/0001-Pin-gcc-client-BugFix-for-SwitchOp-change-it-to-term.patch new file mode 100644 index 0000000000000000000000000000000000000000..e970d88dc09203b38dc82e01df242fc0acaa4da0 --- /dev/null +++ b/0001-Pin-gcc-client-BugFix-for-SwitchOp-change-it-to-term.patch @@ -0,0 +1,74 @@ +From 3206b8e596cedaa6cf00532b21f609649179908f Mon Sep 17 00:00:00 2001 +From: huitailangzju <804544223@qq.com> +Date: Mon, 27 Feb 2023 10:00:05 +0800 +Subject: [PATCH 1/6] [Pin-gcc-client] BugFix for SwitchOp, change it to + terminator operation + + +diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td +index 0b5a138..71a1441 100644 +--- a/include/Dialect/PluginOps.td ++++ b/include/Dialect/PluginOps.td +@@ -484,29 +484,6 @@ def AsmOp : Plugin_Op<"asm", [NoSideEffect]> { + }]; + } + +-def SwitchOp : Plugin_Op<"switch", [NoSideEffect]> { +- let summary = "switch op."; +- let description = [{TODO}]; +- let successors = (successor +- AnySuccessor:$defaultDestination, +- VariadicSuccessor:$caseDestinations +- ); +- let arguments = (ins UI64Attr:$id, AnyType:$index, UI64Attr:$address, AnyType:$defaultLabel, Variadic:$operands, +- UI64Attr:$defaultaddr, ArrayAttr:$caseaddrs); +- let results = (outs AnyType:$result); +- let builders = [ +- OpBuilderDAG<(ins "uint64_t":$id, "Value":$index, "uint64_t":$address, "Value":$defaultLabel, +- "ArrayRef":$operands, "Block*":$defaultDestination, "uint64_t":$defaultaddr, +- "ArrayRef":$caseDestinations, "ArrayRef":$caseaddrs)> +- ]; +- +- let extraClassDeclaration = [{ +- unsigned GetNumLabels() { return getNumOperands() - 2; }; +- Block* GetDefautDest() { return defaultDestination();} +- SmallVector GetCaseDest() { return caseDestinations(); }; +- }]; +-} +- + def LabelOp : Plugin_Op<"label", [NoSideEffect]> { + let summary = "Label op."; + let description = [{TODO}]; +@@ -575,6 +552,29 @@ def CatchOp : Plugin_Op<"catch", [NoSideEffect]> { + class Plugin_TerminatorOp traits = []> : + Plugin_Op; + ++def SwitchOp : Plugin_TerminatorOp<"switch", [NoSideEffect]> { ++ let summary = "switch op."; ++ let description = [{TODO}]; ++ let successors = (successor ++ AnySuccessor:$defaultDestination, ++ VariadicSuccessor:$caseDestinations ++ ); ++ let arguments = (ins UI64Attr:$id, AnyType:$index, UI64Attr:$address, AnyType:$defaultLabel, Variadic:$operands, ++ UI64Attr:$defaultaddr, ArrayAttr:$caseaddrs); ++ let results = (outs AnyType:$result); ++ let builders = [ ++ OpBuilderDAG<(ins "uint64_t":$id, "Value":$index, "uint64_t":$address, "Value":$defaultLabel, ++ "ArrayRef":$operands, "Block*":$defaultDestination, "uint64_t":$defaultaddr, ++ "ArrayRef":$caseDestinations, "ArrayRef":$caseaddrs)> ++ ]; ++ ++ let extraClassDeclaration = [{ ++ unsigned GetNumLabels() { return getNumOperands() - 2; }; ++ Block* GetDefautDest() { return defaultDestination();} ++ SmallVector GetCaseDest() { return caseDestinations(); }; ++ }]; ++} ++ + def FallThroughOp : Plugin_TerminatorOp<"fallthrough", [NoSideEffect]> { + let summary = "FallThroughOp"; + let description = [{TODO}]; +-- +2.33.0 + diff --git a/0002-Pin-gcc-client-Bugfix-for-GetFunctionById.patch b/0002-Pin-gcc-client-Bugfix-for-GetFunctionById.patch new file mode 100644 index 0000000000000000000000000000000000000000..c7810f0ed3e78cc467ee4d0e96c0907251571ec4 --- /dev/null +++ b/0002-Pin-gcc-client-Bugfix-for-GetFunctionById.patch @@ -0,0 +1,282 @@ +From 01a71df9866c4871d68e77f7307107d4e191264c Mon Sep 17 00:00:00 2001 +From: Mingchuan Wu +Date: Mon, 27 Feb 2023 16:21:41 +0800 +Subject: [PATCH 2/6] [Pin-gcc-client] Bugfix for GetFunctionById. + + +diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h +index ca74588..981964b 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -55,6 +55,8 @@ public: + virtual uint64_t GetImmediateDominator(uint64_t, uint64_t) = 0; + virtual uint64_t RecomputeDominator(uint64_t, uint64_t) = 0; + virtual vector GetAllFunc() = 0; ++ virtual vector GetFunctions() = 0; ++ virtual FunctionOp GetFunctionOpById(uint64_t) = 0; + virtual vector GetDecls(uint64_t funcID) = 0; + virtual vector GetLoopsFromFunc(uint64_t) = 0; + virtual LoopOp GetLoopById(uint64_t) = 0; +diff --git a/include/PluginAPI/PluginClientAPI.h b/include/PluginAPI/PluginClientAPI.h +index 727d329..d69baff 100644 +--- a/include/PluginAPI/PluginClientAPI.h ++++ b/include/PluginAPI/PluginClientAPI.h +@@ -46,6 +46,8 @@ public: + uint64_t RecomputeDominator(uint64_t, uint64_t) override; + + vector GetAllFunc() override; ++ vector GetFunctions() override; ++ FunctionOp GetFunctionOpById(uint64_t) override; + vector GetDecls(uint64_t funcID) override; + vector GetLoopsFromFunc(uint64_t) override; + LoopOp GetLoopById(uint64_t) override; +diff --git a/include/PluginClient/PluginJson.h b/include/PluginClient/PluginJson.h +index 54517fd..d4e48af 100755 +--- a/include/PluginClient/PluginJson.h ++++ b/include/PluginClient/PluginJson.h +@@ -40,7 +40,7 @@ public: + void OpJsonSerialize(vector& data, string& out); + void LoopOpsJsonSerialize(vector& loops, string& out); + void LoopOpJsonSerialize(mlir::Plugin::LoopOp& loop, string& out); +- void BlocksJsonSerialize(vector&, string&); ++ void IDsJsonSerialize(vector&, string&); + void EdgesJsonSerialize(vector >&, string&); + void EdgeJsonSerialize(std::pair&, string&); + void NopJsonSerialize(string&); +diff --git a/include/Translate/GimpleToPluginOps.h b/include/Translate/GimpleToPluginOps.h +index 59896fa..0928ece 100644 +--- a/include/Translate/GimpleToPluginOps.h ++++ b/include/Translate/GimpleToPluginOps.h +@@ -61,6 +61,8 @@ public: + uint64_t GetImmediateDominator(uint64_t, uint64_t); + uint64_t RecomputeDominator(uint64_t, uint64_t); + vector GetAllFunction(); ++ vector GetFunctionIDs(); ++ mlir::Plugin::FunctionOp GetFunctionById(uint64_t); + vector GetAllDecls(uint64_t); + vector GetAllLoops(uint64_t); + LoopOp GetLoop(uint64_t); +diff --git a/lib/PluginAPI/PluginClientAPI.cpp b/lib/PluginAPI/PluginClientAPI.cpp +index 362ede1..3623091 100644 +--- a/lib/PluginAPI/PluginClientAPI.cpp ++++ b/lib/PluginAPI/PluginClientAPI.cpp +@@ -76,6 +76,16 @@ vector PluginClientAPI::GetAllFunc() + return gimpleConversion.GetAllFunction(); + } + ++vector PluginClientAPI::GetFunctions() ++{ ++ return gimpleConversion.GetFunctionIDs(); ++} ++ ++FunctionOp PluginClientAPI::GetFunctionOpById(uint64_t id) ++{ ++ return gimpleConversion.GetFunctionById(id); ++} ++ + vector PluginClientAPI::GetDecls(uint64_t funcID) + { + return gimpleConversion.GetAllDecls(funcID); +diff --git a/lib/PluginClient/PluginClient.cpp b/lib/PluginClient/PluginClient.cpp +index 81b59c0..937f6e1 100644 +--- a/lib/PluginClient/PluginClient.cpp ++++ b/lib/PluginClient/PluginClient.cpp +@@ -107,6 +107,33 @@ void GetAllFuncResult(PluginClient *client, Json::Value& root, string& result) + client->ReceiveSendMsg("FuncOpResult", result); + } + ++void GetFunctionIDsResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ // Load our Dialect in this MLIR Context. ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ vector ids = clientAPI.GetFunctions(); ++ PluginJson json = client->GetJson(); ++ json.IDsJsonSerialize(ids, result); ++ client->ReceiveSendMsg("IdsResult", result); ++} ++ ++void GetFunctionOpByIdResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ // Load our Dialect in this MLIR Context. ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string funcIdKey = "id"; ++ uint64_t funcID = atol(root[funcIdKey].asString().c_str()); ++ vector allFuncOps; ++ allFuncOps.push_back(clientAPI.GetFunctionOpById(funcID)); ++ PluginJson json = client->GetJson(); ++ json.FunctionOpJsonSerialize(allFuncOps, result); ++ client->ReceiveSendMsg("FuncOpResult", result); ++} ++ + void GetLocalDeclsResult(PluginClient *client, Json::Value& root, string& result) + { + /// Json格式 +@@ -280,9 +307,9 @@ void GetBlocksInLoopResult(PluginClient *client, Json::Value& root, string& resu + PluginAPI::PluginClientAPI clientAPI(context); + std::string loopIdKey = "loopId"; + uint64_t loopId = atol(root[loopIdKey].asString().c_str()); +- vector blocks = clientAPI.GetBlocksInLoop(loopId); ++ vector blockIDs = clientAPI.GetBlocksInLoop(loopId); + PluginJson json = client->GetJson(); +- json.BlocksJsonSerialize(blocks, result); ++ json.IDsJsonSerialize(blockIDs, result); + client->ReceiveSendMsg("IdsResult", result); + } + +@@ -841,6 +868,8 @@ void IsWholeProgramResult(PluginClient *client, Json::Value& root, string& resul + typedef std::function GetResultFunc; + std::map g_getResultFunc = { + {"GetAllFunc", GetAllFuncResult}, ++ {"GetFunctionIDs", GetFunctionIDsResult}, ++ {"GetFunctionOpById", GetFunctionOpByIdResult}, + {"GetLocalDecls", GetLocalDeclsResult}, + {"GetLoopsFromFunc", GetLoopsFromFuncResult}, + {"GetLoopById", GetLoopByIdResult}, +diff --git a/lib/PluginClient/PluginInputCheck.cpp b/lib/PluginClient/PluginInputCheck.cpp +index 12cfcdc..4d17e0a 100755 +--- a/lib/PluginClient/PluginInputCheck.cpp ++++ b/lib/PluginClient/PluginInputCheck.cpp +@@ -43,7 +43,6 @@ bool PluginInputCheck::ReadConfigfile(Json::Value& root) + Json::Reader reader; + std::ifstream ifs(configFilePath.c_str()); + if (!ifs.is_open()) { +- LOGW("open %s fail! use default sha256file:%s\n", configFilePath.c_str(), shaPath.c_str()); + return false; + } + +@@ -92,12 +91,14 @@ int PluginInputCheck::GetInitInfo() + if (root[jsonkey[TIMEOUT]].isInt()) { + int timeoutJson = root[jsonkey[TIMEOUT]].asInt(); + SetTimeout(timeoutJson); ++ } else { ++ LOGW("timeout in config.json is not int or out of int range!use default:%d\n", timeout); + } + + if (root[jsonkey[SHA256]].isString()) { + shaPath = root[jsonkey[SHA256]].asString(); + } else { +- LOGW("sha256file int config.json is not string!\n"); ++ LOGW("sha256file in config.json is not string!\n"); + } + + if ((shaPath == "") || (CheckShaFile() != 0)) { +diff --git a/lib/PluginClient/PluginJson.cpp b/lib/PluginClient/PluginJson.cpp +index cf09d86..388efc9 100755 +--- a/lib/PluginClient/PluginJson.cpp ++++ b/lib/PluginClient/PluginJson.cpp +@@ -401,16 +401,16 @@ void PluginJson::LoopOpJsonSerialize(mlir::Plugin::LoopOp& loop, string& out) + out = root.toStyledString(); + } + +-void PluginJson::BlocksJsonSerialize(vector& blocks, string& out) ++void PluginJson::IDsJsonSerialize(vector& ids, string& out) + { + Json::Value root; + Json::Value item; + int i = 0; + string index; + +- for (auto& block : blocks) { +- item["id"] = std::to_string(block); +- index = "block" + std::to_string(i++); ++ for (auto& id : ids) { ++ item["id"] = std::to_string(id); ++ index = "ID" + std::to_string(i++); + root[index] = item; + item.clear(); + } +diff --git a/lib/Translate/GimpleToPluginOps.cpp b/lib/Translate/GimpleToPluginOps.cpp +index 4f59aab..0bb4416 100644 +--- a/lib/Translate/GimpleToPluginOps.cpp ++++ b/lib/Translate/GimpleToPluginOps.cpp +@@ -330,6 +330,28 @@ vector GimpleToPluginOps::GetAllFunction() + return functions; + } + ++vector GimpleToPluginOps::GetFunctionIDs() ++{ ++ cgraph_node *node = NULL; ++ function *fn = NULL; ++ vector functions; ++ FOR_EACH_FUNCTION (node) { ++ fn = DECL_STRUCT_FUNCTION(node->decl); ++ if (fn == NULL) ++ continue; ++ int64_t id = reinterpret_cast(reinterpret_cast(fn)); ++ functions.push_back(id); ++ } ++ return functions; ++} ++ ++FunctionOp GimpleToPluginOps::GetFunctionById(uint64_t id) ++{ ++ FunctionOp irFunc = BuildFunctionOp(id); ++ builder.setInsertionPointAfter(irFunc.getOperation()); ++ return irFunc; ++} ++ + vector GimpleToPluginOps::GetAllDecls(uint64_t funcID) + { + function *fn = reinterpret_cast(funcID); +@@ -934,20 +956,20 @@ AsmOp GimpleToPluginOps::BuildAsmOp(uint64_t gasmId) + uint32_t nOuputs = gimple_asm_noutputs(stmt); + uint32_t nClobbers = gimple_asm_nclobbers(stmt); + +- for (int i = 0; i < nInputs; i++) { ++ for (size_t i = 0; i < nInputs; i++) { + uint64_t input = reinterpret_cast( + reinterpret_cast(gimple_asm_input_op(stmt, i))); + Value tett = TreeToValue(input); + ops.push_back(tett); + } + +- for (int i = 0; i < nOuputs; i++) { ++ for (size_t i = 0; i < nOuputs; i++) { + uint64_t input = reinterpret_cast( + reinterpret_cast(gimple_asm_output_op(stmt, i))); + ops.push_back(TreeToValue(input)); + } + +- for (int i = 0; i < nClobbers; i++) { ++ for (size_t i = 0; i < nClobbers; i++) { + uint64_t input = reinterpret_cast( + reinterpret_cast(gimple_asm_clobber_op(stmt, i))); + ops.push_back(TreeToValue(input)); +@@ -972,7 +994,7 @@ SwitchOp GimpleToPluginOps::BuildSwitchOp(uint64_t gswitchId) + Value defaultLabel = TreeToValue(sDefault); + + unsigned nLabels = gimple_switch_num_labels(stmt); +- for (int i = 1; i < nLabels; i++) { ++ for (size_t i = 1; i < nLabels; i++) { + uint64_t input = reinterpret_cast( + reinterpret_cast(gimple_switch_label(stmt, i))); + ops.push_back(TreeToValue(input)); +@@ -983,7 +1005,7 @@ SwitchOp GimpleToPluginOps::BuildSwitchOp(uint64_t gswitchId) + llvm::SmallVector caseaddr; + + push_cfun(fn); +- for (int i = 1; i < nLabels; i++) { ++ for (size_t i = 1; i < nLabels; i++) { + basic_block label_bb = gimple_switch_label_bb (cfun, stmt, i); + Block *temp = bbTranslator->blockMaps[label_bb]; + caseaddr.push_back((uint64_t)label_bb); +diff --git a/lib/Translate/TypeTranslation.cpp b/lib/Translate/TypeTranslation.cpp +index f332130..458d5a3 100644 +--- a/lib/Translate/TypeTranslation.cpp ++++ b/lib/Translate/TypeTranslation.cpp +@@ -148,7 +148,7 @@ private: + StringRef name; + for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) + { +- if (TREE_CODE (field) == FIELD_DECL) ++ if (TREE_CODE (field) == FIELD_DECL && DECL_NAME(field)) + { + name = IDENTIFIER_POINTER ( DECL_NAME(field)); + names.push_back(name); +-- +2.33.0 + diff --git a/0003-Pin-gcc-client-Init-a-SimpleIPAPASS.patch b/0003-Pin-gcc-client-Init-a-SimpleIPAPASS.patch new file mode 100644 index 0000000000000000000000000000000000000000..32c2d7f388d19b28c76e914e7b2d3dd9b44870eb --- /dev/null +++ b/0003-Pin-gcc-client-Init-a-SimpleIPAPASS.patch @@ -0,0 +1,57 @@ +From afcc34cc338c59a66132f152e1bdd5e841ab7eca Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Tue, 28 Feb 2023 21:10:06 +0800 +Subject: [PATCH 3/6] [Pin-gcc-client] Init a SimpleIPAPASS + + +diff --git a/include/PluginClient/PluginClient.h b/include/PluginClient/PluginClient.h +index 89d7573..2b5648c 100644 +--- a/include/PluginClient/PluginClient.h ++++ b/include/PluginClient/PluginClient.h +@@ -117,6 +117,7 @@ enum RefPassName { + PASS_PHIOPT, + PASS_SSA, + PASS_LOOP, ++ PASS_MAC, + }; + + enum PassPosition { +diff --git a/lib/gccPlugin/gccPlugin.cpp b/lib/gccPlugin/gccPlugin.cpp +index 103d709..1877651 100755 +--- a/lib/gccPlugin/gccPlugin.cpp ++++ b/lib/gccPlugin/gccPlugin.cpp +@@ -159,11 +159,11 @@ public: + SimpleIPAPass(pass_data passData, unsigned int indx): simple_ipa_opt_pass(passData, g), index(indx) + { + } +- /* unsigned int execute(function *fun) override ++ unsigned int execute(function *fun) override + { + ManagerSetupCallback(index, fun); + return 0; +- } */ ++ } + + private: + unsigned int index; +@@ -193,6 +193,7 @@ static std::map g_refPassName { + {PASS_PHIOPT, "phiopt"}, + {PASS_SSA, "ssa"}, + {PASS_LOOP, "loop"}, ++ {PASS_MAC, "materialize-all-clones"}, + }; + + void RegisterPassManagerSetup(unsigned int index, const ManagerSetupData& setupData, const string& pluginName) +@@ -231,6 +232,9 @@ void RegisterPassManagerSetup(unsigned int index, const ManagerSetupData& setupD + passData.type = GIMPLE_PASS; + passInfo.pass = new GimplePass(passData, index); + break; ++ case PASS_MAC: ++ passData.type = SIMPLE_IPA_PASS; ++ passInfo.pass = new SimpleIPAPass(passData, index); + default: + passInfo.pass = new GimplePass(passData, index); + break; +-- +2.33.0 + diff --git a/0004-Pin-gcc-client-Add-CGnodeOp.patch b/0004-Pin-gcc-client-Add-CGnodeOp.patch new file mode 100644 index 0000000000000000000000000000000000000000..967cc45503a7da53cc2f457b54e4b3e5a66cfcdf --- /dev/null +++ b/0004-Pin-gcc-client-Add-CGnodeOp.patch @@ -0,0 +1,308 @@ +From 8d80ef3e9d0fc535694cca23d4d29c7d3f9b1e23 Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Fri, 3 Mar 2023 10:51:04 +0800 +Subject: [PATCH 4/6] [Pin-gcc-client] Add CGnodeOp + + +diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td +index 79d73d0..143a856 100644 +--- a/include/Dialect/PluginOps.td ++++ b/include/Dialect/PluginOps.td +@@ -24,6 +24,29 @@ include "PluginDialect.td" + include "mlir/Interfaces/SideEffectInterfaces.td" + include "mlir/Interfaces/CallInterfaces.td" + ++def CGnodeOp : Plugin_Op<"callgraphnode", [NoSideEffect]> { ++ let summary = "callgraph node operation"; ++ let description = [{ ++ TODO. ++ }]; ++ ++ let arguments = (ins UI64Attr:$id, ++ StrAttr:$symbolName, ++ OptionalAttr:$definition, ++ UI32Attr:$order); ++ let regions = (region AnyRegion:$bodyRegion); ++ ++ // Add custom build methods for the operation. These method populates ++ // the `state` that MLIR uses to create operations, i.e. these are used when ++ // using `builder.create(...)`. ++ let builders = [ ++ OpBuilderDAG<(ins "uint64_t":$id, ++ "StringRef":$symbolName, ++ "bool":$definition, ++ "uint32_t":$order)> ++ ]; ++} ++ + def FunctionOp : Plugin_Op<"function", [NoSideEffect]> { + let summary = "function with a region"; + let description = [{ +diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h +index 981964b..6e66d08 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -49,6 +49,10 @@ public: + virtual int GetDeclSourceLine(uint64_t gccDataAddr) = 0; + virtual int GetDeclSourceColumn(uint64_t gccDataAddr) = 0; + ++ // CGnode ++ virtual vector GetCGnodeIDs() = 0; ++ virtual CGnodeOp GetCGnodeOpById(uint64_t) = 0; ++ + virtual uint64_t CreateBlock(uint64_t, uint64_t) = 0; + virtual void DeleteBlock(uint64_t, uint64_t) = 0; + virtual void SetImmediateDominator(uint64_t, uint64_t, uint64_t) = 0; +diff --git a/include/PluginAPI/PluginClientAPI.h b/include/PluginAPI/PluginClientAPI.h +index d69baff..1970f1e 100644 +--- a/include/PluginAPI/PluginClientAPI.h ++++ b/include/PluginAPI/PluginClientAPI.h +@@ -45,6 +45,11 @@ public: + uint64_t GetImmediateDominator(uint64_t, uint64_t) override; + uint64_t RecomputeDominator(uint64_t, uint64_t) override; + ++ // CGnode ++ vector GetCGnodeIDs() override; ++ CGnodeOp GetCGnodeOpById(uint64_t) override; ++ bool IsRealSymbolOfCGnode(uint64_t); ++ + vector GetAllFunc() override; + vector GetFunctions() override; + FunctionOp GetFunctionOpById(uint64_t) override; +diff --git a/include/PluginClient/PluginJson.h b/include/PluginClient/PluginJson.h +index d4e48af..3f7813e 100755 +--- a/include/PluginClient/PluginJson.h ++++ b/include/PluginClient/PluginJson.h +@@ -37,6 +37,9 @@ using std::vector; + + class PluginJson { + public: ++ // CGnodeOp ++ void CGnodeOpJsonSerialize(mlir::Plugin::CGnodeOp& cgnode, string& out); ++ + void OpJsonSerialize(vector& data, string& out); + void LoopOpsJsonSerialize(vector& loops, string& out); + void LoopOpJsonSerialize(mlir::Plugin::LoopOp& loop, string& out); +diff --git a/include/Translate/GimpleToPluginOps.h b/include/Translate/GimpleToPluginOps.h +index 0928ece..3c7aba2 100644 +--- a/include/Translate/GimpleToPluginOps.h ++++ b/include/Translate/GimpleToPluginOps.h +@@ -60,6 +60,13 @@ public: + void SetImmediateDominator(uint64_t, uint64_t, uint64_t); + uint64_t GetImmediateDominator(uint64_t, uint64_t); + uint64_t RecomputeDominator(uint64_t, uint64_t); ++ ++ // CGnode ++ vector GetCGnodeIDs(); ++ mlir::Plugin::CGnodeOp GetCGnodeOpById(uint64_t); ++ CGnodeOp BuildCGnodeOp(uint64_t); ++ bool IsRealSymbolOfCGnode(uint64_t); ++ + vector GetAllFunction(); + vector GetFunctionIDs(); + mlir::Plugin::FunctionOp GetFunctionById(uint64_t); +diff --git a/lib/Dialect/PluginOps.cpp b/lib/Dialect/PluginOps.cpp +index 058a0e6..cf1dbbe 100644 +--- a/lib/Dialect/PluginOps.cpp ++++ b/lib/Dialect/PluginOps.cpp +@@ -33,6 +33,21 @@ + using namespace mlir; + using namespace mlir::Plugin; + ++// CGnodeOp =================== ++ ++void CGnodeOp::build(OpBuilder &builder, OperationState &state, ++ uint64_t id, StringRef symbolName, bool definition, ++ uint32_t order) ++{ ++ state.addRegion(); ++ state.addAttribute("id", builder.getI64IntegerAttr(id)); ++ state.addAttribute("symbolName", builder.getStringAttr(symbolName)); ++ state.addAttribute("definition", builder.getBoolAttr(definition)); ++ state.addAttribute("order", builder.getI32IntegerAttr(order)); ++} ++ ++// ============================ ++ + void FunctionOp::build(OpBuilder &builder, OperationState &state, + uint64_t id, StringRef funcName, bool declaredInline, Type type) + { +diff --git a/lib/PluginAPI/PluginClientAPI.cpp b/lib/PluginAPI/PluginClientAPI.cpp +index 3623091..5194d29 100644 +--- a/lib/PluginAPI/PluginClientAPI.cpp ++++ b/lib/PluginAPI/PluginClientAPI.cpp +@@ -71,6 +71,22 @@ uint64_t PluginClientAPI::RecomputeDominator(uint64_t dir, uint64_t bbAddr) + return gimpleConversion.RecomputeDominator(dir, bbAddr); + } + ++// CGnode ++vector PluginClientAPI::GetCGnodeIDs() ++{ ++ return gimpleConversion.GetCGnodeIDs(); ++} ++ ++CGnodeOp PluginClientAPI::GetCGnodeOpById(uint64_t id) ++{ ++ return gimpleConversion.GetCGnodeOpById(id); ++} ++ ++bool PluginClientAPI::IsRealSymbolOfCGnode(uint64_t id) ++{ ++ return gimpleConversion.IsRealSymbolOfCGnode(id); ++} ++ + vector PluginClientAPI::GetAllFunc() + { + return gimpleConversion.GetAllFunction(); +diff --git a/lib/PluginClient/PluginClient.cpp b/lib/PluginClient/PluginClient.cpp +index 937f6e1..310366d 100644 +--- a/lib/PluginClient/PluginClient.cpp ++++ b/lib/PluginClient/PluginClient.cpp +@@ -95,6 +95,48 @@ void PluginClient::GetGccData(const string& funcName, const string& param, strin + } + } + ++// CGnode ============ ++ ++void GetCGnodeIDsResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ // Load our Dialect in this MLIR Context. ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ vector ids = clientAPI.GetCGnodeIDs(); ++ PluginJson json = client->GetJson(); ++ json.IDsJsonSerialize(ids, result); ++ client->ReceiveSendMsg("IdsResult", result); ++} ++ ++void GetCGnodeOpByIdResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ // Load our Dialect in this MLIR Context. ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string funcIdKey = "id"; ++ uint64_t cgnodeID = atol(root[funcIdKey].asString().c_str()); ++ CGnodeOp cgnodeOp = clientAPI.GetCGnodeOpById(cgnodeID); ++ PluginJson json = client->GetJson(); ++ json.CGnodeOpJsonSerialize(cgnodeOp, result); ++ client->ReceiveSendMsg("CGnodeOpResult", result); ++} ++ ++void IsRealSymbolOfCGnodeResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ // Load our Dialect in this MLIR Context. ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string funcIdKey = "id"; ++ uint64_t cgnodeID = atol(root[funcIdKey].asString().c_str()); ++ bool realsymbol = clientAPI.IsRealSymbolOfCGnode(cgnodeID); ++ client->ReceiveSendMsg("BoolResult", std::to_string(realsymbol)); ++} ++ ++// =================== ++ + void GetAllFuncResult(PluginClient *client, Json::Value& root, string& result) + { + // Load our Dialect in this MLIR Context. +@@ -867,6 +909,9 @@ void IsWholeProgramResult(PluginClient *client, Json::Value& root, string& resul + + typedef std::function GetResultFunc; + std::map g_getResultFunc = { ++ {"GetCGnodeIDs", GetCGnodeIDsResult}, ++ {"GetCGnodeOpById", GetCGnodeOpByIdResult}, ++ {"IsRealSymbolOfCGnode", IsRealSymbolOfCGnodeResult}, + {"GetAllFunc", GetAllFuncResult}, + {"GetFunctionIDs", GetFunctionIDsResult}, + {"GetFunctionOpById", GetFunctionOpByIdResult}, +diff --git a/lib/PluginClient/PluginJson.cpp b/lib/PluginClient/PluginJson.cpp +index 388efc9..40590b2 100755 +--- a/lib/PluginClient/PluginJson.cpp ++++ b/lib/PluginClient/PluginJson.cpp +@@ -195,6 +195,24 @@ PluginIR::PluginTypeBase PluginJson::TypeJsonDeSerialize(const string& data, mli + return baseType; + } + ++void PluginJson::CGnodeOpJsonSerialize(CGnodeOp& cgnode, string& out) ++{ ++ Json::Value root; ++ Json::Value operationObj; ++ Json::Value item; ++ ++ root["id"] = std::to_string(cgnode.idAttr().getInt()); ++ root["attributes"]["order"] = std::to_string(cgnode.orderAttr().getInt()); ++ if (cgnode.definitionAttr().getValue()) { ++ root["attributes"]["definition"] = "1"; ++ }else { ++ root["attributes"]["definition"] = "0"; ++ } ++ root["attributes"]["symbolName"] = cgnode.symbolNameAttr().getValue().str().c_str(); ++ fprintf(stderr, "dgy client cgnode json %s\n", root.toStyledString().c_str()); ++ out = root.toStyledString(); ++} ++ + void PluginJson::FunctionOpJsonSerialize(vector& data, string& out) + { + Json::Value root; +diff --git a/lib/Translate/GimpleToPluginOps.cpp b/lib/Translate/GimpleToPluginOps.cpp +index 0bb4416..230fc1e 100644 +--- a/lib/Translate/GimpleToPluginOps.cpp ++++ b/lib/Translate/GimpleToPluginOps.cpp +@@ -313,6 +313,52 @@ uint64_t GimpleToPluginOps::RecomputeDominator(uint64_t dir, uint64_t bbAddr) + abort(); + } + ++// CGnode ========= ++ ++CGnodeOp GimpleToPluginOps::BuildCGnodeOp(uint64_t id) ++{ ++ cgraph_node *node; ++ node = reinterpret_cast(id); ++ fprintf(stderr, "dgy client BuildCGnodeOp id : %lld\n", id); ++ fprintf(stderr, "dgy client BuildCGnodeOp node name is : %s/%d\n", node->name(), node->order); ++ mlir::StringRef symbolName(node->name()); ++ bool definition = false; ++ if (node->definition) ++ definition = true; ++ uint32_t order = node->order; ++ auto location = builder.getUnknownLoc(); ++ CGnodeOp retOp = builder.create(location, id, symbolName, definition, order); ++ return retOp; ++} ++ ++vector GimpleToPluginOps::GetCGnodeIDs() ++{ ++ cgraph_node *node = NULL; ++ vector cgnodeIDs; ++ FOR_EACH_FUNCTION (node) { ++ int64_t id = reinterpret_cast(reinterpret_cast(node)); ++ fprintf(stderr, "dgy client GetCGnodeIDs id : %lld\n", id); ++ fprintf(stderr, "dgy client GetCGnodeIDs node name is : %s/%d\n", node->name(), node->order); ++ cgnodeIDs.push_back(id); ++ } ++ return cgnodeIDs; ++} ++ ++CGnodeOp GimpleToPluginOps::GetCGnodeOpById(uint64_t id) ++{ ++ CGnodeOp cgOp = BuildCGnodeOp(id); ++ return cgOp; ++} ++ ++bool GimpleToPluginOps::IsRealSymbolOfCGnode(uint64_t id) ++{ ++ cgraph_node *node; ++ node = reinterpret_cast(id); ++ return node->real_symbol_p(); ++} ++ ++//================= ++ + vector GimpleToPluginOps::GetAllFunction() + { + cgraph_node *node = NULL; +-- +2.33.0 + diff --git a/0005-Pin-gcc-client-Add-support-for-decl-and-field-SetDec.patch b/0005-Pin-gcc-client-Add-support-for-decl-and-field-SetDec.patch new file mode 100644 index 0000000000000000000000000000000000000000..c4e057ca749bc4279bdae1aa3ca9c674da5db4f8 --- /dev/null +++ b/0005-Pin-gcc-client-Add-support-for-decl-and-field-SetDec.patch @@ -0,0 +1,893 @@ +From 14bac90b45e248e18262cc2bc1cb4775f2a33643 Mon Sep 17 00:00:00 2001 +From: huitailangzju <804544223@qq.com> +Date: Mon, 6 Mar 2023 10:14:19 +0800 +Subject: [PATCH 5/6] [Pin-gcc-client] Add support for decl and field: + SetDeclName, + SetDeclType,SetDeclAlign,SetUserAlign,SetSourceLocation,SetAddressable,SetNonAddressablep,SetVolatile,SetDeclContext,SetDeclChain + + +diff --git a/include/Dialect/PluginDialect.td b/include/Dialect/PluginDialect.td +index 13b9d37..0edf301 100644 +--- a/include/Dialect/PluginDialect.td ++++ b/include/Dialect/PluginDialect.td +@@ -80,12 +80,14 @@ def IDefineCodeConstructor : I32EnumAttrCase<"Constructor", 9>; + def IDefineCodeVec : I32EnumAttrCase<"Vec", 10>; + def IDefineCodeBLOCK : I32EnumAttrCase<"BLOCK", 11>; + def IDefineCodeCOMPONENT : I32EnumAttrCase<"COMPONENT", 12>; +-def IDefineCodeUNDEF : I32EnumAttrCase<"UNDEF", 13>; ++def IDefineCodeTYPEDECL : I32EnumAttrCase<"TYPEDECL", 13>; ++def IDefineCodeUNDEF : I32EnumAttrCase<"UNDEF", 14>; + def IDefineCodeAttr : I32EnumAttr< + "IDefineCode", "plugin define code", + [IDefineCodeMemRef, IDefineCodeIntCST, IDefineCodeSSA, IDefineCodeLIST, + IDefineCodeStrCST, IDefineCodeArrayRef, IDefineCodeDecl, IDefineCodeFieldDecl, IDefineCodeAddrExp, +- IDefineCodeConstructor, IDefineCodeVec, IDefineCodeBLOCK, IDefineCodeCOMPONENT, IDefineCodeUNDEF]>{ ++ IDefineCodeConstructor, IDefineCodeVec, IDefineCodeBLOCK, IDefineCodeCOMPONENT, IDefineCodeTYPEDECL, ++ IDefineCodeUNDEF]>{ + let cppNamespace = "::mlir::Plugin"; + } + +diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h +index 6e66d08..bb1e0b2 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -62,6 +62,28 @@ public: + virtual vector GetFunctions() = 0; + virtual FunctionOp GetFunctionOpById(uint64_t) = 0; + virtual vector GetDecls(uint64_t funcID) = 0; ++ virtual vector GetFuncDecls(uint64_t funcID) = 0; ++ virtual vector GetFields(uint64_t declID) = 0; ++ virtual DeclBaseOp BuildDecl(IDefineCode, string, PluginTypeBase) = 0; ++ ++ virtual mlir::Value MakeNode(IDefineCode) = 0; ++ virtual void SetDeclName(uint64_t, uint64_t) = 0; ++ virtual void SetDeclType(uint64_t, uint64_t) = 0; ++ virtual void SetDeclAlign(uint64_t newfieldId, uint64_t fieldId) = 0; ++ virtual void SetUserAlign(uint64_t newfieldId, uint64_t fieldId) = 0; ++ virtual void SetSourceLocation(uint64_t newfieldId, uint64_t fieldId) = 0; ++ virtual void SetAddressable(uint64_t newfieldId, uint64_t fieldId) = 0; ++ virtual void SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId) = 0; ++ virtual void SetVolatile(uint64_t newfieldId, uint64_t fieldId) = 0; ++ virtual void SetDeclContext(uint64_t newfieldId, uint64_t declId) = 0; ++ virtual void SetDeclChain(uint64_t newfieldId, uint64_t fieldId) = 0; ++ ++ virtual unsigned GetDeclTypeSize(uint64_t declId) = 0; ++ ++ virtual void SetTypeFields(uint64_t declId, uint64_t fieldId) = 0; ++ virtual void LayoutType(uint64_t declId) = 0; ++ virtual void LayoutDecl(uint64_t declId) = 0; ++ + virtual vector GetLoopsFromFunc(uint64_t) = 0; + virtual LoopOp GetLoopById(uint64_t) = 0; + virtual bool IsBlockInside(uint64_t, uint64_t) = 0; +diff --git a/include/PluginAPI/PluginClientAPI.h b/include/PluginAPI/PluginClientAPI.h +index 1970f1e..9b845a8 100644 +--- a/include/PluginAPI/PluginClientAPI.h ++++ b/include/PluginAPI/PluginClientAPI.h +@@ -54,6 +54,28 @@ public: + vector GetFunctions() override; + FunctionOp GetFunctionOpById(uint64_t) override; + vector GetDecls(uint64_t funcID) override; ++ vector GetFuncDecls(uint64_t funcID) override; ++ vector GetFields(uint64_t declID) override; ++ DeclBaseOp BuildDecl(IDefineCode, string, PluginTypeBase) override; ++ ++ mlir::Value MakeNode(IDefineCode) override; ++ void SetDeclName(uint64_t, uint64_t) override; ++ void SetDeclType(uint64_t, uint64_t) override; ++ void SetDeclAlign(uint64_t newfieldId, uint64_t fieldId) override; ++ void SetUserAlign(uint64_t newfieldId, uint64_t fieldId) override; ++ void SetSourceLocation(uint64_t newfieldId, uint64_t fieldId) override; ++ void SetAddressable(uint64_t newfieldId, uint64_t fieldId) override; ++ void SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId) override; ++ void SetVolatile(uint64_t newfieldId, uint64_t fieldId) override; ++ void SetDeclContext(uint64_t newfieldId, uint64_t declId) override; ++ void SetDeclChain(uint64_t newfieldId, uint64_t fieldId) override; ++ ++ unsigned GetDeclTypeSize(uint64_t declId) override; ++ ++ void SetTypeFields(uint64_t declId, uint64_t fieldId) override; ++ void LayoutType(uint64_t declId) override; ++ void LayoutDecl(uint64_t declId) override; ++ + vector GetLoopsFromFunc(uint64_t) override; + LoopOp GetLoopById(uint64_t) override; + bool IsBlockInside(uint64_t, uint64_t) override; +diff --git a/include/PluginClient/PluginJson.h b/include/PluginClient/PluginJson.h +index 3f7813e..f8df011 100755 +--- a/include/PluginClient/PluginJson.h ++++ b/include/PluginClient/PluginJson.h +@@ -49,6 +49,8 @@ public: + void NopJsonSerialize(string&); + void FunctionOpJsonSerialize(vector& data, string& out); + void LocalDeclsJsonSerialize(vector& decls, string& out); ++ void FunctionDeclsJsonSerialize(vector& decls, string& out); ++ void FiledOpsJsonSerialize(vector& decls, string& out); + void GetPhiOpsJsonSerialize(vector phiOps, string& out); + Json::Value OperationJsonSerialize(mlir::Operation *, uint64_t&); + Json::Value CallOpJsonSerialize(mlir::Plugin::CallOp& data); +diff --git a/include/Translate/GimpleToPluginOps.h b/include/Translate/GimpleToPluginOps.h +index 3c7aba2..0565b01 100644 +--- a/include/Translate/GimpleToPluginOps.h ++++ b/include/Translate/GimpleToPluginOps.h +@@ -71,6 +71,28 @@ public: + vector GetFunctionIDs(); + mlir::Plugin::FunctionOp GetFunctionById(uint64_t); + vector GetAllDecls(uint64_t); ++ vector GetFuncDecls(uint64_t); ++ vector GetFields(uint64_t); ++ mlir::Plugin::DeclBaseOp BuildDecl(IDefineCode, string, PluginTypeBase); ++ ++ mlir::Value MakeNode(IDefineCode); ++ void SetDeclName(uint64_t, uint64_t); ++ void SetDeclType(uint64_t, uint64_t); ++ void SetDeclAlign(uint64_t newfieldId, uint64_t fieldId); ++ void SetUserAlign(uint64_t newfieldId, uint64_t fieldId); ++ void SetSourceLocation(uint64_t newfieldId, uint64_t fieldId); ++ void SetAddressable(uint64_t newfieldId, uint64_t fieldId); ++ void SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId); ++ void SetVolatile(uint64_t newfieldId, uint64_t fieldId); ++ void SetDeclContext(uint64_t newfieldId, uint64_t declId); ++ void SetDeclChain(uint64_t newfieldId, uint64_t fieldId); ++ ++ unsigned GetDeclTypeSize(uint64_t declId); ++ ++ void SetTypeFields(uint64_t declId, uint64_t fieldId); ++ void LayoutType(uint64_t declId); ++ void LayoutDecl(uint64_t declId); ++ + vector GetAllLoops(uint64_t); + LoopOp GetLoop(uint64_t); + bool IsBlockInside(uint64_t, uint64_t); +diff --git a/lib/PluginAPI/PluginClientAPI.cpp b/lib/PluginAPI/PluginClientAPI.cpp +index 5194d29..0ee062b 100644 +--- a/lib/PluginAPI/PluginClientAPI.cpp ++++ b/lib/PluginAPI/PluginClientAPI.cpp +@@ -107,6 +107,96 @@ vector PluginClientAPI::GetDecls(uint64_t funcID) + return gimpleConversion.GetAllDecls(funcID); + } + ++vector PluginClientAPI::GetFuncDecls(uint64_t funcID) ++{ ++ return gimpleConversion.GetFuncDecls(funcID); ++} ++ ++vector PluginClientAPI::GetFields(uint64_t declID) ++{ ++ return gimpleConversion.GetFields(declID); ++} ++ ++mlir::Value PluginClientAPI::MakeNode(IDefineCode code) ++{ ++ return gimpleConversion.MakeNode(code); ++} ++ ++DeclBaseOp PluginClientAPI::BuildDecl(IDefineCode code, string name, PluginTypeBase type) ++{ ++ return gimpleConversion.BuildDecl(code, name, type); ++} ++ ++void PluginClientAPI::SetDeclName(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetDeclName(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetDeclType(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetDeclType(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetDeclAlign(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetDeclAlign(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetUserAlign(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetUserAlign(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetDeclChain(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetDeclChain(newfieldId, fieldId); ++} ++ ++unsigned PluginClientAPI::GetDeclTypeSize(uint64_t declId) ++{ ++ gimpleConversion.GetDeclTypeSize(declId); ++} ++ ++void PluginClientAPI::SetSourceLocation(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetSourceLocation(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetAddressable(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetAddressable(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetNonAddressablep(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetVolatile(uint64_t newfieldId, uint64_t fieldId) ++{ ++ gimpleConversion.SetVolatile(newfieldId, fieldId); ++} ++ ++void PluginClientAPI::SetDeclContext(uint64_t newfieldId, uint64_t declId) ++{ ++ gimpleConversion.SetDeclContext(newfieldId, declId); ++} ++ ++void PluginClientAPI::SetTypeFields(uint64_t declId, uint64_t fieldId) ++{ ++ gimpleConversion.SetTypeFields(declId, fieldId); ++} ++ ++void PluginClientAPI::LayoutType(uint64_t declId) ++{ ++ gimpleConversion.LayoutType(declId); ++} ++ ++void PluginClientAPI::LayoutDecl(uint64_t declId) ++{ ++ gimpleConversion.LayoutDecl(declId); ++} ++ + vector PluginClientAPI::GetLoopsFromFunc(uint64_t funcID) + { + return gimpleConversion.GetAllLoops(funcID); +diff --git a/lib/PluginClient/PluginClient.cpp b/lib/PluginClient/PluginClient.cpp +index 310366d..83e8642 100644 +--- a/lib/PluginClient/PluginClient.cpp ++++ b/lib/PluginClient/PluginClient.cpp +@@ -193,6 +193,353 @@ void GetLocalDeclsResult(PluginClient *client, Json::Value& root, string& result + client->ReceiveSendMsg("LocalDeclOpResult", result); + } + ++void GetFuncDeclsResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "funcId":"xxxx" ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string funcIdKey = "funcId"; ++ uint64_t funcID = atol(root[funcIdKey].asString().c_str()); ++ vector decls = clientAPI.GetFuncDecls(funcID); ++ PluginJson json = client->GetJson(); ++ json.FunctionDeclsJsonSerialize(decls, result); ++ client->ReceiveSendMsg("FuncDeclsOpResult", result); ++} ++ ++void GetMakeNodeResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "defCode":"xxxx" ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string codeKey = "defCode"; ++ IDefineCode code = IDefineCode(atoi((root[codeKey].asString().c_str()))); ++ mlir::Value v = clientAPI.MakeNode(code); ++ PluginJson json = client->GetJson(); ++ result = json.ValueJsonSerialize(v).toStyledString(); ++ client->ReceiveSendMsg("MakeNodeResult", result); ++} ++ ++void GetFieldsResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "declId":"xxxx" ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string declIdKey = "declId"; ++ uint64_t declID = atol(root[declIdKey].asString().c_str()); ++ vector decls = clientAPI.GetFields(declID); ++ PluginJson json = client->GetJson(); ++ json.FiledOpsJsonSerialize(decls, result); ++ client->ReceiveSendMsg("GetFieldsOpResult", result); ++} ++ ++void GetBuildDeclResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "defCode":"xxxx", ++ /// "name":"xxxx", ++ /// "type":"xxxx" ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string defCode = "defCode"; ++ std::string name = "name"; ++ std::string type = "type"; ++ IDefineCode code = IDefineCode(atoi((root[defCode].asString().c_str()))); ++ string tname = root[name].asString(); ++ PluginJson json = client->GetJson(); ++ PluginIR::PluginTypeBase t = json.TypeJsonDeSerialize(root[type].toStyledString(), context); ++ DeclBaseOp decl = clientAPI.BuildDecl(code, tname, t); ++ ++ result = json.DeclBaseOpJsonSerialize(decl).toStyledString(); ++ client->ReceiveSendMsg("DeclOpResult", result); ++} ++ ++void SetDeclNameResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetDeclName(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetSourceLocationResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetSourceLocation(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetDeclAlignResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetDeclAlign(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetUserAlignResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetUserAlign(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetTypeFieldsResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "declId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string declIdkey = "declId"; ++ uint64_t declId = atol(root[declIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetTypeFields(declId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void LayoutTypeResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "declId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string declIdKey = "declId"; ++ uint64_t declId = atol(root[declIdKey].asString().c_str()); ++ clientAPI.LayoutType(declId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void LayoutDeclResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "declId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string declIdKey = "declId"; ++ uint64_t declId = atol(root[declIdKey].asString().c_str()); ++ clientAPI.LayoutDecl(declId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++ ++void SetDeclChainResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetDeclChain(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void GetDeclTypeSizeResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "declId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string declIdkey = "declId"; ++ uint64_t declId = atol(root[declIdkey].asString().c_str()); ++ unsigned size = clientAPI.GetDeclTypeSize(declId); ++ PluginJson json = client->GetJson(); ++ json.IntegerSerialize(size, result); ++ client->ReceiveSendMsg("IntegerResult", result); ++} ++ ++void SetAddressableResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetAddressable(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetNonAddressablepResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetNonAddressablep(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetVolatileResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetVolatile(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetDeclContextResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string declIdKey = "declId"; ++ uint64_t declId = atol(root[declIdKey].asString().c_str()); ++ clientAPI.SetDeclContext(newfieldId, declId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ ++void SetDeclTypeResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ /// Json格式 ++ /// { ++ /// "newfieldId":"xxxx", ++ /// "fieldId":"xxxx", ++ /// } ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string newfieldIdkey = "newfieldId"; ++ uint64_t newfieldId = atol(root[newfieldIdkey].asString().c_str()); ++ std::string fieldIdKey = "fieldId"; ++ uint64_t fieldId = atol(root[fieldIdKey].asString().c_str()); ++ clientAPI.SetDeclType(newfieldId, fieldId); ++ PluginJson json = client->GetJson(); ++ json.NopJsonSerialize(result); ++ client->ReceiveSendMsg("VoidResult", result); ++} ++ + void GetLoopsFromFuncResult(PluginClient *client, Json::Value& root, string& result) + { + /// Json格式 +@@ -916,6 +1263,24 @@ std::map g_getResultFunc = { + {"GetFunctionIDs", GetFunctionIDsResult}, + {"GetFunctionOpById", GetFunctionOpByIdResult}, + {"GetLocalDecls", GetLocalDeclsResult}, ++ {"GetFuncDecls", GetFuncDeclsResult}, ++ {"GetFields", GetFieldsResult}, ++ {"BuildDecl", GetBuildDeclResult}, ++ {"MakeNode", GetMakeNodeResult}, ++ {"SetDeclName", SetDeclNameResult}, ++ {"SetDeclType", SetDeclTypeResult}, ++ {"SetSourceLocation", SetSourceLocationResult}, ++ {"SetDeclAlign", SetDeclAlignResult}, ++ {"SetUserAlign", SetUserAlignResult}, ++ {"SetTypeFields", SetTypeFieldsResult}, ++ {"LayoutType", LayoutTypeResult}, ++ {"LayoutDecl", LayoutDeclResult}, ++ {"SetAddressable", SetAddressableResult}, ++ {"GetDeclTypeSize", GetDeclTypeSizeResult}, ++ {"SetDeclChain", SetDeclChainResult}, ++ {"SetNonAddressablep", SetNonAddressablepResult}, ++ {"SetVolatile", SetVolatileResult}, ++ {"SetDeclContext", SetDeclContextResult}, + {"GetLoopsFromFunc", GetLoopsFromFuncResult}, + {"GetLoopById", GetLoopByIdResult}, + {"IsBlockInside", IsBlockInsideResult}, +diff --git a/lib/PluginClient/PluginJson.cpp b/lib/PluginClient/PluginJson.cpp +index 40590b2..76f13a7 100755 +--- a/lib/PluginClient/PluginJson.cpp ++++ b/lib/PluginClient/PluginJson.cpp +@@ -387,6 +387,40 @@ void PluginJson::LocalDeclsJsonSerialize(vector& decls, string& out + out = root.toStyledString(); + } + ++void PluginJson::FunctionDeclsJsonSerialize(vector& decls, string& out) ++{ ++ Json::Value root; ++ Json::Value operationObj; ++ Json::Value item; ++ int i = 0; ++ string operation; ++ ++ for (auto& decl: decls) { ++ item = DeclBaseOpJsonSerialize(decl); ++ operation = std::to_string(i++); ++ root[operation] = item; ++ item.clear(); ++ } ++ out = root.toStyledString(); ++} ++ ++void PluginJson::FiledOpsJsonSerialize(vector& decls, string& out) ++{ ++ Json::Value root; ++ Json::Value operationObj; ++ Json::Value item; ++ int i = 0; ++ string operation; ++ ++ for (auto& decl: decls) { ++ item = FieldDeclOpJsonSerialize(decl); ++ operation = std::to_string(i++); ++ root[operation] = item; ++ item.clear(); ++ } ++ out = root.toStyledString(); ++} ++ + void PluginJson::LoopOpsJsonSerialize(vector& loops, string& out) + { + Json::Value root; +diff --git a/lib/Translate/GimpleToPluginOps.cpp b/lib/Translate/GimpleToPluginOps.cpp +index 230fc1e..d1b3298 100644 +--- a/lib/Translate/GimpleToPluginOps.cpp ++++ b/lib/Translate/GimpleToPluginOps.cpp +@@ -48,6 +48,7 @@ + #include "tree-into-ssa.h" + #include "dominance.h" + #include "print-tree.h" ++#include "stor-layout.h" + + namespace PluginIR { + using namespace mlir::Plugin; +@@ -424,6 +425,207 @@ vector GimpleToPluginOps::GetAllDecls(uint64_t funcID) + return decls; + } + ++vector GimpleToPluginOps::GetFuncDecls(uint64_t funcID) ++{ ++ function *fn = reinterpret_cast(funcID); ++ vector decls; ++ if (!vec_safe_is_empty(fn->local_decls)) { ++ unsigned ix = 0; ++ tree var = NULL_TREE; ++ FOR_EACH_LOCAL_DECL (fn, ix, var) { ++ uint64_t id = reinterpret_cast(reinterpret_cast(var)); ++ if (TREE_CODE(var) != VAR_DECL || !DECL_NAME (var)) { ++ continue; ++ } ++ bool addressable = TREE_ADDRESSABLE(var); ++ bool used = TREE_USED(var); ++ int32_t uid = DECL_UID(var); ++ mlir::Value initial = TreeToValue((uint64_t)DECL_INITIAL(var)); ++ mlir::Value name = TreeToValue((uint64_t)DECL_NAME(var)); ++ llvm::Optional chain = (uint64_t)DECL_CHAIN(var); ++ bool readOnly = false; ++ PluginTypeBase rPluginType = PluginUndefType::get(builder.getContext()); ++ GetTreeAttr(id, readOnly, rPluginType); ++ DeclBaseOp decl = builder.create( ++ builder.getUnknownLoc(), id, IDefineCode::Decl, readOnly, addressable, used, uid, initial, name, ++ chain, rPluginType); ++ ++ decls.push_back(decl); ++ } ++ } ++ return decls; ++} ++ ++mlir::Value GimpleToPluginOps::MakeNode(IDefineCode defcode) ++{ ++ enum tree_code code; ++ switch (defcode) { ++ case IDefineCode::FieldDecl : { ++ code = FIELD_DECL; ++ break; ++ } ++ default : { ++ code = FIELD_DECL; ++ break; ++ } ++ } ++ tree field = make_node(code); ++ mlir::Value v = TreeToValue(reinterpret_cast(reinterpret_cast(field))); ++ return v; ++} ++ ++vector GimpleToPluginOps::GetFields(uint64_t declID) ++{ ++ vector fields; ++ tree decl = reinterpret_cast(declID); ++ tree type = TREE_TYPE(decl); ++ while (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE) ++ type = TREE_TYPE (type); ++ ++ for (tree field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field)) { ++ if (TREE_CODE (field) != FIELD_DECL) { ++ continue; ++ } ++ uint64_t treeId = reinterpret_cast(reinterpret_cast(field)); ++ bool addressable = TREE_ADDRESSABLE(field); ++ bool used = TREE_USED(field); ++ int32_t uid = DECL_UID(field); ++ mlir::Value initial = TreeToValue((uint64_t)DECL_INITIAL(field)); ++ mlir::Value name = TreeToValue((uint64_t)DECL_NAME(field)); ++ uint64_t chain = (uint64_t)DECL_CHAIN(field); ++ mlir::Value fieldOffset = TreeToValue((uint64_t)DECL_FIELD_OFFSET(field)); ++ mlir::Value fieldBitOffset = TreeToValue((uint64_t)DECL_FIELD_BIT_OFFSET(field)); ++ bool readOnly = false; ++ PluginTypeBase rPluginType = PluginUndefType::get(builder.getContext()); ++ GetTreeAttr(treeId, readOnly, rPluginType); ++ FieldDeclOp opValue = builder.create( ++ builder.getUnknownLoc(), treeId, IDefineCode::FieldDecl, readOnly, addressable, used, uid, initial, name, ++ chain, fieldOffset, fieldBitOffset, rPluginType); ++ fields.push_back(opValue); ++ } ++ return fields; ++} ++ ++DeclBaseOp GimpleToPluginOps::BuildDecl(IDefineCode code, string name, PluginTypeBase type) ++{ ++ tree newtype = make_node(RECORD_TYPE); ++ tree t = build_decl(UNKNOWN_LOCATION, TYPE_DECL, get_identifier(name.c_str()), newtype); ++ TYPE_NAME(newtype) = t; ++ ++ uint64_t id = reinterpret_cast(reinterpret_cast(t)); ++ ++ bool addressable = TREE_ADDRESSABLE(t); ++ bool used = TREE_USED(t); ++ int32_t uid = DECL_UID(t); ++ mlir::Value initial = TreeToValue((uint64_t)DECL_INITIAL(t)); ++ mlir::Value tname = TreeToValue((uint64_t)DECL_NAME(t)); ++ llvm::Optional chain = (uint64_t)DECL_CHAIN(t); ++ bool readOnly = false; ++ PluginTypeBase rPluginType = PluginUndefType::get(builder.getContext()); ++ GetTreeAttr(id, readOnly, rPluginType); ++ DeclBaseOp decl = builder.create( ++ builder.getUnknownLoc(), id, code, readOnly, addressable, used, uid, initial, tname, ++ chain, rPluginType); ++ return decl; ++} ++ ++void GimpleToPluginOps::SetDeclName(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ DECL_NAME (newfield) = DECL_NAME (field); ++} ++ ++void GimpleToPluginOps::SetDeclType(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ TREE_TYPE (newfield) = TREE_TYPE (field); ++} ++ ++void GimpleToPluginOps::SetSourceLocation(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ DECL_SOURCE_LOCATION (newfield) = DECL_SOURCE_LOCATION (field); ++} ++ ++void GimpleToPluginOps::SetDeclAlign(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ SET_DECL_ALIGN (newfield, DECL_ALIGN (field)); ++} ++ ++void GimpleToPluginOps::SetUserAlign(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ DECL_USER_ALIGN (newfield) = DECL_USER_ALIGN (field); ++} ++ ++void GimpleToPluginOps::SetTypeFields(uint64_t declId, uint64_t fieldId) ++{ ++ tree decl = reinterpret_cast(declId); ++ tree field = reinterpret_cast(fieldId); ++ TYPE_FIELDS (TREE_TYPE(decl)) = field; ++} ++ ++void GimpleToPluginOps::LayoutType(uint64_t declId) ++{ ++ tree decl = reinterpret_cast(declId); ++ layout_type (TREE_TYPE(decl)); ++} ++ ++void GimpleToPluginOps::LayoutDecl(uint64_t declId) ++{ ++ tree decl = reinterpret_cast(declId); ++ layout_decl (decl, 0); ++ debug_tree(decl); ++ debug_tree(TREE_TYPE(decl)); ++} ++ ++void GimpleToPluginOps::SetDeclChain(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ DECL_CHAIN (newfield) = field; ++} ++ ++unsigned GimpleToPluginOps::GetDeclTypeSize(uint64_t declId) ++{ ++ tree decl = reinterpret_cast(declId); ++ return tree_to_uhwi (TYPE_SIZE (TREE_TYPE (decl))); ++} ++ ++void GimpleToPluginOps::SetAddressable(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ TREE_ADDRESSABLE (newfield) = TREE_ADDRESSABLE (field); ++} ++ ++void GimpleToPluginOps::SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ DECL_NONADDRESSABLE_P (newfield) = !TREE_ADDRESSABLE (field); ++} ++ ++void GimpleToPluginOps::SetVolatile(uint64_t newfieldId, uint64_t fieldId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree field = reinterpret_cast(fieldId); ++ TREE_THIS_VOLATILE (newfield) = TREE_THIS_VOLATILE (field); ++} ++ ++void GimpleToPluginOps::SetDeclContext(uint64_t newfieldId, uint64_t declId) ++{ ++ tree newfield = reinterpret_cast(newfieldId); ++ tree decl = reinterpret_cast(declId); ++ DECL_CONTEXT (newfield) = TREE_TYPE(decl); ++} ++ + vector GimpleToPluginOps::GetAllLoops(uint64_t funcID) + { + function *fn = reinterpret_cast(funcID); +-- +2.33.0 + diff --git a/0006-Pin-gcc-client-Add-GetDeclType.patch b/0006-Pin-gcc-client-Add-GetDeclType.patch new file mode 100644 index 0000000000000000000000000000000000000000..014d2f19a4e9327cdda71c1a844000242b97452e --- /dev/null +++ b/0006-Pin-gcc-client-Add-GetDeclType.patch @@ -0,0 +1,287 @@ +From 001eb22fb00d2240235def0a4d3923f325eba8ad Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Mon, 6 Mar 2023 22:05:28 +0800 +Subject: [PATCH 6/6] [Pin-gcc-client] Add GetDeclType + + +diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h +index bb1e0b2..22da8df 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -64,6 +64,7 @@ public: + virtual vector GetDecls(uint64_t funcID) = 0; + virtual vector GetFuncDecls(uint64_t funcID) = 0; + virtual vector GetFields(uint64_t declID) = 0; ++ virtual PluginIR::PluginTypeBase GetDeclType(uint64_t declID) = 0; + virtual DeclBaseOp BuildDecl(IDefineCode, string, PluginTypeBase) = 0; + + virtual mlir::Value MakeNode(IDefineCode) = 0; +diff --git a/include/PluginAPI/PluginClientAPI.h b/include/PluginAPI/PluginClientAPI.h +index 9b845a8..26ef71d 100644 +--- a/include/PluginAPI/PluginClientAPI.h ++++ b/include/PluginAPI/PluginClientAPI.h +@@ -56,6 +56,7 @@ public: + vector GetDecls(uint64_t funcID) override; + vector GetFuncDecls(uint64_t funcID) override; + vector GetFields(uint64_t declID) override; ++ PluginIR::PluginTypeBase GetDeclType(uint64_t declID) override; + DeclBaseOp BuildDecl(IDefineCode, string, PluginTypeBase) override; + + mlir::Value MakeNode(IDefineCode) override; +diff --git a/include/Translate/GimpleToPluginOps.h b/include/Translate/GimpleToPluginOps.h +index 0565b01..1332219 100644 +--- a/include/Translate/GimpleToPluginOps.h ++++ b/include/Translate/GimpleToPluginOps.h +@@ -73,6 +73,7 @@ public: + vector GetAllDecls(uint64_t); + vector GetFuncDecls(uint64_t); + vector GetFields(uint64_t); ++ PluginIR::PluginTypeBase GetDeclType(uint64_t); + mlir::Plugin::DeclBaseOp BuildDecl(IDefineCode, string, PluginTypeBase); + + mlir::Value MakeNode(IDefineCode); +diff --git a/lib/PluginAPI/PluginClientAPI.cpp b/lib/PluginAPI/PluginClientAPI.cpp +index 0ee062b..95e9ab3 100644 +--- a/lib/PluginAPI/PluginClientAPI.cpp ++++ b/lib/PluginAPI/PluginClientAPI.cpp +@@ -117,6 +117,11 @@ vector PluginClientAPI::GetFields(uint64_t declID) + return gimpleConversion.GetFields(declID); + } + ++PluginIR::PluginTypeBase PluginClientAPI::GetDeclType(uint64_t declID) ++{ ++ return gimpleConversion.GetDeclType(declID); ++} ++ + mlir::Value PluginClientAPI::MakeNode(IDefineCode code) + { + return gimpleConversion.MakeNode(code); +diff --git a/lib/PluginClient/PluginClient.cpp b/lib/PluginClient/PluginClient.cpp +index 83e8642..c354d7e 100644 +--- a/lib/PluginClient/PluginClient.cpp ++++ b/lib/PluginClient/PluginClient.cpp +@@ -268,6 +268,19 @@ void GetBuildDeclResult(PluginClient *client, Json::Value& root, string& result) + client->ReceiveSendMsg("DeclOpResult", result); + } + ++void GetDeclTypeResult(PluginClient *client, Json::Value& root, string& result) ++{ ++ mlir::MLIRContext context; ++ context.getOrLoadDialect(); ++ PluginAPI::PluginClientAPI clientAPI(context); ++ std::string declIdKey = "declId"; ++ uint64_t declID = atol(root[declIdKey].asString().c_str()); ++ PluginIR::PluginTypeBase retType = clientAPI.GetDeclType(declID); ++ PluginJson json = client->GetJson(); ++ result = json.TypeJsonSerialize(retType).toStyledString(); ++ client->ReceiveSendMsg("PluginTypeResult", result); ++} ++ + void SetDeclNameResult(PluginClient *client, Json::Value& root, string& result) + { + /// Json格式 +@@ -1266,6 +1279,7 @@ std::map g_getResultFunc = { + {"GetFuncDecls", GetFuncDeclsResult}, + {"GetFields", GetFieldsResult}, + {"BuildDecl", GetBuildDeclResult}, ++ {"GetDeclType", GetDeclTypeResult}, + {"MakeNode", GetMakeNodeResult}, + {"SetDeclName", SetDeclNameResult}, + {"SetDeclType", SetDeclTypeResult}, +diff --git a/lib/PluginClient/PluginInputCheck.cpp b/lib/PluginClient/PluginInputCheck.cpp +index 4d17e0a..36ebd8c 100755 +--- a/lib/PluginClient/PluginInputCheck.cpp ++++ b/lib/PluginClient/PluginInputCheck.cpp +@@ -47,7 +47,7 @@ bool PluginInputCheck::ReadConfigfile(Json::Value& root) + } + + if (!reader.parse(ifs, root)) { +- printf("parse %s fail! check the file format!\n", configFilePath.c_str()); ++ fprintf(stderr, "parse %s fail! check the file format!\n", configFilePath.c_str()); + ifs.close(); + return false; + } +diff --git a/lib/PluginClient/PluginJson.cpp b/lib/PluginClient/PluginJson.cpp +index 76f13a7..be0ee8d 100755 +--- a/lib/PluginClient/PluginJson.cpp ++++ b/lib/PluginClient/PluginJson.cpp +@@ -209,7 +209,6 @@ void PluginJson::CGnodeOpJsonSerialize(CGnodeOp& cgnode, string& out) + root["attributes"]["definition"] = "0"; + } + root["attributes"]["symbolName"] = cgnode.symbolNameAttr().getValue().str().c_str(); +- fprintf(stderr, "dgy client cgnode json %s\n", root.toStyledString().c_str()); + out = root.toStyledString(); + } + +diff --git a/lib/PluginClient/PluginLog.cpp b/lib/PluginClient/PluginLog.cpp +index 6cdf7af..7ace548 100644 +--- a/lib/PluginClient/PluginLog.cpp ++++ b/lib/PluginClient/PluginLog.cpp +@@ -46,14 +46,14 @@ static void GetLogFileName(string& fileName) + { + time_t nowTime = time(nullptr); + if (nowTime == -1) { +- printf("%s fail\n", __func__); ++ fprintf(stderr, "%s fail\n", __func__); + } + struct tm *t = localtime(&nowTime); + char buf[100]; + int ret = sprintf(buf, "/tmp/pin_client%d_%4d%02d%02d_%02d_%02d_%02d.log", getpid(), + t->tm_year + BASE_DATE, t->tm_mon + 1, t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec); + if (ret < 0) { +- printf("%s sprintf fail\n", __func__); ++ fprintf(stderr, "%s sprintf fail\n", __func__); + } + fileName = buf; + } +@@ -100,14 +100,14 @@ static void LogWrite(const char *tag, const char *msg) + { + time_t nowTime = time(nullptr); + if (nowTime == -1) { +- printf("%s fail\n", __func__); ++ fprintf(stderr, "%s fail\n", __func__); + } + struct tm *t = localtime(&nowTime); + char buf[30]; + int ret = sprintf(buf, "%4d-%02d-%02d %02d:%02d:%02d ", t->tm_year + BASE_DATE, t->tm_mon + 1, t->tm_mday, + t->tm_hour, t->tm_min, t->tm_sec); + if (ret < 0) { +- printf("%s sprintf fail\n", __func__); ++ fprintf(stderr, "%s sprintf fail\n", __func__); + } + string stag = tag; + string smsg = msg; +@@ -123,12 +123,12 @@ void LogPrint(LogPriority priority, const char *tag, const char *fmt, ...) + va_start(ap, fmt); + int ret = vsnprintf(buf, LOG_BUF_SIZE, fmt, ap); + if (ret < 0) { +- printf("%s vsnprintf fail\n", __func__); ++ fprintf(stderr, "%s vsnprintf fail\n", __func__); + } + va_end(ap); + + if (priority <= g_priority) { +- printf("%s%s", tag, buf); ++ fprintf(stderr, "%s%s", tag, buf); + } + + g_mutex.lock(); +diff --git a/lib/Translate/GimpleToPluginOps.cpp b/lib/Translate/GimpleToPluginOps.cpp +index d1b3298..930b430 100644 +--- a/lib/Translate/GimpleToPluginOps.cpp ++++ b/lib/Translate/GimpleToPluginOps.cpp +@@ -93,7 +93,7 @@ static IComparisonCode TranslateCmpCode(enum tree_code ccode) + case NE_EXPR: + return IComparisonCode::ne; + default: +- printf("tcc_comparison: %d not suppoted!\n", ccode); ++ fprintf(stderr, "tcc_comparison: %d not suppoted!\n", ccode); + break; + } + return IComparisonCode::UNDEF; +@@ -117,7 +117,7 @@ static enum tree_code TranslateCmpCodeToTreeCode(IComparisonCode iCode) + case IComparisonCode::ne: + return NE_EXPR; + default: +- printf("tcc_comparison not suppoted!\n"); ++ fprintf(stderr, "tcc_comparison not suppoted!\n"); + break; + } + // FIXME. +@@ -320,8 +320,6 @@ CGnodeOp GimpleToPluginOps::BuildCGnodeOp(uint64_t id) + { + cgraph_node *node; + node = reinterpret_cast(id); +- fprintf(stderr, "dgy client BuildCGnodeOp id : %lld\n", id); +- fprintf(stderr, "dgy client BuildCGnodeOp node name is : %s/%d\n", node->name(), node->order); + mlir::StringRef symbolName(node->name()); + bool definition = false; + if (node->definition) +@@ -338,8 +336,6 @@ vector GimpleToPluginOps::GetCGnodeIDs() + vector cgnodeIDs; + FOR_EACH_FUNCTION (node) { + int64_t id = reinterpret_cast(reinterpret_cast(node)); +- fprintf(stderr, "dgy client GetCGnodeIDs id : %lld\n", id); +- fprintf(stderr, "dgy client GetCGnodeIDs node name is : %s/%d\n", node->name(), node->order); + cgnodeIDs.push_back(id); + } + return cgnodeIDs; +@@ -506,6 +502,14 @@ vector GimpleToPluginOps::GetFields(uint64_t declID) + return fields; + } + ++PluginIR::PluginTypeBase GimpleToPluginOps::GetDeclType(uint64_t declID) ++{ ++ tree decl = reinterpret_cast(declID); ++ tree type = TREE_TYPE(decl); ++ PluginIR::PluginTypeBase retType = typeTranslator.translateType(reinterpret_cast(reinterpret_cast(type))); ++ return retType; ++} ++ + DeclBaseOp GimpleToPluginOps::BuildDecl(IDefineCode code, string name, PluginTypeBase type) + { + tree newtype = make_node(RECORD_TYPE); +@@ -581,8 +585,8 @@ void GimpleToPluginOps::LayoutDecl(uint64_t declId) + { + tree decl = reinterpret_cast(declId); + layout_decl (decl, 0); +- debug_tree(decl); +- debug_tree(TREE_TYPE(decl)); ++ // debug_tree(decl); ++ // debug_tree(TREE_TYPE(decl)); + } + + void GimpleToPluginOps::SetDeclChain(uint64_t newfieldId, uint64_t fieldId) +@@ -900,19 +904,19 @@ Operation *GimpleToPluginOps::BuildOperation(uint64_t id) + break; + } + case GIMPLE_TRY: { +- printf("try stmt \n"); ++ fprintf(stderr, "try stmt \n"); + TryOp tryOp = BuildTryOp(id); + ret = tryOp.getOperation(); + break; + } + case GIMPLE_CATCH: { +- printf("catch stmt \n"); ++ fprintf(stderr, "catch stmt \n"); + CatchOp catchOp = BuildCatchOp(id); + ret = catchOp.getOperation(); + break; + } + case GIMPLE_BIND: { +- printf("bind stmt \n"); ++ fprintf(stderr, "bind stmt \n"); + BindOp bindOp = BuildBindOp(id); + ret = bindOp.getOperation(); + break; +@@ -1078,7 +1082,7 @@ uint64_t GimpleToPluginOps::CreateGassign(uint64_t blockId, IExprCode iCode, + } else if (vargs.size() == 4) { + ret = gimple_build_assign(vargs[0], TranslateExprCodeToTreeCode(iCode), vargs[1], vargs[2], vargs[3]); + } else { +- printf("ERROR size: %ld.\n", vargs.size()); ++ fprintf(stderr, "ERROR size: %ld.\n", vargs.size()); + } + basic_block bb = reinterpret_cast(blockId); + if (bb != nullptr) { +@@ -1288,7 +1292,7 @@ EHMntOp GimpleToPluginOps::BuildEHMntOp(uint64_t gehmntId) + uint64_t fndecladdr = reinterpret_cast( + reinterpret_cast(gimple_eh_must_not_throw_fndecl(stmt))); + Value fndecl = TreeToValue(fndecladdr); +- printf("build --------------------------------------\n"); ++ fprintf(stderr, "build --------------------------------------\n"); + EHMntOp ret = builder.create( + builder.getUnknownLoc(), gehmntId, fndecl); + return ret; +@@ -1718,7 +1722,7 @@ bool GimpleToPluginOps::ProcessGimpleStmt(intptr_t bbPtr, Region& rg) + gimple *stmt = gsi_stmt (si); + uint64_t id = reinterpret_cast(reinterpret_cast(stmt)); + if (BuildOperation(id) == nullptr) { +- printf("ERROR: BuildOperation!"); ++ fprintf(stderr, "ERROR: BuildOperation!"); + } + if(gimple_code(stmt) == GIMPLE_COND || gimple_code(stmt) == GIMPLE_SWITCH + || gimple_code(stmt) == GIMPLE_TRANSACTION || gimple_code(stmt) == GIMPLE_RESX || +-- +2.33.0 + diff --git a/pin-gcc-client.spec b/pin-gcc-client.spec index fa676a3da2efb23e69523ebb5b59bf114bca5ad9..0bd4bc68265d43c24447c1ff02f6b6be93a4b66c 100644 --- a/pin-gcc-client.spec +++ b/pin-gcc-client.spec @@ -1,6 +1,6 @@ Name: pin-gcc-client Version: 0.4.1 -Release: 3 +Release: 4 Summary: A Pin (Plug-IN framework) client is implemented based on GCC plugin and can execute the compiler optimization pass in GCC. License: GPLv3+ and GPLv3+ with exceptions and GPLv2+ with exceptions and LGPLv2+ and BSD URL: https://gitee.com/src-openeuler/pin-gcc-client @@ -10,12 +10,26 @@ BuildRequires: gcc gcc-c++ gcc-plugin-devel cmake make pkgconfig grpc grpc-plug BuildRequires: llvm-mlir llvm-mlir-static llvm-mlir-devel llvm-devel Requires: gcc grpc protobuf +Patch1: 0001-Pin-gcc-client-BugFix-for-SwitchOp-change-it-to-term.patch +Patch2: 0002-Pin-gcc-client-Bugfix-for-GetFunctionById.patch +Patch3: 0003-Pin-gcc-client-Init-a-SimpleIPAPASS.patch +Patch4: 0004-Pin-gcc-client-Add-CGnodeOp.patch +Patch5: 0005-Pin-gcc-client-Add-support-for-decl-and-field-SetDec.patch +Patch6: 0006-Pin-gcc-client-Add-GetDeclType.patch + %description A Pin (Plug-IN framework) client is implemented based on GCC plugin and can execute the compiler optimization pass in GCC. %prep %setup -q +%patch1 -p1 +%patch2 -p1 +%patch3 -p1 +%patch4 -p1 +%patch5 -p1 +%patch6 -p1 + mkdir -p _build cd _build %{cmake} .. -DCMAKE_INSTALL_PREFIX=%{_usr} -DCMAKE_INSTALL_LIBDIR=%{_libdir} -DCMAKE_SKIP_RPATH=ON -DMLIR_DIR=/usr/lib64/cmake/mlir -DLLVM_DIR=/usr/lib64/cmake/llvm @@ -27,7 +41,6 @@ cd _build %install cd _build -export CFLAGS="${RPM_OPT_FLAGS}" %make_install mkdir -p %{buildroot}/etc/ld.so.conf.d @@ -52,6 +65,12 @@ find %{_libdir} -type f -name "*.so" -exec strip "{}" ";" %config(noreplace) /etc/ld.so.conf.d/%{name}-%{_arch}.conf %changelog +* Tue Mar 7 2023 dingguangya - 0.4.1-4 +- Type:Update +- ID:NA +- SUG:NA +- DESC:Sync patch from openEuler/pin-gcc-client + * Mon Mar 6 2023 wumingchuan - 0.4.1-3 - Type:Update - ID:NA