packages/pin-gcc-client
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[sync] Sync patch from openEuler/pin-gcc-client

Browse Source
This commit is contained in:
dingguangya 2023-03-07 11:17:54 +08:00
parent 1ba70bc5fe
commit 413e13993b
7 changed files with 1922 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
0001-Pin-gcc-client-BugFix-for-SwitchOp-change-it-to-term.patch Normal file
View File

@ -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<AnySuccessor>:$caseDestinations
- );
- let arguments = (ins UI64Attr:$id, AnyType:$index, UI64Attr:$address, AnyType:$defaultLabel, Variadic<AnyType>:$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<Value>":$operands, "Block*":$defaultDestination, "uint64_t":$defaultaddr,
- "ArrayRef<Block*>":$caseDestinations, "ArrayRef<uint64_t>":$caseaddrs)>
- ];
-
- let extraClassDeclaration = [{
- unsigned GetNumLabels() { return getNumOperands() - 2; };
- Block* GetDefautDest() { return defaultDestination();}
- SmallVector<mlir::Block*> 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<string mnemonic, list<OpTrait> traits = []> :
Plugin_Op<mnemonic, !listconcat(traits, [Terminator])>;
+def SwitchOp : Plugin_TerminatorOp<"switch", [NoSideEffect]> {
+ let summary = "switch op.";
+ let description = [{TODO}];
+ let successors = (successor
+ AnySuccessor:$defaultDestination,
+ VariadicSuccessor<AnySuccessor>:$caseDestinations
+ );
+ let arguments = (ins UI64Attr:$id, AnyType:$index, UI64Attr:$address, AnyType:$defaultLabel, Variadic<AnyType>:$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<Value>":$operands, "Block*":$defaultDestination, "uint64_t":$defaultaddr,
+ "ArrayRef<Block*>":$caseDestinations, "ArrayRef<uint64_t>":$caseaddrs)>
+ ];
+
+ let extraClassDeclaration = [{
+ unsigned GetNumLabels() { return getNumOperands() - 2; };
+ Block* GetDefautDest() { return defaultDestination();}
+ SmallVector<mlir::Block*> GetCaseDest() { return caseDestinations(); };
+ }];
+}
+
def FallThroughOp : Plugin_TerminatorOp<"fallthrough", [NoSideEffect]> {
let summary = "FallThroughOp";
let description = [{TODO}];
--
2.33.0

282
0002-Pin-gcc-client-Bugfix-for-GetFunctionById.patch Normal file
View File

@ -0,0 +1,282 @@
From 01a71df9866c4871d68e77f7307107d4e191264c Mon Sep 17 00:00:00 2001
From: Mingchuan Wu <wumingchuan1992@foxmail.com>
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<FunctionOp> GetAllFunc() = 0;
+ virtual vector<uint64_t> GetFunctions() = 0;
+ virtual FunctionOp GetFunctionOpById(uint64_t) = 0;
virtual vector<LocalDeclOp> GetDecls(uint64_t funcID) = 0;
virtual vector<LoopOp> 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<FunctionOp> GetAllFunc() override;
+ vector<uint64_t> GetFunctions() override;
+ FunctionOp GetFunctionOpById(uint64_t) override;
vector<LocalDeclOp> GetDecls(uint64_t funcID) override;
vector<LoopOp> 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<mlir::Plugin::FunctionOp>& data, string& out);
void LoopOpsJsonSerialize(vector<mlir::Plugin::LoopOp>& loops, string& out);
void LoopOpJsonSerialize(mlir::Plugin::LoopOp& loop, string& out);
- void BlocksJsonSerialize(vector<uint64_t>&, string&);
+ void IDsJsonSerialize(vector<uint64_t>&, string&);
void EdgesJsonSerialize(vector<std::pair<uint64_t, uint64_t> >&, string&);
void EdgeJsonSerialize(std::pair<uint64_t, uint64_t>&, 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<mlir::Plugin::FunctionOp> GetAllFunction();
+ vector<uint64_t> GetFunctionIDs();
+ mlir::Plugin::FunctionOp GetFunctionById(uint64_t);
vector<mlir::Plugin::LocalDeclOp> GetAllDecls(uint64_t);
vector<mlir::Plugin::LoopOp> 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<FunctionOp> PluginClientAPI::GetAllFunc()
return gimpleConversion.GetAllFunction();
}
+vector<uint64_t> PluginClientAPI::GetFunctions()
+{
+ return gimpleConversion.GetFunctionIDs();
+}
+
+FunctionOp PluginClientAPI::GetFunctionOpById(uint64_t id)
+{
+ return gimpleConversion.GetFunctionById(id);
+}
+
vector<LocalDeclOp> 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<PluginDialect>();
+ PluginAPI::PluginClientAPI clientAPI(context);
+ vector<uint64_t> 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<PluginDialect>();
+ PluginAPI::PluginClientAPI clientAPI(context);
+ std::string funcIdKey = "id";
+ uint64_t funcID = atol(root[funcIdKey].asString().c_str());
+ vector<FunctionOp> 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<uint64_t> blocks = clientAPI.GetBlocksInLoop(loopId);
+ vector<uint64_t> 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<void(PluginClient*, Json::Value&, string&)> GetResultFunc;
std::map<string, GetResultFunc> 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<uint64_t>& blocks, string& out)
+void PluginJson::IDsJsonSerialize(vector<uint64_t>& 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<FunctionOp> GimpleToPluginOps::GetAllFunction()
return functions;
}
+vector<uint64_t> GimpleToPluginOps::GetFunctionIDs()
+{
+ cgraph_node *node = NULL;
+ function *fn = NULL;
+ vector<uint64_t> functions;
+ FOR_EACH_FUNCTION (node) {
+ fn = DECL_STRUCT_FUNCTION(node->decl);
+ if (fn == NULL)
+ continue;
+ int64_t id = reinterpret_cast<int64_t>(reinterpret_cast<void*>(fn));
+ functions.push_back(id);
+ }
+ return functions;
+}
+
+FunctionOp GimpleToPluginOps::GetFunctionById(uint64_t id)
+{
+ FunctionOp irFunc = BuildFunctionOp(id);
+ builder.setInsertionPointAfter(irFunc.getOperation());
+ return irFunc;
+}
+
vector<LocalDeclOp> GimpleToPluginOps::GetAllDecls(uint64_t funcID)
{
function *fn = reinterpret_cast<function *>(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<uint64_t>(
reinterpret_cast<void*>(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<uint64_t>(
reinterpret_cast<void*>(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<uint64_t>(
reinterpret_cast<void*>(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<uint64_t>(
reinterpret_cast<void*>(gimple_switch_label(stmt, i)));
ops.push_back(TreeToValue(input));
@@ -983,7 +1005,7 @@ SwitchOp GimpleToPluginOps::BuildSwitchOp(uint64_t gswitchId)
llvm::SmallVector<uint64_t, 4> 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

57
0003-Pin-gcc-client-Init-a-SimpleIPAPASS.patch Normal file
View File

@ -0,0 +1,57 @@
From afcc34cc338c59a66132f152e1bdd5e841ab7eca Mon Sep 17 00:00:00 2001
From: d00573793 <dingguangya1@huawei.com>
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<RefPassName, string> 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

308
0004-Pin-gcc-client-Add-CGnodeOp.patch Normal file
View File

@ -0,0 +1,308 @@
From 8d80ef3e9d0fc535694cca23d4d29c7d3f9b1e23 Mon Sep 17 00:00:00 2001
From: d00573793 <dingguangya1@huawei.com>
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<BoolAttr>:$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<Op>(...)`.
+ 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<uint64_t> 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<uint64_t> GetCGnodeIDs() override;
+ CGnodeOp GetCGnodeOpById(uint64_t) override;
+ bool IsRealSymbolOfCGnode(uint64_t);
+
vector<FunctionOp> GetAllFunc() override;
vector<uint64_t> 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<mlir::Plugin::FunctionOp>& data, string& out);
void LoopOpsJsonSerialize(vector<mlir::Plugin::LoopOp>& 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<uint64_t> GetCGnodeIDs();
+ mlir::Plugin::CGnodeOp GetCGnodeOpById(uint64_t);
+ CGnodeOp BuildCGnodeOp(uint64_t);
+ bool IsRealSymbolOfCGnode(uint64_t);
+
vector<mlir::Plugin::FunctionOp> GetAllFunction();
vector<uint64_t> 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<uint64_t> 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<FunctionOp> 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<PluginDialect>();
+ PluginAPI::PluginClientAPI clientAPI(context);
+ vector<uint64_t> 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<void(PluginClient*, Json::Value&, string&)> GetResultFunc;
std::map<string, GetResultFunc> 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<FunctionOp>& 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<cgraph_node *>(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<CGnodeOp>(location, id, symbolName, definition, order);
+ return retOp;
+}
+
+vector<uint64_t> GimpleToPluginOps::GetCGnodeIDs()
+{
+ cgraph_node *node = NULL;
+ vector<uint64_t> cgnodeIDs;
+ FOR_EACH_FUNCTION (node) {
+ int64_t id = reinterpret_cast<int64_t>(reinterpret_cast<void*>(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<cgraph_node *>(id);
+ return node->real_symbol_p();
+}
+
+//=================
+
vector<FunctionOp> GimpleToPluginOps::GetAllFunction()
{
cgraph_node *node = NULL;
--
2.33.0

893
0005-Pin-gcc-client-Add-support-for-decl-and-field-SetDec.patch Normal file
View File

@ -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<uint64_t> GetFunctions() = 0;
virtual FunctionOp GetFunctionOpById(uint64_t) = 0;
virtual vector<LocalDeclOp> GetDecls(uint64_t funcID) = 0;
+ virtual vector<DeclBaseOp> GetFuncDecls(uint64_t funcID) = 0;
+ virtual vector<FieldDeclOp> 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<LoopOp> 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<uint64_t> GetFunctions() override;
FunctionOp GetFunctionOpById(uint64_t) override;
vector<LocalDeclOp> GetDecls(uint64_t funcID) override;
+ vector<DeclBaseOp> GetFuncDecls(uint64_t funcID) override;
+ vector<FieldDeclOp> 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<LoopOp> 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<mlir::Plugin::FunctionOp>& data, string& out);
void LocalDeclsJsonSerialize(vector<mlir::Plugin::LocalDeclOp>& decls, string& out);
+ void FunctionDeclsJsonSerialize(vector<mlir::Plugin::DeclBaseOp>& decls, string& out);
+ void FiledOpsJsonSerialize(vector<mlir::Plugin::FieldDeclOp>& decls, string& out);
void GetPhiOpsJsonSerialize(vector<mlir::Plugin::PhiOp> 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<uint64_t> GetFunctionIDs();
mlir::Plugin::FunctionOp GetFunctionById(uint64_t);
vector<mlir::Plugin::LocalDeclOp> GetAllDecls(uint64_t);
+ vector<mlir::Plugin::DeclBaseOp> GetFuncDecls(uint64_t);
+ vector<FieldDeclOp> 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<mlir::Plugin::LoopOp> 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<LocalDeclOp> PluginClientAPI::GetDecls(uint64_t funcID)
return gimpleConversion.GetAllDecls(funcID);
}
+vector<DeclBaseOp> PluginClientAPI::GetFuncDecls(uint64_t funcID)
+{
+ return gimpleConversion.GetFuncDecls(funcID);
+}
+
+vector<FieldDeclOp> 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<LoopOp> 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<PluginDialect>();
+ PluginAPI::PluginClientAPI clientAPI(context);
+ std::string funcIdKey = "funcId";
+ uint64_t funcID = atol(root[funcIdKey].asString().c_str());
+ vector<DeclBaseOp> 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<PluginDialect>();
+ 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<PluginDialect>();
+ PluginAPI::PluginClientAPI clientAPI(context);
+ std::string declIdKey = "declId";
+ uint64_t declID = atol(root[declIdKey].asString().c_str());
+ vector<FieldDeclOp> 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<PluginDialect>();
+ 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<string, GetResultFunc> 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<LocalDeclOp>& decls, string& out
out = root.toStyledString();
}
+void PluginJson::FunctionDeclsJsonSerialize(vector<mlir::Plugin::DeclBaseOp>& 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<mlir::Plugin::FieldDeclOp>& 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<mlir::Plugin::LoopOp>& 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<LocalDeclOp> GimpleToPluginOps::GetAllDecls(uint64_t funcID)
return decls;
}
+vector<DeclBaseOp> GimpleToPluginOps::GetFuncDecls(uint64_t funcID)
+{
+ function *fn = reinterpret_cast<function *>(funcID);
+ vector<DeclBaseOp> 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<uint64_t>(reinterpret_cast<void*>(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<uint64_t> chain = (uint64_t)DECL_CHAIN(var);
+ bool readOnly = false;
+ PluginTypeBase rPluginType = PluginUndefType::get(builder.getContext());
+ GetTreeAttr(id, readOnly, rPluginType);
+ DeclBaseOp decl = builder.create<DeclBaseOp>(
+ 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<uint64_t>(reinterpret_cast<void*>(field)));
+ return v;
+}
+
+vector<FieldDeclOp> GimpleToPluginOps::GetFields(uint64_t declID)
+{
+ vector<FieldDeclOp> fields;
+ tree decl = reinterpret_cast<tree>(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<uint64_t>(reinterpret_cast<void*>(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<FieldDeclOp>(
+ 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<uint64_t>(reinterpret_cast<void*>(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<uint64_t> chain = (uint64_t)DECL_CHAIN(t);
+ bool readOnly = false;
+ PluginTypeBase rPluginType = PluginUndefType::get(builder.getContext());
+ GetTreeAttr(id, readOnly, rPluginType);
+ DeclBaseOp decl = builder.create<DeclBaseOp>(
+ 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<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ DECL_NAME (newfield) = DECL_NAME (field);
+}
+
+void GimpleToPluginOps::SetDeclType(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ TREE_TYPE (newfield) = TREE_TYPE (field);
+}
+
+void GimpleToPluginOps::SetSourceLocation(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ DECL_SOURCE_LOCATION (newfield) = DECL_SOURCE_LOCATION (field);
+}
+
+void GimpleToPluginOps::SetDeclAlign(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ SET_DECL_ALIGN (newfield, DECL_ALIGN (field));
+}
+
+void GimpleToPluginOps::SetUserAlign(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ DECL_USER_ALIGN (newfield) = DECL_USER_ALIGN (field);
+}
+
+void GimpleToPluginOps::SetTypeFields(uint64_t declId, uint64_t fieldId)
+{
+ tree decl = reinterpret_cast<tree>(declId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ TYPE_FIELDS (TREE_TYPE(decl)) = field;
+}
+
+void GimpleToPluginOps::LayoutType(uint64_t declId)
+{
+ tree decl = reinterpret_cast<tree>(declId);
+ layout_type (TREE_TYPE(decl));
+}
+
+void GimpleToPluginOps::LayoutDecl(uint64_t declId)
+{
+ tree decl = reinterpret_cast<tree>(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<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ DECL_CHAIN (newfield) = field;
+}
+
+unsigned GimpleToPluginOps::GetDeclTypeSize(uint64_t declId)
+{
+ tree decl = reinterpret_cast<tree>(declId);
+ return tree_to_uhwi (TYPE_SIZE (TREE_TYPE (decl)));
+}
+
+void GimpleToPluginOps::SetAddressable(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ TREE_ADDRESSABLE (newfield) = TREE_ADDRESSABLE (field);
+}
+
+void GimpleToPluginOps::SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ DECL_NONADDRESSABLE_P (newfield) = !TREE_ADDRESSABLE (field);
+}
+
+void GimpleToPluginOps::SetVolatile(uint64_t newfieldId, uint64_t fieldId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree field = reinterpret_cast<tree>(fieldId);
+ TREE_THIS_VOLATILE (newfield) = TREE_THIS_VOLATILE (field);
+}
+
+void GimpleToPluginOps::SetDeclContext(uint64_t newfieldId, uint64_t declId)
+{
+ tree newfield = reinterpret_cast<tree>(newfieldId);
+ tree decl = reinterpret_cast<tree>(declId);
+ DECL_CONTEXT (newfield) = TREE_TYPE(decl);
+}
+
vector<LoopOp> GimpleToPluginOps::GetAllLoops(uint64_t funcID)
{
function *fn = reinterpret_cast<function *>(funcID);
--
2.33.0

287
0006-Pin-gcc-client-Add-GetDeclType.patch Normal file
View File

@ -0,0 +1,287 @@
From 001eb22fb00d2240235def0a4d3923f325eba8ad Mon Sep 17 00:00:00 2001
From: d00573793 <dingguangya1@huawei.com>
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<LocalDeclOp> GetDecls(uint64_t funcID) = 0;
virtual vector<DeclBaseOp> GetFuncDecls(uint64_t funcID) = 0;
virtual vector<FieldDeclOp> 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<LocalDeclOp> GetDecls(uint64_t funcID) override;
vector<DeclBaseOp> GetFuncDecls(uint64_t funcID) override;
vector<FieldDeclOp> 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<mlir::Plugin::LocalDeclOp> GetAllDecls(uint64_t);
vector<mlir::Plugin::DeclBaseOp> GetFuncDecls(uint64_t);
vector<FieldDeclOp> 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<FieldDeclOp> 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<PluginDialect>();
+ 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<string, GetResultFunc> 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<cgraph_node *>(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<uint64_t> GimpleToPluginOps::GetCGnodeIDs()
vector<uint64_t> cgnodeIDs;
FOR_EACH_FUNCTION (node) {
int64_t id = reinterpret_cast<int64_t>(reinterpret_cast<void*>(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<FieldDeclOp> GimpleToPluginOps::GetFields(uint64_t declID)
return fields;
}
+PluginIR::PluginTypeBase GimpleToPluginOps::GetDeclType(uint64_t declID)
+{
+ tree decl = reinterpret_cast<tree>(declID);
+ tree type = TREE_TYPE(decl);
+ PluginIR::PluginTypeBase retType = typeTranslator.translateType(reinterpret_cast<uintptr_t>(reinterpret_cast<void*>(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<tree>(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<basic_block>(blockId);
if (bb != nullptr) {
@@ -1288,7 +1292,7 @@ EHMntOp GimpleToPluginOps::BuildEHMntOp(uint64_t gehmntId)
uint64_t fndecladdr = reinterpret_cast<uint64_t>(
reinterpret_cast<void*>(gimple_eh_must_not_throw_fndecl(stmt)));
Value fndecl = TreeToValue(fndecladdr);
- printf("build --------------------------------------\n");
+ fprintf(stderr, "build --------------------------------------\n");
EHMntOp ret = builder.create<EHMntOp>(
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<uint64_t>(reinterpret_cast<void*>(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

23
pin-gcc-client.spec
View File

@ -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 <dingguangya1@huawei.com> - 0.4.1-4
- Type:Update
- ID:NA
- SUG:NA
- DESC:Sync patch from openEuler/pin-gcc-client
* Mon Mar 6 2023 wumingchuan <wumingchuan1992@foxmail.com> - 0.4.1-3
- Type:Update
- ID:NA