packages/pin-server
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pin-server/0022-Pin-server-Add-support-for-decl-and-field-SetDeclNam.patch
dingguangya abfcc9ab67 [sync] Sync patch from openEuler/pin-server
2023-03-07 11:41:20 +08:00

702 lines
30 KiB
Diff
Raw Blame History

From d41c7945688f533b15c9ef1d9f41a00cbd7afbdf Mon Sep 17 00:00:00 2001
From: huitailangzju <804544223@qq.com>
Date: Mon, 6 Mar 2023 10:17:31 +0800
Subject: [PATCH 22/23] [Pin-server] 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 b618b59..56f2e4c 100644
--- a/include/Dialect/PluginDialect.td
+++ b/include/Dialect/PluginDialect.td
@@ -78,12 +78,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/Dialect/PluginOps.td b/include/Dialect/PluginOps.td
index 9554067..6c4d80f 100644
--- a/include/Dialect/PluginOps.td
+++ b/include/Dialect/PluginOps.td
@@ -375,6 +375,19 @@ def FieldDeclOp : FieldDecl<"field"> {
Optional<uint64_t> GetChain() { return chain(); }
Value GetFieldOffset() { return fieldOffset(); }
Value GetFieldBitOffset() { return fieldBitOffset(); }
+
+ void SetName(FieldDeclOp);
+ void SetType(FieldDeclOp);
+ void SetDeclAlign(FieldDeclOp);
+ void SetSourceLocation(FieldDeclOp);
+ void SetUserAlign(FieldDeclOp);
+ void SetAddressable(FieldDeclOp);
+ void SetNonAddressablep(FieldDeclOp);
+ void SetVolatile(FieldDeclOp);
+ void SetDeclContext(uint64_t);
+ void SetDeclChain(FieldDeclOp);
+
+ unsigned GetTypeSize();
}];
}
diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h
index e8c0a50..d659662 100644
--- a/include/PluginAPI/BasicPluginOpsAPI.h
+++ b/include/PluginAPI/BasicPluginOpsAPI.h
@@ -51,6 +51,28 @@ public:
virtual vector<FunctionOp> GetAllFunc() = 0;
virtual FunctionOp GetFunctionOpById(uint64_t) = 0;
+ virtual vector<mlir::Plugin::DeclBaseOp> GetFuncDecls(uint64_t) = 0;
+ virtual llvm::SmallVector<mlir::Plugin::FieldDeclOp> GetFields(uint64_t) = 0;
+ virtual mlir::Plugin::DeclBaseOp BuildDecl(IDefineCode, llvm::StringRef, PluginIR::PluginTypeBase) = 0;
+
+ virtual mlir::Plugin::FieldDeclOp MakeNode(IDefineCode) = 0;
+ virtual void SetDeclName(uint64_t newfieldId, uint64_t fieldId) = 0;
+ virtual void SetDeclType(uint64_t newfieldId, uint64_t fieldId) = 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<LocalDeclOp> GetDecls(uint64_t) = 0;
virtual LoopOp AllocateNewLoop(uint64_t) = 0;
virtual vector<LoopOp> GetLoopsFromFunc(uint64_t) = 0;
diff --git a/include/PluginAPI/PluginServerAPI.h b/include/PluginAPI/PluginServerAPI.h
index 71b59b0..239dd23 100644
--- a/include/PluginAPI/PluginServerAPI.h
+++ b/include/PluginAPI/PluginServerAPI.h
@@ -44,6 +44,28 @@ public:
vector<FunctionOp> GetAllFunc() override;
FunctionOp GetFunctionOpById(uint64_t);
+ vector<mlir::Plugin::DeclBaseOp> GetFuncDecls(uint64_t) override;
+ llvm::SmallVector<mlir::Plugin::FieldDeclOp> GetFields(uint64_t) override;
+ mlir::Plugin::DeclBaseOp BuildDecl(IDefineCode, llvm::StringRef, PluginIR::PluginTypeBase) override;
+
+ mlir::Plugin::FieldDeclOp MakeNode(IDefineCode) override;
+ void SetDeclName(uint64_t newfieldId, uint64_t fieldId) override;
+ void SetDeclType(uint64_t newfieldId, uint64_t fieldId) 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<LocalDeclOp> GetDecls(uint64_t) override;
PhiOp GetPhiOp(uint64_t) override;
CallOp GetCallOp(uint64_t) override;
diff --git a/include/PluginServer/PluginCom.h b/include/PluginServer/PluginCom.h
index d507b6f..af819ad 100755
--- a/include/PluginServer/PluginCom.h
+++ b/include/PluginServer/PluginCom.h
@@ -57,6 +57,12 @@ public:
string GetStringDataResult(void);
vector<mlir::Plugin::FunctionOp> GetFunctionOpResult(void);
vector<mlir::Plugin::LocalDeclOp> GetLocalDeclResult(void);
+ vector<mlir::Plugin::DeclBaseOp> GetFuncDeclsResult(void);
+ llvm::SmallVector<mlir::Plugin::FieldDeclOp> GetFieldsResult(void);
+ mlir::Plugin::DeclBaseOp GetBuildDeclResult(void);
+
+ mlir::Plugin::FieldDeclOp GetMakeNodeResult(void);
+
mlir::Plugin::CGnodeOp GetCGnodeOpResult(void);
mlir::Plugin::LoopOp LoopOpResult(void);
vector<mlir::Plugin::LoopOp> LoopOpsResult(void);
@@ -77,6 +83,7 @@ private:
mlir::Plugin::CGnodeOp cgnode;
vector<mlir::Plugin::FunctionOp> funcOpData;
vector<mlir::Plugin::LocalDeclOp> decls;
+ vector<mlir::Plugin::DeclBaseOp> declOps;
vector<mlir::Plugin::LoopOp> loops;
mlir::Plugin::LoopOp loop;
vector<std::pair<mlir::Block*, mlir::Block*> > edges;
@@ -86,6 +93,9 @@ private:
uint64_t idResult;
vector<uint64_t> idsResult;
mlir::Value valueResult;
+ mlir::Plugin::DeclBaseOp declOp;
+ mlir::Plugin::FieldDeclOp fielddeclOp;
+ llvm::SmallVector<mlir::Plugin::FieldDeclOp> fieldsOps;
};
} // namespace PinCom
diff --git a/include/PluginServer/PluginJson.h b/include/PluginServer/PluginJson.h
index eddbb2a..1d4bfbc 100755
--- a/include/PluginServer/PluginJson.h
+++ b/include/PluginServer/PluginJson.h
@@ -39,6 +39,9 @@ public:
void FuncOpJsonDeSerialize(const string&, vector<mlir::Plugin::FunctionOp>&);
void LocalDeclOpJsonDeSerialize(const string&,
vector<mlir::Plugin::LocalDeclOp>&);
+ void FuncDeclsOpJsonDeSerialize(const string&,
+ vector<mlir::Plugin::DeclBaseOp>&);
+ void FieldOpsJsonDeSerialize(const string&, llvm::SmallVector<mlir::Plugin::FieldDeclOp>&);
void LoopOpsJsonDeSerialize(const string&, vector<mlir::Plugin::LoopOp>&);
void EdgesJsonDeSerialize(const string&,
vector<std::pair<mlir::Block*, mlir::Block*>>&);
diff --git a/include/PluginServer/PluginServer.h b/include/PluginServer/PluginServer.h
index d993505..29a790b 100644
--- a/include/PluginServer/PluginServer.h
+++ b/include/PluginServer/PluginServer.h
@@ -158,6 +158,31 @@ public:
RemoteCallClientWithAPI(funName, params);
return pluginCom.GetFunctionOpResult();
}
+
+ vector<mlir::Plugin::DeclBaseOp> GetFuncDeclsResult(const string& funName, const string& params)
+ {
+ RemoteCallClientWithAPI(funName, params);
+ return pluginCom.GetFuncDeclsResult();
+ }
+
+ mlir::Plugin::FieldDeclOp GetMakeNodeResult(const string& funName, const string& params)
+ {
+ RemoteCallClientWithAPI(funName, params);
+ return pluginCom.GetMakeNodeResult();
+ }
+
+ llvm::SmallVector<mlir::Plugin::FieldDeclOp> GetFieldsResult(const string& funName, const string& params)
+ {
+ RemoteCallClientWithAPI(funName, params);
+ return pluginCom.GetFieldsResult();
+ }
+
+ mlir::Plugin::DeclBaseOp GetBuildDeclResult(const string& funName, const string& params)
+ {
+ RemoteCallClientWithAPI(funName, params);
+ return pluginCom.GetBuildDeclResult();
+ }
+
vector<mlir::Plugin::LocalDeclOp> GetLocalDeclResult(const string& funName, const string& params)
{
RemoteCallClientWithAPI(funName, params);
diff --git a/include/user/ArrayWidenPass.h b/include/user/ArrayWidenPass.h
index 38c692d..5528297 100755
--- a/include/user/ArrayWidenPass.h
+++ b/include/user/ArrayWidenPass.h
@@ -35,10 +35,10 @@ public:
}
int DoOptimize()
{
- uint64_t *fun = (uint64_t *)GetFuncAddr();
+ uint64_t fun = (uint64_t)GetFuncAddr();
return DoOptimize(fun);
}
- int DoOptimize(uint64_t *fun);
+ int DoOptimize(uint64_t fun);
};
}
diff --git a/lib/Dialect/PluginOps.cpp b/lib/Dialect/PluginOps.cpp
index 928dc53..57b06b4 100644
--- a/lib/Dialect/PluginOps.cpp
+++ b/lib/Dialect/PluginOps.cpp
@@ -432,6 +432,82 @@ void FieldDeclOp::build(OpBuilder &builder, OperationState &state, uint64_t id,
state.addTypes(retType);
}
+void FieldDeclOp::SetName(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ unsigned idx = 1;
+ this->setOperand(idx ,field.GetName());
+ return pluginAPI.SetDeclName(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetType(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetDeclType(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetDeclAlign(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetDeclAlign(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetUserAlign(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetUserAlign(this->idAttr().getInt(), fieldId);
+}
+
+unsigned FieldDeclOp::GetTypeSize()
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ return pluginAPI.GetDeclTypeSize(this->idAttr().getInt());
+}
+
+void FieldDeclOp::SetSourceLocation(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetSourceLocation(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetAddressable(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetAddressable(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetNonAddressablep(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetNonAddressablep(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetVolatile(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetVolatile(this->idAttr().getInt(), fieldId);
+}
+
+void FieldDeclOp::SetDeclContext(uint64_t declId)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ return pluginAPI.SetDeclContext(this->idAttr().getInt(), declId);
+}
+
+void FieldDeclOp::SetDeclChain(FieldDeclOp field)
+{
+ PluginAPI::PluginServerAPI pluginAPI;
+ uint64_t fieldId = field.idAttr().getInt();
+ return pluginAPI.SetDeclChain(this->idAttr().getInt(), fieldId);
+}
//===----------------------------------------------------------------------===//
// AddressOp
diff --git a/lib/PluginAPI/PluginServerAPI.cpp b/lib/PluginAPI/PluginServerAPI.cpp
index 5297357..537d389 100644
--- a/lib/PluginAPI/PluginServerAPI.cpp
+++ b/lib/PluginAPI/PluginServerAPI.cpp
@@ -442,6 +442,186 @@ vector<LocalDeclOp> PluginServerAPI::GetDecls(uint64_t funcID)
return PluginServer::GetInstance()->GetLocalDeclResult(funName, params);
}
+vector<mlir::Plugin::DeclBaseOp> PluginServerAPI::GetFuncDecls(uint64_t funcID)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["funcId"] = std::to_string(funcID);
+ string params = root.toStyledString();
+
+ return PluginServer::GetInstance()->GetFuncDeclsResult(funName, params);
+}
+
+mlir::Plugin::FieldDeclOp PluginServerAPI::MakeNode(IDefineCode code)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["defCode"] = std::to_string(static_cast<int32_t>(code));
+ string params = root.toStyledString();
+
+ return PluginServer::GetInstance()->GetMakeNodeResult(funName, params);
+}
+
+llvm::SmallVector<mlir::Plugin::FieldDeclOp> PluginServerAPI::GetFields(uint64_t declID)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["declId"] = std::to_string(declID);
+ string params = root.toStyledString();
+
+ return PluginServer::GetInstance()->GetFieldsResult(funName, params);
+}
+
+void PluginServerAPI::SetDeclName(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetDeclType(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetDeclAlign(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetUserAlign(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+unsigned PluginServerAPI::GetDeclTypeSize(uint64_t declId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["declId"] = std::to_string(declId);
+ string params = root.toStyledString();
+ return PluginServer::GetInstance()->GetIntegerDataResult(funName, params);
+}
+
+void PluginServerAPI::SetSourceLocation(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetAddressable(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetNonAddressablep(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetVolatile(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetDeclContext(uint64_t newfieldId, uint64_t declId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["declId"] = std::to_string(declId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::SetDeclChain(uint64_t newfieldId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["newfieldId"] = std::to_string(newfieldId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+mlir::Plugin::DeclBaseOp PluginServerAPI::BuildDecl(IDefineCode code, llvm::StringRef name, PluginIR::PluginTypeBase type)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["defCode"] = std::to_string(static_cast<int32_t>(code));
+ root["name"] = name.str();
+ PinJson::PluginJson json;
+ root["type"] = json.TypeJsonSerialize(type);
+ string params = root.toStyledString();
+
+ return PluginServer::GetInstance()->GetBuildDeclResult(funName, params);
+}
+
+void PluginServerAPI::SetTypeFields(uint64_t declId, uint64_t fieldId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["declId"] = std::to_string(declId);
+ root["fieldId"] = std::to_string(fieldId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::LayoutType(uint64_t declId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["declId"] = std::to_string(declId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
+void PluginServerAPI::LayoutDecl(uint64_t declId)
+{
+ Json::Value root;
+ string funName = __func__;
+ root["declId"] = std::to_string(declId);
+ string params = root.toStyledString();
+ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params);
+}
+
mlir::Block* PluginServerAPI::BlockResult(const string& funName, const string& params)
{
uint64_t blockId = PluginServer::GetInstance()->GetIdResult(funName, params);
diff --git a/lib/PluginServer/PluginCom.cpp b/lib/PluginServer/PluginCom.cpp
index ddf0605..573de13 100755
--- a/lib/PluginServer/PluginCom.cpp
+++ b/lib/PluginServer/PluginCom.cpp
@@ -65,6 +65,32 @@ mlir::Plugin::CGnodeOp PluginCom::GetCGnodeOpResult(void)
return retop;
}
+vector<mlir::Plugin::DeclBaseOp> PluginCom::GetFuncDeclsResult(void)
+{
+ vector<mlir::Plugin::DeclBaseOp> retOps = declOps;
+ declOps.clear();
+ return retOps;
+}
+
+mlir::Plugin::FieldDeclOp PluginCom::GetMakeNodeResult(void)
+{
+ mlir::Plugin::FieldDeclOp retOp = fielddeclOp;
+ return retOp;
+}
+
+llvm::SmallVector<mlir::Plugin::FieldDeclOp> PluginCom::GetFieldsResult(void)
+{
+ llvm::SmallVector<mlir::Plugin::FieldDeclOp> retOps = fieldsOps;
+ fieldsOps.clear();
+ return retOps;
+}
+
+mlir::Plugin::DeclBaseOp PluginCom::GetBuildDeclResult(void)
+{
+ mlir::Plugin::DeclBaseOp retOp = declOp;
+ return retOp;
+}
+
vector<mlir::Plugin::LoopOp> PluginCom::LoopOpsResult(void)
{
vector<mlir::Plugin::LoopOp> retLoops = loops;
@@ -151,6 +177,14 @@ void PluginCom::JsonDeSerialize(const string& key, const string& data)
json.IdsJsonDeSerialize(data, this->idsResult);
} else if (key == "IdResult") {
this->idResult = atol(data.c_str());
+ } else if (key == "DeclOpResult") {
+ mlir::Value decl = json.DeclBaseOpJsonDeSerialize(data);
+ this->declOp = llvm::dyn_cast<mlir::Plugin::DeclBaseOp>(decl.getDefiningOp());
+ printf("server 164 declop ----------------\n");
+ printf("server 164 declop code %d\n", this->declOp.defCodeAttr().getInt());
+ printf("server 165 declop ----------------\n");
+ } else if (key == "GetFieldsOpResult") {
+ json.FieldOpsJsonDeSerialize(data, this->fieldsOps);
} else if (key == "OpsResult") {
json.OpJsonDeSerialize(data.c_str(), this->opData);
} else if (key == "ValueResult") {
diff --git a/lib/PluginServer/PluginJson.cpp b/lib/PluginServer/PluginJson.cpp
index ba2136b..7c2abbe 100755
--- a/lib/PluginServer/PluginJson.cpp
+++ b/lib/PluginServer/PluginJson.cpp
@@ -375,7 +375,7 @@ void PluginJson::FuncOpJsonDeSerialize(
mlir::Region &bodyRegion = fOp.bodyRegion();
Json::Value regionJson = node["region"];
Json::Value::Members bbMember = regionJson.getMemberNames();
- // We must create Blocks before process ops
+ // We must create Blocks before process opsG
for (size_t bbIdx = 0; bbIdx < bbMember.size(); bbIdx++) {
string blockKey = "block" + std::to_string(bbIdx);
Json::Value blockJson = regionJson[blockKey];
@@ -502,6 +502,42 @@ void PluginJson::LocalDeclOpJsonDeSerialize(
}
}
+void PluginJson::FuncDeclsOpJsonDeSerialize(const string& data,
+ vector<mlir::Plugin::DeclBaseOp>& declOps)
+{
+ Json::Value root;
+ Json::Reader reader;
+ Json::Value node;
+ reader.parse(data, root);
+ Json::Value::Members operation = root.getMemberNames();
+ mlir::OpBuilder opBuilder(PluginServer::GetInstance()->GetContext());
+ for (size_t iter = 0; iter < operation.size(); iter++) {
+ string operationKey = std::to_string(iter);
+ node = root[operationKey];
+ mlir::Value opValue = DeclBaseOpJsonDeSerialize(node.toStyledString()); //ValueJsonDeSerialize(node);
+ DeclBaseOp d = llvm::dyn_cast<DeclBaseOp>(opValue.getDefiningOp());
+ declOps.push_back(d);
+ }
+}
+
+void PluginJson::FieldOpsJsonDeSerialize(const string& data,
+ llvm::SmallVector<mlir::Plugin::FieldDeclOp>& fieldOps)
+{
+ Json::Value root;
+ Json::Reader reader;
+ Json::Value node;
+ reader.parse(data, root);
+ Json::Value::Members operation = root.getMemberNames();
+ mlir::OpBuilder opBuilder(PluginServer::GetInstance()->GetContext());
+ for (size_t iter = 0; iter < operation.size(); iter++) {
+ string operationKey = std::to_string(iter);
+ node = root[operationKey];
+ mlir::Value opValue = FieldDeclOpJsonDeSerialize(node.toStyledString()); //ValueJsonDeSerialize(node);
+ FieldDeclOp d = llvm::dyn_cast<FieldDeclOp>(opValue.getDefiningOp());
+ fieldOps.push_back(d);
+ }
+}
+
void PluginJson::LoopOpsJsonDeSerialize(
const string& data, vector<mlir::Plugin::LoopOp>& loops)
{
@@ -767,7 +803,7 @@ mlir::Value PluginJson::ListOpDeSerialize(const string& data)
mlir::Value opValue = ValueJsonDeSerialize(operandJson[std::to_string(opIter).c_str()]);
ops.push_back(opValue);
}
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value trrelist = opBuilder->create<ListOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::LIST, readOnly, hasPurpose, ops, retType);
@@ -782,7 +818,7 @@ mlir::Value PluginJson::StrOpJsonDeSerialize(const string& data)
uint64_t id = GetID(root["id"]);
mlir::StringRef str(root["str"].asString());
bool readOnly = (bool)atoi(root["readOnly"].asString().c_str());
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value strop = opBuilder->create<StrOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::StrCST, readOnly, str, retType);
@@ -797,7 +833,7 @@ mlir::Value PluginJson::ArrayOpJsonDeSerialize(const string& data)
bool readOnly = (bool)atoi(root["readOnly"].asString().c_str());
mlir::Value base = ValueJsonDeSerialize(root["base"]);
mlir::Value offset = ValueJsonDeSerialize(root["offset"]);
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value arrayref = opBuilder->create<ArrayOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::ArrayRef, readOnly, base, offset, retType);
@@ -820,7 +856,8 @@ mlir::Value PluginJson::DeclBaseOpJsonDeSerialize(const string& data)
if (root["chain"]) {
chain = GetID(root["chain"]);
}
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
+ PluginIR::PluginTypeBase pluginType = retType.dyn_cast<PluginIR::PluginTypeBase>();
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value declOp = opBuilder->create<DeclBaseOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::Decl, readOnly, addressable, used, uid, initial, name, chain, retType);
@@ -842,7 +879,7 @@ mlir::Value PluginJson::FieldDeclOpJsonDeSerialize(const string& data)
uint64_t chain = GetID(root["chain"]);
mlir::Value fieldOffset = ValueJsonDeSerialize(root["fieldOffset"]);
mlir::Value fieldBitOffset = ValueJsonDeSerialize(root["fieldBitOffset"]);
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value fieldOp = opBuilder->create<FieldDeclOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::FieldDecl, readOnly, addressable, used, uid, initial, name, chain,
@@ -858,7 +895,7 @@ mlir::Value PluginJson::AddressOpJsonDeSerialize(const string& data)
uint64_t id = GetID(root["id"]);
bool readOnly = (bool)atoi(root["readOnly"].asString().c_str());
mlir::Value operand = ValueJsonDeSerialize(root["operand"]);
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value addrOp = opBuilder->create<AddressOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::AddrExp, readOnly, operand, retType);
@@ -886,7 +923,7 @@ mlir::Value PluginJson::ConstructorOpJsonDeSerialize(const string& data)
mlir::Value opValue = ValueJsonDeSerialize(valJson[std::to_string(iter).c_str()]);
val.push_back(opValue);
}
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value constructorOp = opBuilder->create<ConstructorOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::Constructor, readOnly, len, idx, val, retType);
@@ -908,7 +945,7 @@ mlir::Value PluginJson::VecOpJsonDeSerialize(const string& data)
mlir::Value opValue = ValueJsonDeSerialize(elementsJson[std::to_string(iter).c_str()]);
elements.push_back(opValue);
}
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value vecOp = opBuilder->create<VecOp>(opBuilder->getUnknownLoc(), id,
IDefineCode::Vec, readOnly, len, elements, retType);
@@ -937,7 +974,7 @@ mlir::Value PluginJson::BlockOpJsonDeSerialize(const string& data)
if (root["abstract_origin"]) {
abstract_origin = ValueJsonDeSerialize(root["abstract_origin"]);
}
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value blockOp = opBuilder->create<BlockOp>(
opBuilder->getUnknownLoc(), id, IDefineCode::BLOCK, readOnly, vars, supercontext, subblocks,
@@ -954,7 +991,7 @@ mlir::Value PluginJson::ComponentOpJsonDeSerialize(const string& data)
bool readOnly = (bool)atoi(root["readOnly"].asString().c_str());
mlir::Value component = ValueJsonDeSerialize(root["component"]);
mlir::Value field = ValueJsonDeSerialize(root["field"]);
- mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString().c_str());
+ mlir::Type retType = TypeJsonDeSerialize(root["retType"].toStyledString());
mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder();
mlir::Value componentOp = opBuilder->create<ComponentOp>(
opBuilder->getUnknownLoc(), id, IDefineCode::COMPONENT, readOnly, component, field, retType);
--
2.33.0
Reference in New Issue View Git Blame Copy Permalink