From abfcc9ab6771b5934568f5284adbc7d13f3510d1 Mon Sep 17 00:00:00 2001 From: dingguangya Date: Tue, 7 Mar 2023 11:41:20 +0800 Subject: [PATCH] [sync] Sync patch from openEuler/pin-server --- ...-refactoring-of-Communication-Subsys.patch | 7 +- ...-refactoring-of-Communication-Subsys.patch | 6 +- ...-refactoring-of-Communication-Subsys.patch | 6 +- 0004-Pin-server-Add-DebugOp.patch | 4 +- ...Pin-server-Add-API-for-LTO-judgement.patch | 4 +- 0006-Pin-server-Fix-bug-for-BuildCallOp.patch | 6 +- ...toring-array-widen-compare-into-a-cl.patch | 4 +- ...ctoring-DEMOs-into-PluginOpt-classes.patch | 4 +- ...r-Support-functiontype-structtype.eg.patch | 4 +- ...omponentOp-ConstructorOp-AddressOp-F.patch | 10 +- ...opOp-EHElseOp-AsmOp-SwitchOp-LabelOp.patch | 8 +- 0012-Pin-server-Support-Vectortype.patch | 4 +- ... 0013-Pin-server-Fix-Definecode-name.patch | 4 +- ...WC-pass-can-complice-can-compile-a-c.patch | 4 +- ...x-for-SwitchOp-change-it-to-terminat.patch | 74 ++ ...in-server-Bugfix-for-GetFunctionById.patch | 152 +++ ...fy-API-parameters-to-improve-usabili.patch | 1046 +++++++++++++++++ ...atch => 0018-Build-Fix-strip-problem.patch | 7 +- 0019-Pin-server-Init-a-SimpleIPAPASS.patch | 174 +++ 0020-Pin-server-Add-CGnodeOp.patch | 325 +++++ ...to-flag-is-used-to-control-the-pass-.patch | 51 + ...upport-for-decl-and-field-SetDeclNam.patch | 701 +++++++++++ ...in-server-Add-StructReorderPASS-demo.patch | 382 ++++++ pin-server.spec | 28 +- 24 files changed, 2970 insertions(+), 45 deletions(-) rename 0013-Pin-server-Support-Vectortype.patch => 0013-Pin-server-Fix-Definecode-name.patch (90%) create mode 100644 0015-Pin-server-Bugfix-for-SwitchOp-change-it-to-terminat.patch create mode 100644 0016-Pin-server-Bugfix-for-GetFunctionById.patch create mode 100644 0017-Refactoring-Modify-API-parameters-to-improve-usabili.patch rename 0015-Pin-server-Fix-strip-problem.patch => 0018-Build-Fix-strip-problem.patch (83%) create mode 100644 0019-Pin-server-Init-a-SimpleIPAPASS.patch create mode 100644 0020-Pin-server-Add-CGnodeOp.patch create mode 100644 0021-Pin-server-The-lto-flag-is-used-to-control-the-pass-.patch create mode 100644 0022-Pin-server-Add-support-for-decl-and-field-SetDeclNam.patch create mode 100644 0023-Pin-server-Add-StructReorderPASS-demo.patch diff --git a/0001-Refactoring-Code-refactoring-of-Communication-Subsys.patch b/0001-Refactoring-Code-refactoring-of-Communication-Subsys.patch index 3913cb1..c5b73b9 100644 --- a/0001-Refactoring-Code-refactoring-of-Communication-Subsys.patch +++ b/0001-Refactoring-Code-refactoring-of-Communication-Subsys.patch @@ -1,8 +1,9 @@ From 7ec62344dcd95cb321647f495d12303c94286ec5 Mon Sep 17 00:00:00 2001 From: wangding16 Date: Wed, 8 Feb 2023 15:05:33 +0800 -Subject: [PATCH 1/9] [Refactoring] Code refactoring of Communication Subsystem - [1/3]. Code refactoring of PluginLog and PluginServer. Add PluginJson. +Subject: [PATCH 01/23] [Refactoring] Code refactoring of Communication + Subsystem [1/3]. Code refactoring of PluginLog and PluginServer. Add + PluginJson. diff --git a/include/user.h b/include/user.h @@ -1967,5 +1968,5 @@ index 7ebc15d..05d0d3d 100644 } } // namespace PinServer -- -2.27.0.windows.1 +2.33.0 diff --git a/0002-Refactoring-Code-refactoring-of-Communication-Subsys.patch b/0002-Refactoring-Code-refactoring-of-Communication-Subsys.patch index 8abb0a3..a96e1ca 100644 --- a/0002-Refactoring-Code-refactoring-of-Communication-Subsys.patch +++ b/0002-Refactoring-Code-refactoring-of-Communication-Subsys.patch @@ -1,8 +1,8 @@ From c1301cbec8465ef4c9c4df597ee46774b6da5715 Mon Sep 17 00:00:00 2001 From: wangding16 Date: Wed, 8 Feb 2023 15:13:54 +0800 -Subject: [PATCH 2/9] [Refactoring] Code refactoring of Communication Subsystem - [2/3]. Code refactoring of PluginServer. +Subject: [PATCH 02/23] [Refactoring] Code refactoring of Communication + Subsystem [2/3]. Code refactoring of PluginServer. diff --git a/include/PluginServer/PluginLog.h b/include/PluginServer/PluginLog.h @@ -2591,5 +2591,5 @@ index cdb0b99..a6fe555 100644 + pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); } -- -2.27.0.windows.1 +2.33.0 diff --git a/0003-Refactoring-Code-refactoring-of-Communication-Subsys.patch b/0003-Refactoring-Code-refactoring-of-Communication-Subsys.patch index 56b7993..1410c60 100644 --- a/0003-Refactoring-Code-refactoring-of-Communication-Subsys.patch +++ b/0003-Refactoring-Code-refactoring-of-Communication-Subsys.patch @@ -1,8 +1,8 @@ From d395986acddf59c379a107fbe6d1b69c74ff2d3b Mon Sep 17 00:00:00 2001 From: wangding16 Date: Wed, 8 Feb 2023 15:16:49 +0800 -Subject: [PATCH 3/9] [Refactoring] Code refactoring of Communication Subsystem - [3/3]. Code refactoring of Communication subsystem. +Subject: [PATCH 03/23] [Refactoring] Code refactoring of Communication + Subsystem [3/3]. Code refactoring of Communication subsystem. diff --git a/CMakeLists.txt b/CMakeLists.txt @@ -1711,5 +1711,5 @@ index 5ab27d7..523e08d 100644 } // namespace Plugin_IR -- -2.27.0.windows.1 +2.33.0 diff --git a/0004-Pin-server-Add-DebugOp.patch b/0004-Pin-server-Add-DebugOp.patch index b3466a6..8f999c2 100644 --- a/0004-Pin-server-Add-DebugOp.patch +++ b/0004-Pin-server-Add-DebugOp.patch @@ -1,7 +1,7 @@ From b14803116c8488a4c765799fd31966991f2031d7 Mon Sep 17 00:00:00 2001 From: benniaobufeijiushiji Date: Sun, 19 Feb 2023 11:43:57 +0800 -Subject: [PATCH 4/9] [Pin-server] Add DebugOp +Subject: [PATCH 04/23] [Pin-server] Add DebugOp diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td @@ -123,5 +123,5 @@ index a6fe555..8163cec 100644 if (!getIvUpperBound(cond)) { return false; -- -2.27.0.windows.1 +2.33.0 diff --git a/0005-Pin-server-Add-API-for-LTO-judgement.patch b/0005-Pin-server-Add-API-for-LTO-judgement.patch index c6b102a..99cca03 100644 --- a/0005-Pin-server-Add-API-for-LTO-judgement.patch +++ b/0005-Pin-server-Add-API-for-LTO-judgement.patch @@ -1,7 +1,7 @@ From 47f1208aab2acb3e1a8442d830125ad3b54149c5 Mon Sep 17 00:00:00 2001 From: benniaobufeijiushiji Date: Sun, 19 Feb 2023 14:40:09 +0800 -Subject: [PATCH 5/9] [Pin-server] Add API for LTO judgement +Subject: [PATCH 05/23] [Pin-server] Add API for LTO judgement diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h @@ -56,5 +56,5 @@ index 523e08d..f81a3ad 100644 + } // namespace Plugin_IR -- -2.27.0.windows.1 +2.33.0 diff --git a/0006-Pin-server-Fix-bug-for-BuildCallOp.patch b/0006-Pin-server-Fix-bug-for-BuildCallOp.patch index 35f3e0a..de8e2df 100644 --- a/0006-Pin-server-Fix-bug-for-BuildCallOp.patch +++ b/0006-Pin-server-Fix-bug-for-BuildCallOp.patch @@ -1,8 +1,8 @@ From 5be0d63fe19decadaebb012efeb03b75aa868228 Mon Sep 17 00:00:00 2001 From: Mingchuan Wu Date: Tue, 21 Feb 2023 16:52:39 +0800 -Subject: [PATCH 6/9] [Pin-server] Fix bug for BuildCallOp. Now we can convert - the function pointer. +Subject: [PATCH 06/23] [Pin-server] Fix bug for BuildCallOp. Now we can + convert the function pointer. diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td @@ -101,5 +101,5 @@ index fac574e..333d55e 100644 LogPriority priority = (LogPriority)atoi(argv[1]); PluginServer server(priority, port); -- -2.27.0.windows.1 +2.33.0 diff --git a/0007-Pin-server-Refactoring-array-widen-compare-into-a-cl.patch b/0007-Pin-server-Refactoring-array-widen-compare-into-a-cl.patch index aa04376..df3a2e9 100644 --- a/0007-Pin-server-Refactoring-array-widen-compare-into-a-cl.patch +++ b/0007-Pin-server-Refactoring-array-widen-compare-into-a-cl.patch @@ -1,7 +1,7 @@ From 1f800efcb93e2868f609c70584966b706ba13031 Mon Sep 17 00:00:00 2001 From: Mingchuan Wu Date: Tue, 21 Feb 2023 17:37:23 +0800 -Subject: [PATCH 7/9] [Pin-server] Refactoring array-widen-compare into a +Subject: [PATCH 07/23] [Pin-server] Refactoring array-widen-compare into a class. @@ -89,5 +89,5 @@ index 0000000..bee70bb + pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); +} -- -2.27.0.windows.1 +2.33.0 diff --git a/0008-Pin-server-Refactoring-DEMOs-into-PluginOpt-classes.patch b/0008-Pin-server-Refactoring-DEMOs-into-PluginOpt-classes.patch index 60cb456..52259f0 100644 --- a/0008-Pin-server-Refactoring-DEMOs-into-PluginOpt-classes.patch +++ b/0008-Pin-server-Refactoring-DEMOs-into-PluginOpt-classes.patch @@ -1,7 +1,7 @@ From 2942cf7b6cdbea40735d5574e21d34d9f665a1fd Mon Sep 17 00:00:00 2001 From: Mingchuan Wu Date: Tue, 21 Feb 2023 17:45:30 +0800 -Subject: [PATCH 8/9] [Pin-server] Refactoring DEMOs into PluginOpt classes. +Subject: [PATCH 08/23] [Pin-server] Refactoring DEMOs into PluginOpt classes. diff --git a/CMakeLists.txt b/CMakeLists.txt @@ -438,5 +438,5 @@ index bee70bb..16f0687 100644 + // pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); } -- -2.27.0.windows.1 +2.33.0 diff --git a/0009-Pin-server-Support-functiontype-structtype.eg.patch b/0009-Pin-server-Support-functiontype-structtype.eg.patch index 01e2398..5c44c40 100644 --- a/0009-Pin-server-Support-functiontype-structtype.eg.patch +++ b/0009-Pin-server-Support-functiontype-structtype.eg.patch @@ -1,7 +1,7 @@ From e2a6f729f4ce40542fccec997529b43d25a6d5ae Mon Sep 17 00:00:00 2001 From: d00573793 Date: Tue, 21 Feb 2023 21:53:44 +0800 -Subject: [PATCH 9/9] [Pin-server] Support functiontype structtype.eg. +Subject: [PATCH 09/23] [Pin-server] Support functiontype structtype.eg. diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td @@ -562,5 +562,5 @@ index 4fc4985..2e157e3 100755 auto decl = decls[j]; string name = decl.symNameAttr().getValue().str(); -- -2.27.0.windows.1 +2.33.0 diff --git a/0010-Pin-server-Add-ComponentOp-ConstructorOp-AddressOp-F.patch b/0010-Pin-server-Add-ComponentOp-ConstructorOp-AddressOp-F.patch index c86cf4a..2439350 100644 --- a/0010-Pin-server-Add-ComponentOp-ConstructorOp-AddressOp-F.patch +++ b/0010-Pin-server-Add-ComponentOp-ConstructorOp-AddressOp-F.patch @@ -1,10 +1,10 @@ From b460122fefb5d4f889c807b704f252948d488893 Mon Sep 17 00:00:00 2001 From: huitailangzju <804544223@qq.com> Date: Wed, 22 Feb 2023 11:42:02 +0800 -Subject: [PATCH 1/5] =?UTF-8?q?[Pin-server]=20Add=20ComponentOp=E3=80=81Co?= - =?UTF-8?q?nstructorOp=E3=80=81AddressOp=E3=80=81FieldDeclOp=E3=80=81VecOp?= - =?UTF-8?q?=E3=80=81BlockOp=E3=80=81DeclBaseOp=E3=80=81ListOp=E3=80=81StrO?= - =?UTF-8?q?p=E3=80=81ArrayOp.?= +Subject: [PATCH 10/23] =?UTF-8?q?[Pin-server]=20Add=20ComponentOp=E3=80=81?= + =?UTF-8?q?ConstructorOp=E3=80=81AddressOp=E3=80=81FieldDeclOp=E3=80=81Vec?= + =?UTF-8?q?Op=E3=80=81BlockOp=E3=80=81DeclBaseOp=E3=80=81ListOp=E3=80=81St?= + =?UTF-8?q?rOp=E3=80=81ArrayOp.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit @@ -846,5 +846,5 @@ index 7bbf681..c5e302f 100755 const string& data, vector& opData) { -- -2.27.0.windows.1 +2.33.0 diff --git a/0011-Pin-server-Add-NopOp-EHElseOp-AsmOp-SwitchOp-LabelOp.patch b/0011-Pin-server-Add-NopOp-EHElseOp-AsmOp-SwitchOp-LabelOp.patch index 7f92356..963f287 100644 --- a/0011-Pin-server-Add-NopOp-EHElseOp-AsmOp-SwitchOp-LabelOp.patch +++ b/0011-Pin-server-Add-NopOp-EHElseOp-AsmOp-SwitchOp-LabelOp.patch @@ -1,9 +1,9 @@ From 190a1e5f5278f4966eb3bcdbdcee950560092216 Mon Sep 17 00:00:00 2001 From: huitailangzju <804544223@qq.com> Date: Wed, 22 Feb 2023 11:54:28 +0800 -Subject: [PATCH 2/5] =?UTF-8?q?[Pin-server]=20Add=20NopOp=E3=80=81EHElseOp?= - =?UTF-8?q?=E3=80=81AsmOp=E3=80=81SwitchOp=E3=80=81LabelOp=E3=80=81EHMntOp?= - =?UTF-8?q?=E3=80=81BindOp=E3=80=81TryOp=E3=80=81CatchOp=E3=80=81GotoOp?= +Subject: [PATCH 11/23] =?UTF-8?q?[Pin-server]=20Add=20NopOp=E3=80=81EHElse?= + =?UTF-8?q?Op=E3=80=81AsmOp=E3=80=81SwitchOp=E3=80=81LabelOp=E3=80=81EHMnt?= + =?UTF-8?q?Op=E3=80=81BindOp=E3=80=81TryOp=E3=80=81CatchOp=E3=80=81GotoOp?= =?UTF-8?q?=E3=80=81TransactionOp=E3=80=81ResxOp=E3=80=81EHDispatchOp.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 @@ -908,5 +908,5 @@ index c5e302f..b849cf9 100755 } // namespace PinJson \ No newline at end of file -- -2.27.0.windows.1 +2.33.0 diff --git a/0012-Pin-server-Support-Vectortype.patch b/0012-Pin-server-Support-Vectortype.patch index 692d1e7..1841141 100644 --- a/0012-Pin-server-Support-Vectortype.patch +++ b/0012-Pin-server-Support-Vectortype.patch @@ -1,7 +1,7 @@ From 50801883d5d5e89d44026ead6e38e149caa346b2 Mon Sep 17 00:00:00 2001 From: d00573793 Date: Sat, 25 Feb 2023 15:31:02 +0800 -Subject: [PATCH 3/5] [Pin-server] Support Vectortype +Subject: [PATCH 12/23] [Pin-server] Support Vectortype diff --git a/include/Dialect/PluginTypes.h b/include/Dialect/PluginTypes.h @@ -147,5 +147,5 @@ index 2e157e3..ccee9f7 100755 llvm::ArrayRef paramsType = ty.getParams(); for (auto ty : ty.getParams()) { -- -2.27.0.windows.1 +2.33.0 diff --git a/0013-Pin-server-Support-Vectortype.patch b/0013-Pin-server-Fix-Definecode-name.patch similarity index 90% rename from 0013-Pin-server-Support-Vectortype.patch rename to 0013-Pin-server-Fix-Definecode-name.patch index 3fded7b..0e0d755 100644 --- a/0013-Pin-server-Support-Vectortype.patch +++ b/0013-Pin-server-Fix-Definecode-name.patch @@ -1,7 +1,7 @@ From 75ac9cb04537b586e77820278600544f83742df3 Mon Sep 17 00:00:00 2001 From: huitailangzju <804544223@qq.com> Date: Sun, 26 Feb 2023 17:09:16 +0800 -Subject: [PATCH 1/2] [Pin-server] Fix Definecode name +Subject: [PATCH 13/23] [Pin-server] Fix Definecode name diff --git a/lib/PluginServer/PluginJson.cpp b/lib/PluginServer/PluginJson.cpp @@ -18,5 +18,5 @@ index b849cf9..2500fe8 100755 break; } -- -2.27.0.windows.1 +2.33.0 diff --git a/0014-Pin-server-Fix-AWC-pass-can-complice-can-compile-a-c.patch b/0014-Pin-server-Fix-AWC-pass-can-complice-can-compile-a-c.patch index 1d7b25b..9167ac2 100644 --- a/0014-Pin-server-Fix-AWC-pass-can-complice-can-compile-a-c.patch +++ b/0014-Pin-server-Fix-AWC-pass-can-complice-can-compile-a-c.patch @@ -1,7 +1,7 @@ From e760e64864b2c5dfb4da010bef3c97ee5575e936 Mon Sep 17 00:00:00 2001 From: d00573793 Date: Sat, 25 Feb 2023 21:03:26 +0800 -Subject: [PATCH 2/2] [Pin-server] Fix AWC pass can complice can compile a +Subject: [PATCH 14/23] [Pin-server] Fix AWC pass can complice can compile a complete program @@ -108,5 +108,5 @@ index 162fdc9..627e7f7 100644 } } -- -2.27.0.windows.1 +2.33.0 diff --git a/0015-Pin-server-Bugfix-for-SwitchOp-change-it-to-terminat.patch b/0015-Pin-server-Bugfix-for-SwitchOp-change-it-to-terminat.patch new file mode 100644 index 0000000..d806124 --- /dev/null +++ b/0015-Pin-server-Bugfix-for-SwitchOp-change-it-to-terminat.patch @@ -0,0 +1,74 @@ +From 2f7eddb9820a2b8d9946431632f27490687af521 Mon Sep 17 00:00:00 2001 +From: huitailangzju <804544223@qq.com> +Date: Mon, 27 Feb 2023 10:02:43 +0800 +Subject: [PATCH 15/23] [Pin-server] Bugfix for SwitchOp, change it to + terminator operation + + +diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td +index 52c3ceb..db7e33f 100644 +--- a/include/Dialect/PluginOps.td ++++ b/include/Dialect/PluginOps.td +@@ -521,29 +521,6 @@ def AsmOp : Plugin_Op<"asm", [NoSideEffect]> { + }]; + } + +-def SwitchOp : Plugin_Op<"switch", [NoSideEffect]> { +- let summary = "switch op."; +- let description = [{TODO}]; +- let successors = (successor +- AnySuccessor:$defaultDestination, +- VariadicSuccessor:$caseDestinations +- ); +- let arguments = (ins UI64Attr:$id, AnyType:$index, UI64Attr:$address, AnyType:$defaultLabel, Variadic:$operands, +- UI64Attr:$defaultaddr, ArrayAttr:$caseaddrs); +- let results = (outs AnyType:$result); +- let builders = [ +- OpBuilderDAG<(ins "uint64_t":$id, "Value":$index, "uint64_t":$address, "Value":$defaultLabel, +- "ArrayRef":$operands, "Block*":$defaultDestination, "uint64_t":$defaultaddr, +- "ArrayRef":$caseDestinations, "ArrayRef":$caseaddrs)> +- ]; +- +- let extraClassDeclaration = [{ +- unsigned GetNumLabels() { return getNumOperands() - 2; }; +- Block* GetDefautDest() { return defaultDestination();} +- SmallVector GetCaseDest() { return caseDestinations(); }; +- }]; +-} +- + def LabelOp : Plugin_Op<"label", [NoSideEffect]> { + let summary = "Label op."; + let description = [{TODO}]; +@@ -612,6 +589,29 @@ def CatchOp : Plugin_Op<"catch", [NoSideEffect]> { + class Plugin_TerminatorOp traits = []> : + Plugin_Op; + ++def SwitchOp : Plugin_TerminatorOp<"switch", [NoSideEffect]> { ++ let summary = "switch op."; ++ let description = [{TODO}]; ++ let successors = (successor ++ AnySuccessor:$defaultDestination, ++ VariadicSuccessor:$caseDestinations ++ ); ++ let arguments = (ins UI64Attr:$id, AnyType:$index, UI64Attr:$address, AnyType:$defaultLabel, Variadic:$operands, ++ UI64Attr:$defaultaddr, ArrayAttr:$caseaddrs); ++ let results = (outs AnyType:$result); ++ let builders = [ ++ OpBuilderDAG<(ins "uint64_t":$id, "Value":$index, "uint64_t":$address, "Value":$defaultLabel, ++ "ArrayRef":$operands, "Block*":$defaultDestination, "uint64_t":$defaultaddr, ++ "ArrayRef":$caseDestinations, "ArrayRef":$caseaddrs)> ++ ]; ++ ++ let extraClassDeclaration = [{ ++ unsigned GetNumLabels() { return getNumOperands() - 2; }; ++ Block* GetDefautDest() { return defaultDestination();} ++ SmallVector GetCaseDest() { return caseDestinations(); }; ++ }]; ++} ++ + def FallThroughOp : Plugin_TerminatorOp<"fallthrough", [NoSideEffect]> { + let summary = "FallThroughOp"; + let description = [{TODO}]; +-- +2.33.0 + diff --git a/0016-Pin-server-Bugfix-for-GetFunctionById.patch b/0016-Pin-server-Bugfix-for-GetFunctionById.patch new file mode 100644 index 0000000..a7d5d72 --- /dev/null +++ b/0016-Pin-server-Bugfix-for-GetFunctionById.patch @@ -0,0 +1,152 @@ +From 5b2e40badcd1d32180895e09edf208d052be25bf Mon Sep 17 00:00:00 2001 +From: Mingchuan Wu +Date: Mon, 27 Feb 2023 16:23:59 +0800 +Subject: [PATCH 16/23] [Pin-server] Bugfix for GetFunctionById. + + +diff --git a/lib/PluginAPI/PluginServerAPI.cpp b/lib/PluginAPI/PluginServerAPI.cpp +index 8ef10d1..ff9c90e 100644 +--- a/lib/PluginAPI/PluginServerAPI.cpp ++++ b/lib/PluginAPI/PluginServerAPI.cpp +@@ -75,6 +75,7 @@ static uint64_t GetValueId(mlir::Value v) + } + return 0; + } ++ + int64_t PluginServerAPI::GetInjectDataAddress() + { + string funName = __func__; +@@ -173,24 +174,26 @@ mlir::Value PluginServerAPI::CreateSSAOp(mlir::Type t) + vector PluginServerAPI::GetAllFunc() + { + Json::Value root; +- string funName = __func__; ++ string funName = "GetFunctionIDs"; + string params = root.toStyledString(); +- +- return PluginServer::GetInstance()->GetFunctionOpResult(funName, params); ++ vector res; ++ vector ids = PluginServer::GetInstance()->GetIdsResult(funName, params); ++ for (auto id : ids) { ++ res.push_back(GetFunctionOpById(id)); ++ } ++ return res; + } + + FunctionOp PluginServerAPI::GetFunctionOpById(uint64_t id) + { +- vector allFunction = GetAllFunc(); ++ Json::Value root; ++ string funName = __func__; ++ root["id"] = std::to_string(id); ++ string params = root.toStyledString(); ++ vector funcOps = PluginServer::GetInstance()->GetFunctionOpResult(funName, params); + FunctionOp funOp = nullptr; +- +- for (auto &funcOp : allFunction) { +- if (funcOp.id() == id) { +- funOp = funcOp; +- break; +- } +- } +- assert(funOp != nullptr); ++ if (funcOps.size()) ++ funOp = funcOps[0]; + return funOp; + } + +diff --git a/lib/PluginServer/PluginJson.cpp b/lib/PluginServer/PluginJson.cpp +index ca75764..14a6ef4 100755 +--- a/lib/PluginServer/PluginJson.cpp ++++ b/lib/PluginServer/PluginJson.cpp +@@ -587,7 +587,7 @@ void PluginJson::IdsJsonDeSerialize( + reader.parse(data, root); + Json::Value::Members operation = root.getMemberNames(); + for (size_t iter = 0; iter < operation.size(); iter++) { +- string operationKey = "block" + std::to_string(iter); ++ string operationKey = "ID" + std::to_string(iter); + node = root[operationKey]; + uint64_t id = GetID(node["id"]); + idsResult.push_back(id); +diff --git a/lib/PluginServer/PluginServer.cpp b/lib/PluginServer/PluginServer.cpp +index d2a1736..8778019 100644 +--- a/lib/PluginServer/PluginServer.cpp ++++ b/lib/PluginServer/PluginServer.cpp +@@ -46,6 +46,10 @@ bool PluginServer::RegisterOpt(std::shared_ptr optBase) + if ((inject >= HANDLE_MAX) || (optBase == nullptr)) { + return false; + } ++ if (inject == HANDLE_MANAGER_SETUP) { ++ log->LOGE("inject HANDLE_MANAGER_SETUP should use interface RegisterPassManagerOpt!\n"); ++ return false; ++ } + + string name = "funcname" + std::to_string((uintptr_t)optBase.get()); + userOpts[inject].push_back(RecordedOpt(name, optBase)); +diff --git a/user/ArrayWidenPass.cpp b/user/ArrayWidenPass.cpp +index 627e7f7..6fb187c 100644 +--- a/user/ArrayWidenPass.cpp ++++ b/user/ArrayWidenPass.cpp +@@ -44,42 +44,6 @@ mlir::OpBuilder* opBuilder = nullptr; + std::map defs_map; + std::map opNameMap; + +-static void UserOptimizeFunc(void) +-{ +- PluginServerAPI pluginAPI; +- vector allFunction = pluginAPI.GetAllFunc(); +- int count = 0; +- for (size_t i = 0; i < allFunction.size(); i++) { +- if (allFunction[i].declaredInlineAttr().getValue()) +- count++; +- } +- printf("declaredInline have %d functions were declared.\n", count); +-} +- +-static void LocalVarSummery(void) +-{ +- PluginServerAPI pluginAPI; +- vector allFunction = pluginAPI.GetAllFunc(); +- map args = PluginServer::GetInstance()->GetArgs(); +- for (size_t i = 0; i < allFunction.size(); i++) { +- uint64_t funcID = allFunction[i].idAttr().getValue().getZExtValue(); +- printf("In the %ldth function:\n", i); +- vector decls = pluginAPI.GetDecls(funcID); +- int64_t typeFilter = -1u; +- if (args.find("type_code") != args.end()) { +- typeFilter = (int64_t)pluginAPI.GetTypeCodeFromString(args["type_code"]); +- } +- for (size_t j = 0; j < decls.size(); j++) { +- auto decl = decls[j]; +- string name = decl.symNameAttr().getValue().str(); +- int64_t declTypeID = decl.typeIDAttr().getValue().getZExtValue(); +- if (declTypeID == typeFilter) { +- printf("\tFind %ldth target type %s\n", j, name.c_str()); +- } +- } +- } +-} +- + static void PassManagerSetupFunc(void) + { + printf("PassManagerSetupFunc in\n"); +@@ -1385,7 +1349,7 @@ static void create_epilogue_loop_body_bb(Block *epilogue_loop_body_bb, Block* af + + Value res = g.GetLHS(); + cond_stmt = opBuilder->create(opBuilder->getUnknownLoc(), +- llvm::dyn_cast(originLoop.condOp1).condCode(), res, originLoop.limit, tb, fb, (epilogue_loop_body_bb)); ++ llvm::dyn_cast(originLoop.condOp1).condCode(), lhs2, res, tb, fb, (epilogue_loop_body_bb)); + + defs_map.emplace(epilogue_loop_body_bb, baseSsa.GetCurrentDef()); + } +@@ -1540,6 +1504,7 @@ static void ProcessArrayWiden(uint64_t *fun) + PluginServerAPI pluginAPI; + + FunctionOp funcOp = pluginAPI.GetFunctionOpById((uint64_t)fun); ++ if (funcOp == nullptr) return; + + context = funcOp.getOperation()->getContext(); + mlir::OpBuilder opBuilder_temp = mlir::OpBuilder(context); +-- +2.33.0 + diff --git a/0017-Refactoring-Modify-API-parameters-to-improve-usabili.patch b/0017-Refactoring-Modify-API-parameters-to-improve-usabili.patch new file mode 100644 index 0000000..1bbd341 --- /dev/null +++ b/0017-Refactoring-Modify-API-parameters-to-improve-usabili.patch @@ -0,0 +1,1046 @@ +From 23cf14c4b59fc8dfc8d696ee50cd86a6122f0686 Mon Sep 17 00:00:00 2001 +From: Mingchuan Wu +Date: Wed, 1 Mar 2023 16:04:51 +0800 +Subject: [PATCH 17/23] [Refactoring] Modify API parameters to improve + usability. + + +diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td +index 93ba116..47909c7 100644 +--- a/include/Dialect/PluginOps.td ++++ b/include/Dialect/PluginOps.td +@@ -95,7 +95,7 @@ def LoopOp : Plugin_Op<"loop", [NoSideEffect]> { + bool IsLoopFather(mlir::Block*); + std::vector > GetExitEdges(); + std::vector GetLoopBody(); +- void AddLoop(uint64_t, uint64_t); ++ void AddLoop(LoopOp *, FunctionOp *); + void AddBlock(mlir::Block*); + }]; + } +@@ -118,9 +118,8 @@ def CallOp : Plugin_Op<"call", [ + OpBuilderDAG<(ins "int64_t":$id, + "ArrayRef":$arguments)>, + // Only for server. +- OpBuilderDAG<(ins "Value":$func, +- "ArrayRef":$arguments, "Block *":$block)>, +- OpBuilderDAG<(ins "ArrayRef":$arguments, "Block *":$block)> ++ OpBuilderDAG<(ins "Value":$func, "ArrayRef":$arguments)>, ++ OpBuilderDAG<(ins "ArrayRef":$arguments)> + ]; + let extraClassDeclaration = [{ + bool SetLHS(Value lhs); +@@ -160,7 +159,7 @@ def AssignOp : Plugin_Op<"assign", [NoSideEffect]> { + "uint64_t":$id, "IExprCode":$exprCode)>, + // Only for server. + OpBuilderDAG<(ins "ArrayRef":$operands, +- "IExprCode":$exprCode, "Block *":$block)> ++ "IExprCode":$exprCode)> + ]; + let extraClassDeclaration = [{ + Value GetLHS() { return getOperand(0); } +@@ -625,7 +624,7 @@ def FallThroughOp : Plugin_TerminatorOp<"fallthrough", [NoSideEffect]> { + let builders = [ + OpBuilderDAG<(ins "uint64_t":$address, "Block*":$dest, "uint64_t":$destaddr)>, + // Only for server. +- OpBuilderDAG<(ins "uint64_t":$address, "Block*":$dest)> ++ OpBuilderDAG<(ins "Block*":$src, "Block*":$dest)> + ]; + } + +@@ -646,8 +645,8 @@ def CondOp : Plugin_TerminatorOp<"condition", [NoSideEffect]> { + "uint64_t":$tbaddr, "uint64_t":$fbaddr, "Value":$trueLabel, + "Value":$falseLabel)>, + // Only for server. +- OpBuilderDAG<(ins "IComparisonCode":$condCode, "Value":$lhs, "Value":$rhs, +- "Block*":$tb, "Block*":$fb, "Block *":$block)> ++ OpBuilderDAG<(ins "IComparisonCode":$condCode, "Value":$lhs, ++ "Value":$rhs, "Block*":$tb, "Block*":$fb)> + ]; + let extraClassDeclaration = [{ + Value GetLHS() { return getOperand(0); } +diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h +index 923dd44..6f0a4af 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -52,13 +52,13 @@ public: + virtual vector GetLoopsFromFunc(uint64_t) = 0; + virtual LoopOp GetLoopById(uint64_t) = 0; + virtual void AddLoop(uint64_t, uint64_t, uint64_t) = 0; +- virtual void AddBlockToLoop(uint64_t, uint64_t) = 0; ++ virtual void AddBlockToLoop(mlir::Block*, LoopOp *) = 0; + virtual void DeleteLoop(uint64_t) = 0; + virtual vector GetLoopBody(uint64_t) = 0; + virtual bool IsBlockInLoop(uint64_t, uint64_t) = 0; + virtual pair LoopSingleExit(uint64_t) = 0; + virtual vector > GetLoopExitEdges(uint64_t) = 0; +- virtual LoopOp GetBlockLoopFather(uint64_t) = 0; ++ virtual LoopOp GetBlockLoopFather(mlir::Block*) = 0; + virtual PhiOp GetPhiOp(uint64_t) = 0; + virtual CallOp GetCallOp(uint64_t) = 0; + virtual bool SetLhsInCallOp(uint64_t, uint64_t) = 0; +@@ -80,7 +80,7 @@ public: + virtual mlir::Value CreateSSAOp(mlir::Type) = 0; + virtual mlir::Value ConfirmValue(mlir::Value) = 0; + virtual mlir::Value BuildMemRef(PluginIR::PluginTypeBase, mlir::Value, mlir::Value) = 0; +- virtual bool RedirectFallthroughTarget(FallThroughOp&, uint64_t, uint64_t) = 0; ++ virtual bool RedirectFallthroughTarget(FallThroughOp&, mlir::Block*, mlir::Block*) = 0; + virtual mlir::Operation* GetSSADefOperation(uint64_t) = 0; + }; // class BasicPluginOpsAPI + } // namespace PluginAPI +diff --git a/include/PluginAPI/ControlFlowAPI.h b/include/PluginAPI/ControlFlowAPI.h +index a436e85..429ba11 100644 +--- a/include/PluginAPI/ControlFlowAPI.h ++++ b/include/PluginAPI/ControlFlowAPI.h +@@ -41,15 +41,16 @@ public: + bool UpdateSSA(void); + vector GetAllPhiOpInsideBlock(mlir::Block *b); + +- uint64_t CreateBlock(mlir::Block*, uint64_t, uint64_t); +- void DeleteBlock(mlir::Block*, uint64_t, uint64_t); +- void SetImmediateDominator(uint64_t, uint64_t, uint64_t); ++ mlir::Block* CreateBlock(mlir::Block*, FunctionOp*); ++ void DeleteBlock(mlir::Block*, FunctionOp*); ++ void SetImmediateDominator(uint64_t, mlir::Block*, uint64_t); ++ void SetImmediateDominator(uint64_t, mlir::Block*, mlir::Block*); + uint64_t GetImmediateDominator(uint64_t, uint64_t); +- uint64_t RecomputeDominator(uint64_t, uint64_t); ++ uint64_t RecomputeDominator(uint64_t, mlir::Block*); + mlir::Value CreateNewDef(mlir::Value, mlir::Operation *); + + void CreateFallthroughOp(uint64_t, uint64_t); +- void RemoveEdge(uint64_t, uint64_t); ++ void RemoveEdge(mlir::Block*, mlir::Block*); + private: + bool GetUpdateOperationResult(const string &funName); + vector GetPhiOperationResult(const string &funName, const string& params); +diff --git a/include/PluginAPI/PluginServerAPI.h b/include/PluginAPI/PluginServerAPI.h +index 3da28f5..0d6a5bc 100644 +--- a/include/PluginAPI/PluginServerAPI.h ++++ b/include/PluginAPI/PluginServerAPI.h +@@ -48,15 +48,15 @@ public: + bool IsBlockInLoop(uint64_t loopID, uint64_t blockID); + void DeleteLoop(uint64_t loopID); + void AddLoop(uint64_t loopID, uint64_t outerID, uint64_t funcID); +- void AddBlockToLoop(uint64_t blockID, uint64_t loopID); ++ void AddBlockToLoop(mlir::Block*, LoopOp *); + pair LoopSingleExit(uint64_t loopID); + vector > GetLoopExitEdges(uint64_t loopID); + mlir::Block* GetHeader(uint64_t loopID); + mlir::Block* GetLatch(uint64_t loopID); +- void SetHeader(uint64_t loopID, uint64_t blockID); +- void SetLatch(uint64_t loopID, uint64_t blockID); ++ void SetHeader(LoopOp*, mlir::Block*); ++ void SetLatch(LoopOp*, mlir::Block*); + vector GetLoopBody(uint64_t loopID); +- LoopOp GetBlockLoopFather(uint64_t blockID); ++ LoopOp GetBlockLoopFather(mlir::Block*); + mlir::Block* FindBlock(uint64_t); + uint64_t FindBasicBlock(mlir::Block*); + bool InsertValue(uint64_t, mlir::Value); +@@ -84,7 +84,7 @@ public: + mlir::Value CreateSSAOp(mlir::Type) override; + mlir::Value ConfirmValue(mlir::Value); + mlir::Value BuildMemRef(PluginIR::PluginTypeBase, mlir::Value, mlir::Value); +- bool RedirectFallthroughTarget(FallThroughOp&, uint64_t, uint64_t) override; ++ bool RedirectFallthroughTarget(FallThroughOp&, mlir::Block*, mlir::Block*) override; + mlir::Operation* GetSSADefOperation(uint64_t) override; + void InsertCreatedBlock(uint64_t id, mlir::Block* block); + +diff --git a/lib/Dialect/PluginOps.cpp b/lib/Dialect/PluginOps.cpp +index ab0e3ce..5beb558 100644 +--- a/lib/Dialect/PluginOps.cpp ++++ b/lib/Dialect/PluginOps.cpp +@@ -163,17 +163,13 @@ Block* LoopOp::GetLatch() + void LoopOp::SetHeader(mlir::Block* b) + { + PluginAPI::PluginServerAPI pluginAPI; +- uint64_t loopId = idAttr().getInt(); +- uint64_t blockId = pluginAPI.FindBasicBlock(b); +- pluginAPI.SetHeader(loopId, blockId); ++ pluginAPI.SetHeader(this, b); + } + + void LoopOp::SetLatch(mlir::Block* b) + { + PluginAPI::PluginServerAPI pluginAPI; +- uint64_t loopId = idAttr().getInt(); +- uint64_t blockId = pluginAPI.FindBasicBlock(b); +- pluginAPI.SetLatch(loopId, blockId); ++ pluginAPI.SetLatch(this, b); + } + + vector LoopOp::GetLoopBody() +@@ -223,8 +219,7 @@ bool LoopOp::IsLoopFather(mlir::Block* b) + { + PluginAPI::PluginServerAPI pluginAPI; + uint64_t loopId = idAttr().getInt(); +- uint64_t blockId = pluginAPI.FindBasicBlock(b); +- LoopOp loopFather = pluginAPI.GetBlockLoopFather(blockId); ++ LoopOp loopFather = pluginAPI.GetBlockLoopFather(b); + uint64_t id = loopFather.idAttr().getInt(); + return id == loopId; + } +@@ -236,19 +231,18 @@ vector > LoopOp::GetExitEdges() + return pluginAPI.GetLoopExitEdges(loopId); + } + +-void LoopOp::AddLoop(uint64_t outerId, uint64_t funcId) ++void LoopOp::AddLoop(LoopOp* outerLoop, FunctionOp* funcOp) + { + PluginAPI::PluginServerAPI pluginAPI; + uint64_t loopId = idAttr().getInt(); +- return pluginAPI.AddLoop(loopId, outerId, funcId); ++ return pluginAPI.AddLoop(loopId, outerLoop->idAttr().getInt(), ++ funcOp->idAttr().getInt()); + } + + void LoopOp::AddBlock(mlir::Block* block) + { + PluginAPI::PluginServerAPI pluginAPI; +- uint64_t blockId = pluginAPI.FindBasicBlock(block); +- uint64_t loopId = idAttr().getInt(); +- pluginAPI.AddBlockToLoop(blockId, loopId); ++ pluginAPI.AddBlockToLoop(block, this); + } + + // ===----------------------------------------------------------------------===// +@@ -595,9 +589,12 @@ bool CallOp::SetLHS(Value lhs) + } + + void CallOp::build(OpBuilder &builder, OperationState &state, +- Value func, ArrayRef arguments, Block * block) ++ Value func, ArrayRef arguments) + { ++ Block *insertionBlock = builder.getInsertionBlock(); ++ assert(insertionBlock && "No InsertPoint is set for the OpBuilder."); + PluginAPI::PluginServerAPI pluginAPI; ++ uint64_t blockId = pluginAPI.FindBasicBlock(insertionBlock); + PlaceholderOp funcOp = func.getDefiningOp(); + uint64_t funcId = funcOp.idAttr().getInt(); + vector argIds; +@@ -605,7 +602,6 @@ void CallOp::build(OpBuilder &builder, OperationState &state, + uint64_t argId = GetValueId(v); + argIds.push_back(argId); + } +- uint64_t blockId = pluginAPI.FindBasicBlock(block); + uint64_t id = pluginAPI.CreateCallOp(blockId, funcId, argIds); + state.addAttribute("id", builder.getI64IntegerAttr(id)); + state.addOperands(arguments); +@@ -614,15 +610,17 @@ void CallOp::build(OpBuilder &builder, OperationState &state, + } + + void CallOp::build(OpBuilder &builder, OperationState &state, +- ArrayRef arguments, Block * block) ++ ArrayRef arguments) + { ++ Block *insertionBlock = builder.getInsertionBlock(); ++ assert(insertionBlock && "No InsertPoint is set for the OpBuilder."); + PluginAPI::PluginServerAPI pluginAPI; ++ uint64_t blockId = pluginAPI.FindBasicBlock(insertionBlock); + vector argIds; + for (auto v : arguments) { + uint64_t argId = GetValueId(v); + argIds.push_back(argId); + } +- uint64_t blockId = pluginAPI.FindBasicBlock(block); + uint64_t funcId = 0; + uint64_t id = pluginAPI.CreateCallOp(blockId, funcId, argIds); + state.addAttribute("id", builder.getI64IntegerAttr(id)); +@@ -653,12 +651,14 @@ void CondOp::build(OpBuilder &builder, OperationState &state, + + void CondOp::build(OpBuilder &builder, OperationState &state, + IComparisonCode condCode, Value lhs, Value rhs, Block* tb, +- Block* fb, Block * block) ++ Block* fb) + { ++ Block *insertionBlock = builder.getInsertionBlock(); ++ assert(insertionBlock && "No InsertPoint is set for the OpBuilder."); + PluginAPI::PluginServerAPI pluginAPI; ++ uint64_t blockId = pluginAPI.FindBasicBlock(insertionBlock); + uint64_t lhsId = GetValueId(lhs); + uint64_t rhsId = GetValueId(rhs); +- uint64_t blockId = pluginAPI.FindBasicBlock(block); + uint64_t tbaddr = pluginAPI.FindBasicBlock(tb); + uint64_t fbaddr = pluginAPI.FindBasicBlock(fb); + uint64_t id = pluginAPI.CreateCondOp(blockId, condCode, lhsId, rhsId, +@@ -737,16 +737,17 @@ void AssignOp::build(OpBuilder &builder, OperationState &state, + } + + void AssignOp::build(OpBuilder &builder, OperationState &state, +- ArrayRef operands, IExprCode exprCode, +- Block * block) ++ ArrayRef operands, IExprCode exprCode) + { ++ Block *insertionBlock = builder.getInsertionBlock(); ++ assert(insertionBlock && "No InsertPoint is set for the OpBuilder."); + PluginAPI::PluginServerAPI pluginAPI; ++ uint64_t blockId = pluginAPI.FindBasicBlock(insertionBlock); + vector argIds; + for (auto v : operands) { + uint64_t argId = GetValueId(v); + argIds.push_back(argId); + } +- uint64_t blockId = pluginAPI.FindBasicBlock(block); + uint64_t id = pluginAPI.CreateAssignOp(blockId, exprCode, argIds); + state.addAttribute("id", builder.getI64IntegerAttr(id)); + state.addAttribute("exprCode", +@@ -821,7 +822,7 @@ void SwitchOp::build(OpBuilder &builder, OperationState &state, + state.addAttribute("address", builder.getI64IntegerAttr(address)); + state.addAttribute("defaultaddr", builder.getI64IntegerAttr(defaultaddr)); + llvm::SmallVector attributes; +- for (int i = 0; i < caseaddr.size(); ++i) { ++ for (size_t i = 0; i < caseaddr.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(caseaddr[i])); + } + state.addAttribute("caseaddrs", builder.getArrayAttr(attributes)); +@@ -842,9 +843,10 @@ void FallThroughOp::build(OpBuilder &builder, OperationState &state, + } + + void FallThroughOp::build(OpBuilder &builder, OperationState &state, +- uint64_t address, Block* dest) ++ Block* src, Block* dest) + { + PluginAPI::PluginServerAPI pluginAPI; ++ uint64_t address = pluginAPI.FindBasicBlock(src); + uint64_t destaddr = pluginAPI.FindBasicBlock(dest); + + PluginAPI::ControlFlowAPI cfgAPI; +@@ -892,7 +894,7 @@ void TransactionOp::build(OpBuilder &builder, OperationState &state, uint64_t id + state.addAttribute("id", builder.getI64IntegerAttr(id)); + state.addAttribute("address", builder.getI64IntegerAttr(address)); + llvm::SmallVector attributes; +- for (int i = 0; i < stmtaddr.size(); ++i) { ++ for (size_t i = 0; i < stmtaddr.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(stmtaddr[i])); + } + state.addAttribute("stmtaddr", builder.getArrayAttr(attributes)); +@@ -932,7 +934,7 @@ void EHDispatchOp::build(OpBuilder &builder, OperationState &state, uint64_t id, + state.addAttribute("region", builder.getI64IntegerAttr(region)); + state.addSuccessors(ehHandlers); + llvm::SmallVector attributes; +- for (int i = 0; i < ehHandlersaddrs.size(); ++i) { ++ for (size_t i = 0; i < ehHandlersaddrs.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(ehHandlersaddrs[i])); + } + state.addAttribute("ehHandlersaddrs", builder.getArrayAttr(attributes)); +@@ -946,7 +948,7 @@ void BindOp::build(OpBuilder &builder, OperationState &state, uint64_t id, Value + state.addAttribute("id", builder.getI64IntegerAttr(id)); + state.addOperands({vars, block}); + llvm::SmallVector attributes; +- for (int i = 0; i < body.size(); ++i) { ++ for (size_t i = 0; i < body.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(body[i])); + } + state.addAttribute("body", builder.getArrayAttr(attributes)); +@@ -960,12 +962,12 @@ void TryOp::build(OpBuilder &builder, OperationState &state, uint64_t id, ArrayR + { + state.addAttribute("id", builder.getI64IntegerAttr(id)); + llvm::SmallVector attributes; +- for (int i = 0; i < eval.size(); ++i) { ++ for (size_t i = 0; i < eval.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(eval[i])); + } + state.addAttribute("eval", builder.getArrayAttr(attributes)); + attributes.clear(); +- for (int i = 0; i < cleanup.size(); ++i) { ++ for (size_t i = 0; i < cleanup.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(cleanup[i])); + } + state.addAttribute("cleanup", builder.getArrayAttr(attributes)); +@@ -980,7 +982,7 @@ void CatchOp::build(OpBuilder &builder, OperationState &state, uint64_t id, Valu + state.addAttribute("id", builder.getI64IntegerAttr(id)); + state.addOperands(types); + llvm::SmallVector attributes; +- for (int i = 0; i < handler.size(); ++i) { ++ for (size_t i = 0; i < handler.size(); ++i) { + attributes.push_back(builder.getI64IntegerAttr(handler[i])); + } + state.addAttribute("handler", builder.getArrayAttr(attributes)); +diff --git a/lib/PluginAPI/ControlFlowAPI.cpp b/lib/PluginAPI/ControlFlowAPI.cpp +index 720bac5..b356ae9 100644 +--- a/lib/PluginAPI/ControlFlowAPI.cpp ++++ b/lib/PluginAPI/ControlFlowAPI.cpp +@@ -110,24 +110,30 @@ vector ControlFlowAPI::GetAllPhiOpInsideBlock(mlir::Block *b) + return GetPhiOperationResult(funName, params); + } + +-uint64_t ControlFlowAPI::CreateBlock(mlir::Block* b, uint64_t funcAddr, uint64_t bbAddr) ++mlir::Block* ControlFlowAPI::CreateBlock(mlir::Block* b, FunctionOp *funcOp) + { + Json::Value root; + string funName = __func__; ++ uint64_t funcAddr = funcOp->idAttr().getInt(); + assert(funcAddr); ++ PluginServer *server = PluginServer::GetInstance(); ++ uint64_t bbAddr = server->FindBasicBlock(b); + assert(bbAddr); + root["funcaddr"] = std::to_string(funcAddr); + root["bbaddr"] = std::to_string(bbAddr); + string params = root.toStyledString(); +- PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); +- return PluginServer::GetInstance()->GetBlockResult(b); ++ server->RemoteCallClientWithAPI(funName, params); ++ uint64_t retId = server->GetBlockResult(b); ++ return server->FindBlock(retId); + } + +-void ControlFlowAPI::DeleteBlock(mlir::Block* b, uint64_t funcAddr, uint64_t bbAddr) ++void ControlFlowAPI::DeleteBlock(mlir::Block* b, FunctionOp* funcOp) + { + Json::Value root; + string funName = __func__; ++ uint64_t funcAddr = funcOp->idAttr().getInt(); + assert(funcAddr); ++ uint64_t bbAddr = PluginServer::GetInstance()->FindBasicBlock(b); + assert(bbAddr); + root["funcaddr"] = std::to_string(funcAddr); + root["bbaddr"] = std::to_string(bbAddr); +@@ -137,10 +143,29 @@ void ControlFlowAPI::DeleteBlock(mlir::Block* b, uint64_t funcAddr, uint64_t bbA + } + + /* dir: 1 or 2 */ +-void ControlFlowAPI::SetImmediateDominator(uint64_t dir, uint64_t bbAddr, uint64_t domiAddr) ++void ControlFlowAPI::SetImmediateDominator(uint64_t dir, mlir::Block* bb, uint64_t domiAddr) ++{ ++ Json::Value root; ++ string funName = __func__; ++ PluginServer *server = PluginServer::GetInstance(); ++ uint64_t bbAddr = server->FindBasicBlock(bb); ++ if (!bbAddr || !domiAddr) return; ++ assert(dir && bbAddr && domiAddr); ++ root["dir"] = std::to_string(dir); ++ root["bbaddr"] = std::to_string(bbAddr); ++ root["domiaddr"] = std::to_string(domiAddr); ++ string params = root.toStyledString(); ++ PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); ++} ++ ++void ControlFlowAPI::SetImmediateDominator(uint64_t dir, mlir::Block* bb, ++ mlir::Block* domi) + { + Json::Value root; + string funName = __func__; ++ PluginServer *server = PluginServer::GetInstance(); ++ uint64_t bbAddr = server->FindBasicBlock(bb); ++ uint64_t domiAddr = server->FindBasicBlock(domi); + if (!bbAddr || !domiAddr) return; + assert(dir && bbAddr && domiAddr); + root["dir"] = std::to_string(dir); +@@ -163,10 +188,11 @@ uint64_t ControlFlowAPI::GetImmediateDominator(uint64_t dir, uint64_t bbAddr) + } + + /* dir: 1 or 2 */ +-uint64_t ControlFlowAPI::RecomputeDominator(uint64_t dir, uint64_t bbAddr) ++uint64_t ControlFlowAPI::RecomputeDominator(uint64_t dir, mlir::Block* bb) + { + Json::Value root; + string funName = __func__; ++ uint64_t bbAddr = PluginServer::GetInstance()->FindBasicBlock(bb); + assert(dir && bbAddr); + root["dir"] = std::to_string(dir); + root["bbaddr"] = std::to_string(bbAddr); +@@ -201,10 +227,12 @@ void ControlFlowAPI::CreateFallthroughOp( + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + } + +-void ControlFlowAPI::RemoveEdge(uint64_t src, uint64_t dest) ++void ControlFlowAPI::RemoveEdge(mlir::Block* srcBB, mlir::Block* destBB) + { + Json::Value root; + string funName = __func__; ++ uint64_t src = PluginServer::GetInstance()->FindBasicBlock(srcBB); ++ uint64_t dest = PluginServer::GetInstance()->FindBasicBlock(destBB); + root["src"] = std::to_string(src); + root["dest"] = std::to_string(dest); + string params = root.toStyledString(); +diff --git a/lib/PluginAPI/PluginServerAPI.cpp b/lib/PluginAPI/PluginServerAPI.cpp +index ff9c90e..6a52dd6 100644 +--- a/lib/PluginAPI/PluginServerAPI.cpp ++++ b/lib/PluginAPI/PluginServerAPI.cpp +@@ -486,12 +486,12 @@ void PluginServerAPI::AddLoop(uint64_t loopID, uint64_t outerID, uint64_t funcID + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + } + +-void PluginServerAPI::AddBlockToLoop(uint64_t blockID, uint64_t loopID) ++void PluginServerAPI::AddBlockToLoop(mlir::Block* b, LoopOp *loop) + { + Json::Value root; + string funName("AddBlockToLoop"); +- root["blockId"] = blockID; +- root["loopId"] = loopID; ++ root["blockId"] = PluginServer::GetInstance()->FindBasicBlock(b); ++ root["loopId"] = loop->idAttr().getInt(); + string params = root.toStyledString(); + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + } +@@ -527,22 +527,24 @@ mlir::Block* PluginServerAPI::GetLatch(uint64_t loopID) + return BlockResult(funName, params); + } + +-void PluginServerAPI::SetHeader(uint64_t loopID, uint64_t blockID) ++void PluginServerAPI::SetHeader(LoopOp * loop, mlir::Block* b) + { + Json::Value root; + string funName("SetHeader"); +- root["loopId"] = std::to_string(loopID); +- root["blockId"] = std::to_string(blockID); ++ root["loopId"] = std::to_string(loop->idAttr().getInt()); ++ root["blockId"] = std::to_string( ++ PluginServer::GetInstance()->FindBasicBlock(b)); + string params = root.toStyledString(); + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + } + +-void PluginServerAPI::SetLatch(uint64_t loopID, uint64_t blockID) ++void PluginServerAPI::SetLatch(LoopOp * loop, mlir::Block* b) + { + Json::Value root; + string funName("SetLatch"); +- root["loopId"] = std::to_string(loopID); +- root["blockId"] = std::to_string(blockID); ++ root["loopId"] = std::to_string(loop->idAttr().getInt()); ++ root["blockId"] = std::to_string( ++ PluginServer::GetInstance()->FindBasicBlock(b)); + string params = root.toStyledString(); + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + } +@@ -574,11 +576,12 @@ vector PluginServerAPI::GetLoopBody(uint64_t loopID) + return BlocksResult(funName, params); + } + +-LoopOp PluginServerAPI::GetBlockLoopFather(uint64_t blockID) ++LoopOp PluginServerAPI::GetBlockLoopFather(mlir::Block* b) + { + Json::Value root; + string funName("GetBlockLoopFather"); +- root["blockId"] = std::to_string(blockID); ++ root["blockId"] = std::to_string( ++ PluginServer::GetInstance()->FindBasicBlock(b)); + string params = root.toStyledString(); + return PluginServer::GetInstance()->LoopOpResult(funName, params); + } +@@ -601,18 +604,17 @@ bool PluginServerAPI::InsertValue(uint64_t id, mlir::Value v) + return server->InsertValue(id, v); + } + +-bool PluginServerAPI::RedirectFallthroughTarget(FallThroughOp& fop, +- uint64_t src, uint64_t dest) ++bool PluginServerAPI::RedirectFallthroughTarget( ++ FallThroughOp& fop, mlir::Block* src, mlir::Block* dest) + { + Json::Value root; + string funName = __func__; +- root["src"] = src; +- root["dest"] = dest; ++ root["src"] = PluginServer::GetInstance()->FindBasicBlock(src); ++ root["dest"] = PluginServer::GetInstance()->FindBasicBlock(dest); + string params = root.toStyledString(); + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + // update server +- PluginServer *server = PluginServer::GetInstance(); +- fop->setSuccessor(server->FindBlock(dest), 0); ++ fop->setSuccessor(dest, 0); + return true; + } + +diff --git a/user/ArrayWidenPass.cpp b/user/ArrayWidenPass.cpp +index 6fb187c..591ecdb 100644 +--- a/user/ArrayWidenPass.cpp ++++ b/user/ArrayWidenPass.cpp +@@ -947,8 +947,8 @@ static void update_loop_dominator(uint64_t dir, FunctionOp* funcOp) + } + uint64_t i_bbAddr = cfAPI.GetImmediateDominator(dir, bbAddr); + if (!i_bbAddr || &bb == originLoop.exitBB1) { +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(&bb), \ +- cfAPI.RecomputeDominator(1, pluginAPI.FindBasicBlock(&bb))); ++ cfAPI.SetImmediateDominator(1, &bb, \ ++ cfAPI.RecomputeDominator(1, &bb)); + continue; + } + } +@@ -962,7 +962,7 @@ static void remove_originLoop(LoopOp *loop, FunctionOp* funcOp) + body = loop->GetLoopBody(); + unsigned n = loop->numBlockAttr().getInt(); + for (unsigned i = 0; i < n; i++) { +- controlapi.DeleteBlock(body[i], funcOp->idAttr().getInt(), pluginAPI.FindBasicBlock(body[i])); ++ controlapi.DeleteBlock(body[i], funcOp); + } + loop->Delete(); + } +@@ -975,12 +975,11 @@ static void create_prolog_bb(Block *prolog_bb, Block *after_bb, Block *dominator + ControlFlowAPI cfAPI; + PluginServerAPI pluginAPI; + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(prolog_bb), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(prolog_bb, outer); + + FallThroughOp fp = llvm::dyn_cast(entryEdge.src->back()); +- pluginAPI.RedirectFallthroughTarget(fp, pluginAPI.FindBasicBlock(entryEdge.src), +- pluginAPI.FindBasicBlock(prolog_bb)); +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(prolog_bb), pluginAPI.FindBasicBlock(dominator_bb)); ++ pluginAPI.RedirectFallthroughTarget(fp, entryEdge.src, prolog_bb); ++ cfAPI.SetImmediateDominator(1, prolog_bb, dominator_bb); + + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + lhs1 = baseSsa.Copy(); +@@ -993,13 +992,13 @@ static void create_prolog_bb(Block *prolog_bb, Block *after_bb, Block *dominator + mlir::Attribute attr = opBuilder->getI64IntegerAttr(originLoop.step); + mlir::Value step = ConstOp::CreateConst(*opBuilder, attr, originLoop.base.getType()); + ops.push_back(step); +- AssignOp opa = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus, prolog_bb); ++ AssignOp opa = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus); + } else { + ops.push_back(lhs1); + ops.push_back(originLoop.base); +- AssignOp op = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop, prolog_bb); ++ AssignOp op = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop); + } +- opBuilder->create(opBuilder->getUnknownLoc(), pluginAPI.FindBasicBlock(prolog_bb), ftBB); ++ opBuilder->create(opBuilder->getUnknownLoc(), prolog_bb, ftBB); + baseSsa.SetCurrentDef(lhs1); + defs_map.emplace(prolog_bb, lhs1); + } +@@ -1010,10 +1009,10 @@ static void create_loop_pred_bb( + ControlFlowAPI cfAPI; + PluginServerAPI pluginAPI; + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(loop_pred_bb), outer->idAttr().getInt()); +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(loop_pred_bb), pluginAPI.FindBasicBlock(dominator_bb)); ++ pluginAPI.AddBlockToLoop(loop_pred_bb, outer); ++ cfAPI.SetImmediateDominator(1, loop_pred_bb, dominator_bb); + opBuilder->setInsertionPointToStart(loop_pred_bb); +- opBuilder->create(opBuilder->getUnknownLoc(), pluginAPI.FindBasicBlock(loop_pred_bb), ftBB); ++ opBuilder->create(opBuilder->getUnknownLoc(), loop_pred_bb, ftBB); + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + defs_map.emplace(loop_pred_bb, baseSsa.GetCurrentDef()); + } +@@ -1029,9 +1028,9 @@ static void create_align_loop_header(Block *align_loop_header, Block* after_bb, + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + Value entry_node = baseSsa.GetCurrentDef(); + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(align_loop_header), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(align_loop_header, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(align_loop_header), pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, align_loop_header, dominator_bb); + phi = PhiOp::CreatePhi(nullptr, align_loop_header); + cfAPI.CreateNewDef(entry_node, phi.getOperation()); + res = phi.GetResult(); +@@ -1043,25 +1042,25 @@ static void create_align_loop_header(Block *align_loop_header, Block* after_bb, + PluginIR::PluginIntegerType::Unsigned); + ops.push_back(SSAOp::MakeSSA(*opBuilder, baseType)); + ops.push_back(res); +- AssignOp op1 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop, (align_loop_header)); ++ AssignOp op1 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop); + Value lhs1 = op1.GetLHS(); + ops.clear(); + ops.push_back(SSAOp::MakeSSA(*opBuilder, lhs1.getType())); + ops.push_back(lhs1); + ops.push_back(ConstOp::CreateConst(*opBuilder, opBuilder->getI64IntegerAttr(8), lhs1.getType())); +- AssignOp op2 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus, (align_loop_header)); ++ AssignOp op2 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus); + Value lhs2 = op2.GetLHS(); + ops.clear(); + ops.push_back(SSAOp::MakeSSA(*opBuilder, baseType)); + ops.push_back(originLoop.limit); +- AssignOp op3 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop, (align_loop_header)); ++ AssignOp op3 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop); + Value lhs3 = op3.GetLHS(); + ops.clear(); + ops.push_back(lhs2); + ops.push_back(lhs3); + +- cond_stmt = opBuilder->create(opBuilder->getUnknownLoc(), IComparisonCode::le, +- lhs2, lhs3, tb, fb, (align_loop_header)); ++ cond_stmt = opBuilder->create( ++ opBuilder->getUnknownLoc(), IComparisonCode::le, lhs2, lhs3, tb, fb); + + baseSsa.SetCurrentDef(res); + defs_map.emplace(align_loop_header, res); +@@ -1096,9 +1095,9 @@ static LoopOp *init_new_loop(LoopOp *outer_loop, Block* header, Block* latch, Fu + LoopOp *new_loop; + LoopOp new_loopt = funcOp->AllocateNewLoop(); + new_loop = &new_loopt; +- pluginAPI.SetHeader(new_loop->idAttr().getInt(), pluginAPI.FindBasicBlock(header)); +- pluginAPI.SetLatch(new_loop->idAttr().getInt(), pluginAPI.FindBasicBlock(latch)); +- new_loop->AddLoop(outer_loop->idAttr().getInt(), funcOp->idAttr().getInt()); ++ pluginAPI.SetHeader(new_loop, header); ++ pluginAPI.SetLatch(new_loop, latch); ++ new_loop->AddLoop(outer_loop, funcOp); + + return new_loop; + } +@@ -1111,10 +1110,9 @@ static void create_align_loop_body_bb(Block *align_loop_body_bb, Block* after_bb + ControlFlowAPI cfAPI; + PluginServerAPI pluginAPI; + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(align_loop_body_bb), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(align_loop_body_bb, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(align_loop_body_bb), +- pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, align_loop_body_bb, dominator_bb); + + opBuilder->setInsertionPointToStart(align_loop_body_bb); + llvm::SmallVector ops; +@@ -1126,15 +1124,15 @@ static void create_align_loop_body_bb(Block *align_loop_body_bb, Block* after_bb + ops.push_back(SSAOp::MakeSSA(*opBuilder, sizeType)); + + ops.push_back(baseSsa.GetCurrentDef()); +- AssignOp op1 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::Nop, (align_loop_body_bb)); ++ AssignOp op1 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::Nop); + Value var = op1.GetLHS(); + ops.clear(); + ops.push_back(SSAOp::MakeSSA(*opBuilder, originLoop.arr2.getType())); + ops.push_back(originLoop.arr2); + ops.push_back(var); +- AssignOp op2 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::PtrPlus, (align_loop_body_bb)); ++ AssignOp op2 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::PtrPlus); + lhs1 = op2.GetLHS(); + ops.clear(); + PluginIR::PluginTypeBase baseType = PluginIR::PluginIntegerType::get(context, 64, +@@ -1143,15 +1141,16 @@ static void create_align_loop_body_bb(Block *align_loop_body_bb, Block* after_bb + ops.push_back(SSAOp::MakeSSA(*opBuilder, baseType)); + mlir::Attribute asdada = opBuilder->getI64IntegerAttr(0); + ops.push_back(pluginAPI.BuildMemRef(baseType, lhs1, ConstOp::CreateConst(*opBuilder, asdada, pointerTy))); +- AssignOp op3 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF, (align_loop_body_bb)); ++ AssignOp op3 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF); + + lhs1 = op3.GetLHS(); + ops.clear(); + ops.push_back(SSAOp::MakeSSA(*opBuilder, originLoop.arr1.getType())); + ops.push_back(originLoop.arr1); + ops.push_back(var); +- AssignOp op4 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::PtrPlus, (align_loop_body_bb)); ++ AssignOp op4 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::PtrPlus); + lhs2 = op4.GetLHS(); + ops.clear(); + +@@ -1159,12 +1158,14 @@ static void create_align_loop_body_bb(Block *align_loop_body_bb, Block* after_bb + ops.push_back(pluginAPI.BuildMemRef( + baseType, lhs2, ConstOp::CreateConst(*opBuilder, opBuilder->getI64IntegerAttr(0), pointerTy))); + +- AssignOp op5 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::UNDEF, (align_loop_body_bb)); ++ AssignOp op5 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF); + lhs2 = op5.GetLHS(); + +- cond_stmt = opBuilder->create(opBuilder->getUnknownLoc(), +- llvm::dyn_cast(originLoop.condOp2).condCode(), lhs1, lhs2, tb, fb, (align_loop_body_bb)); ++ cond_stmt = opBuilder->create( ++ opBuilder->getUnknownLoc(), ++ llvm::dyn_cast(originLoop.condOp2).condCode(), ++ lhs1, lhs2, tb, fb); + } + + static void create_align_loop_latch(Block *align_loop_latch, Block* after_bb, Block* dominator_bb, +@@ -1177,10 +1178,9 @@ static void create_align_loop_latch(Block *align_loop_latch, Block* after_bb, Bl + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + Value entry_node = baseSsa.GetCurrentDef(); + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(align_loop_latch), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(align_loop_latch, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(align_loop_latch), +- pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, align_loop_latch, dominator_bb); + + res = baseSsa.Copy(); + +@@ -1189,8 +1189,8 @@ static void create_align_loop_latch(Block *align_loop_latch, Block* after_bb, Bl + ops.push_back(res); + ops.push_back(entry_node); + ops.push_back(ConstOp::CreateConst(*opBuilder, opBuilder->getI64IntegerAttr(8), entry_node.getType())); +- opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus, (align_loop_latch)); +- opBuilder->create(opBuilder->getUnknownLoc(), pluginAPI.FindBasicBlock(align_loop_latch), ftBB); ++ opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus); ++ opBuilder->create(opBuilder->getUnknownLoc(), align_loop_latch, ftBB); + defs_map.emplace(align_loop_latch, res); + } + +@@ -1206,10 +1206,9 @@ static void create_align_loop_exit_bb(Block *align_loop_exit_bb, Block* after_bb + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + Value entry_node = baseSsa.GetCurrentDef(); + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(align_loop_exit_bb), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(align_loop_exit_bb, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(align_loop_exit_bb), +- pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, align_loop_exit_bb, dominator_bb); + + cond_stmt = llvm::dyn_cast(after_bb->back()); + cond_lhs = cond_stmt.GetLHS(); +@@ -1220,12 +1219,12 @@ static void create_align_loop_exit_bb(Block *align_loop_exit_bb, Block* after_bb + ops.push_back((SSAOp::MakeSSA(*opBuilder, cond_lhs.getType()))); + ops.push_back(cond_lhs); + ops.push_back(cond_rhs); +- AssignOp op1 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::BitXOR, (align_loop_exit_bb)); ++ AssignOp op1 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::BitXOR); + lhs1 = op1.GetLHS(); + ops.clear(); + ops.push_back(lhs1); +- build_ctzll = opBuilder->create(opBuilder->getUnknownLoc(), ops, (align_loop_exit_bb)); ++ build_ctzll = opBuilder->create(opBuilder->getUnknownLoc(), ops); + PluginIR::PluginTypeBase intType = + PluginIR::PluginIntegerType::get(context, 32, PluginIR::PluginIntegerType::Signed); + lhs1 = SSAOp::MakeSSA(*opBuilder, intType); +@@ -1237,12 +1236,12 @@ static void create_align_loop_exit_bb(Block *align_loop_exit_bb, Block* after_bb + ops.push_back(lhs2); + ops.push_back(lhs1); + ops.push_back(ConstOp::CreateConst(*opBuilder, opBuilder->getI64IntegerAttr(3), lhs1.getType())); +- opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Rshift, (align_loop_exit_bb)); ++ opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Rshift); + + ops.clear(); + ops.push_back(SSAOp::MakeSSA(*opBuilder, entry_node.getType())); + ops.push_back(lhs2); +- AssignOp op2 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop, (align_loop_exit_bb)); ++ AssignOp op2 = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Nop); + lhs1 = op2.GetLHS(); + SSAOp entrySsa = dyn_cast(entry_node.getDefiningOp()); + lhs2 = entrySsa.Copy(); +@@ -1250,9 +1249,9 @@ static void create_align_loop_exit_bb(Block *align_loop_exit_bb, Block* after_bb + ops.push_back(lhs2); + ops.push_back(lhs1); + ops.push_back(entry_node); +- opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus, (align_loop_exit_bb)); ++ opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus); + +- opBuilder->create(opBuilder->getUnknownLoc(), pluginAPI.FindBasicBlock(align_loop_exit_bb), ftBB); ++ opBuilder->create(opBuilder->getUnknownLoc(), align_loop_exit_bb, ftBB); + + defs_map.emplace(align_loop_exit_bb, lhs2); + } +@@ -1269,10 +1268,9 @@ static void create_epilogue_loop_header(Block *epilogue_loop_header, Block* afte + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + Value entry_node = baseSsa.GetCurrentDef(); + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(epilogue_loop_header), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(epilogue_loop_header, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(epilogue_loop_header), +- pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, epilogue_loop_header, dominator_bb); + + phi = PhiOp::CreatePhi(nullptr, epilogue_loop_header); + cfAPI.CreateNewDef(entry_node, phi.getOperation()); +@@ -1280,8 +1278,10 @@ static void create_epilogue_loop_header(Block *epilogue_loop_header, Block* afte + + opBuilder->setInsertionPointToStart(epilogue_loop_header); + +- cond_stmt = opBuilder->create(opBuilder->getUnknownLoc(), +- llvm::dyn_cast(originLoop.condOp1).condCode(), res, originLoop.limit, tb, fb, (epilogue_loop_header)); ++ cond_stmt = opBuilder->create( ++ opBuilder->getUnknownLoc(), ++ llvm::dyn_cast(originLoop.condOp1).condCode(), ++ res, originLoop.limit, tb, fb); + + baseSsa.SetCurrentDef(res); + defs_map.emplace(epilogue_loop_header, res); +@@ -1299,10 +1299,9 @@ static void create_epilogue_loop_body_bb(Block *epilogue_loop_body_bb, Block* af + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + Value entry_node = baseSsa.GetCurrentDef(); + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(epilogue_loop_body_bb), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(epilogue_loop_body_bb, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(epilogue_loop_body_bb), +- pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, epilogue_loop_body_bb, dominator_bb); + + opBuilder->setInsertionPointToStart(epilogue_loop_body_bb); + llvm::SmallVector ops; +@@ -1311,15 +1310,15 @@ static void create_epilogue_loop_body_bb(Block *epilogue_loop_body_bb, Block* af + PluginIR::PluginIntegerType::Unsigned); + ops.push_back(SSAOp::MakeSSA(*opBuilder, sizeType)); + ops.push_back(entry_node); +- AssignOp op1 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::Nop, (epilogue_loop_body_bb)); ++ AssignOp op1 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::Nop); + lhs1 = op1.GetLHS(); + ops.clear(); + ops.push_back(SSAOp::MakeSSA(*opBuilder, originLoop.arr1.getType())); + ops.push_back(originLoop.arr1); + ops.push_back(lhs1); +- AssignOp op2 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::PtrPlus, (epilogue_loop_body_bb)); ++ AssignOp op2 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::PtrPlus); + lhs2 = op2.GetLHS(); + + ops.clear(); +@@ -1328,7 +1327,7 @@ static void create_epilogue_loop_body_bb(Block *epilogue_loop_body_bb, Block* af + ops.push_back(SSAOp::MakeSSA(*opBuilder, charType)); + ops.push_back(pluginAPI.BuildMemRef(charType, lhs2, + ConstOp::CreateConst(*opBuilder, opBuilder->getI64IntegerAttr(0), lhs2.getType()))); +- g = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF, (epilogue_loop_body_bb)); ++ g = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF); + + lhs2 = g.GetLHS(); + +@@ -1336,8 +1335,8 @@ static void create_epilogue_loop_body_bb(Block *epilogue_loop_body_bb, Block* af + ops.push_back(SSAOp::MakeSSA(*opBuilder, originLoop.arr2.getType())); + ops.push_back(originLoop.arr2); + ops.push_back(lhs1); +- AssignOp op3 = opBuilder->create(opBuilder->getUnknownLoc(), ops, +- IExprCode::PtrPlus, (epilogue_loop_body_bb)); ++ AssignOp op3 = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::PtrPlus); + lhs3 = op3.GetLHS(); + + ops.clear(); +@@ -1345,11 +1344,14 @@ static void create_epilogue_loop_body_bb(Block *epilogue_loop_body_bb, Block* af + ops.push_back(SSAOp::MakeSSA(*opBuilder, charType)); + ops.push_back(pluginAPI.BuildMemRef(charType, lhs3, ConstOp::CreateConst(*opBuilder, + opBuilder->getI64IntegerAttr(0), lhs3.getType()))); +- g = opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF, (epilogue_loop_body_bb)); ++ g = opBuilder->create( ++ opBuilder->getUnknownLoc(), ops, IExprCode::UNDEF); + + Value res = g.GetLHS(); +- cond_stmt = opBuilder->create(opBuilder->getUnknownLoc(), +- llvm::dyn_cast(originLoop.condOp1).condCode(), lhs2, res, tb, fb, (epilogue_loop_body_bb)); ++ cond_stmt = opBuilder->create( ++ opBuilder->getUnknownLoc(), ++ llvm::dyn_cast(originLoop.condOp1).condCode(), ++ lhs2, res, tb, fb); + + defs_map.emplace(epilogue_loop_body_bb, baseSsa.GetCurrentDef()); + } +@@ -1363,10 +1365,9 @@ static void create_epilogue_loop_latch(Block *epilogue_loop_latch, + SSAOp baseSsa = dyn_cast(originLoop.base.getDefiningOp()); + Value entry_node = baseSsa.GetCurrentDef(); + +- pluginAPI.AddBlockToLoop(pluginAPI.FindBasicBlock(epilogue_loop_latch), outer->idAttr().getInt()); ++ pluginAPI.AddBlockToLoop(epilogue_loop_latch, outer); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(epilogue_loop_latch), +- pluginAPI.FindBasicBlock(dominator_bb)); ++ cfAPI.SetImmediateDominator(1, epilogue_loop_latch, dominator_bb); + + SSAOp entrySsa = dyn_cast(entry_node.getDefiningOp()); + res = entrySsa.Copy(); +@@ -1377,9 +1378,10 @@ static void create_epilogue_loop_latch(Block *epilogue_loop_latch, + ops.push_back(entry_node); + ops.push_back(ConstOp::CreateConst(*opBuilder, + opBuilder->getI64IntegerAttr(originLoop.step), entry_node.getType())); +- opBuilder->create(opBuilder->getUnknownLoc(), ops, IExprCode::Plus, (epilogue_loop_latch)); ++ opBuilder->create(opBuilder->getUnknownLoc(), ++ ops, IExprCode::Plus); + +- opBuilder->create(opBuilder->getUnknownLoc(), pluginAPI.FindBasicBlock(epilogue_loop_latch), ftBB); ++ opBuilder->create(opBuilder->getUnknownLoc(), epilogue_loop_latch, ftBB); + + defs_map.emplace(epilogue_loop_latch, res); + } +@@ -1395,47 +1397,27 @@ static void create_new_loops(edge entryEdge, FunctionOp *funcOp) + LoopOp *epilogue_loop; + PluginServerAPI pluginAPI; + ControlFlowAPI cfAPI; +- LoopOp outer = pluginAPI.GetBlockLoopFather(pluginAPI.FindBasicBlock(entryEdge.src)); ++ LoopOp outer = pluginAPI.GetBlockLoopFather(entryEdge.src); + +- uint64_t bbAddr = cfAPI.CreateBlock(entryEdge.src, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(entryEdge.src)); +- prolog_bb = pluginAPI.FindBlock(bbAddr); ++ prolog_bb = cfAPI.CreateBlock(entryEdge.src, funcOp); + +- bbAddr = cfAPI.CreateBlock(prolog_bb, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(prolog_bb)); +- align_pred_bb = pluginAPI.FindBlock(bbAddr); ++ align_pred_bb = cfAPI.CreateBlock(prolog_bb, funcOp); + +- bbAddr = cfAPI.CreateBlock(align_pred_bb, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(align_pred_bb)); +- align_loop_header = pluginAPI.FindBlock(bbAddr); ++ align_loop_header = cfAPI.CreateBlock(align_pred_bb, funcOp); + +- bbAddr = cfAPI.CreateBlock(align_loop_header, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(align_loop_header)); +- align_loop_body_bb = pluginAPI.FindBlock(bbAddr); ++ align_loop_body_bb = cfAPI.CreateBlock(align_loop_header, funcOp); + +- bbAddr = cfAPI.CreateBlock(align_loop_body_bb, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(align_loop_body_bb)); +- align_loop_latch = pluginAPI.FindBlock(bbAddr); ++ align_loop_latch = cfAPI.CreateBlock(align_loop_body_bb, funcOp); + +- bbAddr = cfAPI.CreateBlock(align_loop_body_bb, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(align_loop_body_bb)); +- align_loop_exit_bb = pluginAPI.FindBlock(bbAddr); ++ align_loop_exit_bb = cfAPI.CreateBlock(align_loop_body_bb, funcOp); + +- bbAddr = cfAPI.CreateBlock(align_loop_header, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(align_loop_header)); +- epilogue_loop_pred_bb = pluginAPI.FindBlock(bbAddr); ++ epilogue_loop_pred_bb = cfAPI.CreateBlock(align_loop_header, funcOp); + +- bbAddr = cfAPI.CreateBlock(epilogue_loop_pred_bb, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(epilogue_loop_pred_bb)); +- epilogue_loop_header = pluginAPI.FindBlock(bbAddr); ++ epilogue_loop_header = cfAPI.CreateBlock(epilogue_loop_pred_bb, funcOp); + +- bbAddr = cfAPI.CreateBlock(epilogue_loop_header, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(epilogue_loop_header)); +- epilogue_loop_body_bb = pluginAPI.FindBlock(bbAddr); ++ epilogue_loop_body_bb = cfAPI.CreateBlock(epilogue_loop_header, funcOp); + +- bbAddr = cfAPI.CreateBlock(epilogue_loop_body_bb, funcOp->idAttr().getInt(), +- pluginAPI.FindBasicBlock(epilogue_loop_body_bb)); +- epilogue_loop_latch = pluginAPI.FindBlock(bbAddr); ++ epilogue_loop_latch = cfAPI.CreateBlock(epilogue_loop_body_bb, funcOp); + + create_prolog_bb(prolog_bb, entryEdge.src, entryEdge.src, &outer, entryEdge, funcOp, align_pred_bb); + +@@ -1473,18 +1455,14 @@ static void create_new_loops(edge entryEdge, FunctionOp *funcOp) + + epilogue_loop = init_new_loop(&outer, epilogue_loop_header, epilogue_loop_latch, funcOp); + +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(originLoop.exitBB1), +- pluginAPI.FindBasicBlock(entryEdge.src)); +- cfAPI.SetImmediateDominator(1, pluginAPI.FindBasicBlock(originLoop.exitBB2), +- pluginAPI.FindBasicBlock(entryEdge.src)); ++ cfAPI.SetImmediateDominator(1, originLoop.exitBB1, entryEdge.src); ++ cfAPI.SetImmediateDominator(1, originLoop.exitBB2, entryEdge.src); + + rewrite_add_phi_arg(originLoop.exitBB1); + rewrite_add_phi_arg(originLoop.exitBB2); + +- cfAPI.RemoveEdge(pluginAPI.FindBasicBlock(originLoop.exitE1.src), +- pluginAPI.FindBasicBlock(originLoop.exitE1.dest)); +- cfAPI.RemoveEdge(pluginAPI.FindBasicBlock(originLoop.exitE2.src), +- pluginAPI.FindBasicBlock(originLoop.exitE2.dest)); ++ cfAPI.RemoveEdge(originLoop.exitE1.src, originLoop.exitE1.dest); ++ cfAPI.RemoveEdge(originLoop.exitE2.src, originLoop.exitE2.dest); + } + + static void convertToNewLoop(LoopOp* loop, FunctionOp* funcOp) +diff --git a/user/LocalVarSummeryPass.cpp b/user/LocalVarSummeryPass.cpp +index ccee9f7..a343175 100755 +--- a/user/LocalVarSummeryPass.cpp ++++ b/user/LocalVarSummeryPass.cpp +@@ -69,7 +69,7 @@ static void LocalVarSummery(void) + size_t paramIndex = 0; + llvm::ArrayRef paramsType = ty.getParams(); + for (auto ty : ty.getParams()) { +- printf("\n Param index : %d\n", paramIndex++); ++ printf("\n Param index : %ld\n", paramIndex++); + printf("\n Param type id : %d\n", ty.dyn_cast().getPluginTypeID()); + } + } +-- +2.33.0 + diff --git a/0015-Pin-server-Fix-strip-problem.patch b/0018-Build-Fix-strip-problem.patch similarity index 83% rename from 0015-Pin-server-Fix-strip-problem.patch rename to 0018-Build-Fix-strip-problem.patch index b18aa74..70a0f2f 100644 --- a/0015-Pin-server-Fix-strip-problem.patch +++ b/0018-Build-Fix-strip-problem.patch @@ -1,11 +1,8 @@ From 3f7bcee573a1b504a151f491c12e26e752c68cea Mon Sep 17 00:00:00 2001 From: Mingchuan Wu Date: Mon, 6 Mar 2023 11:51:49 +0800 -Subject: [PATCH] [Build] Fix strip problem. +Subject: [PATCH 18/23] [Build] Fix strip problem. ---- - CMakeLists.txt | 1 + - 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index 1cfb776..720bac9 100644 @@ -20,5 +17,5 @@ index 1cfb776..720bac9 100644 # pin_server -- -Gitee +2.33.0 diff --git a/0019-Pin-server-Init-a-SimpleIPAPASS.patch b/0019-Pin-server-Init-a-SimpleIPAPASS.patch new file mode 100644 index 0000000..14abc14 --- /dev/null +++ b/0019-Pin-server-Init-a-SimpleIPAPASS.patch @@ -0,0 +1,174 @@ +From eb6f6bde062764538a91e35792b06124cf91f0d3 Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Tue, 28 Feb 2023 21:11:35 +0800 +Subject: [PATCH 19/23] [Pin-server] Init a SimpleIPAPASS + + +diff --git a/CMakeLists.txt b/CMakeLists.txt +index 1cfb776..59dee9f 100644 +--- a/CMakeLists.txt ++++ b/CMakeLists.txt +@@ -83,7 +83,8 @@ target_link_libraries(plg_grpc_proto + add_subdirectory(include) + add_subdirectory(lib) + add_library(pin_user SHARED +- "user/ArrayWidenPass.cpp" ++ # "user/ArrayWidenPass.cpp" ++ "user/StructReorder.cpp" + "user/InlineFunctionPass.cpp" + "user/LocalVarSummeryPass.cpp" + "user/user.cpp") +diff --git a/include/PluginServer/ManagerSetup.h b/include/PluginServer/ManagerSetup.h +index 27ba930..e264237 100755 +--- a/include/PluginServer/ManagerSetup.h ++++ b/include/PluginServer/ManagerSetup.h +@@ -28,6 +28,7 @@ enum RefPassName { + PASS_PHIOPT, + PASS_SSA, + PASS_LOOP, ++ PASS_MAC, + }; + + enum PassPosition { +diff --git a/include/user/StructReorder.h b/include/user/StructReorder.h +new file mode 100644 +index 0000000..1d05e56 +--- /dev/null ++++ b/include/user/StructReorder.h +@@ -0,0 +1,45 @@ ++/* Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. ++ ++ Licensed under the Apache License, Version 2.0 (the "License"); you may ++ not use this file except in compliance with the License. You may obtain ++ a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT ++ WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the ++ License for the specific language governing permissions and limitations ++ under the License. ++ ++ Author: Mingchuan Wu and Yancheng Li ++ Create: 2022-08-18 ++ Description: ++ This file contains the declaration of the StructReorderPass class. ++*/ ++ ++#ifndef STRUCTREORDER_PASS_H ++#define STRUCTREORDER_PASS_H ++ ++#include "PluginServer/PluginOptBase.h" ++ ++namespace PluginOpt { ++class StructReorderPass : public PluginOptBase { ++public: ++ StructReorderPass() : PluginOptBase(HANDLE_MANAGER_SETUP) ++ { ++ } ++ bool Gate() ++ { ++ return true; ++ } ++ int DoOptimize() ++ { ++ uint64_t *fun = (uint64_t *)GetFuncAddr(); ++ return DoOptimize(fun); ++ } ++ int DoOptimize(uint64_t *fun); ++}; ++} ++ ++#endif +diff --git a/user/StructReorder.cpp b/user/StructReorder.cpp +new file mode 100644 +index 0000000..bdc7abb +--- /dev/null ++++ b/user/StructReorder.cpp +@@ -0,0 +1,59 @@ ++/* Copyright (c) Huawei Technologies Co., Ltd. 2022-2022. All rights reserved. ++ ++ Licensed under the Apache License, Version 2.0 (the "License"); you may ++ not use this file except in compliance with the License. You may obtain ++ a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++ Unless required by applicable law or agreed to in writing, software ++ distributed under the License is distributed on an "AS IS" BASIS, WITHOUT ++ WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the ++ License for the specific language governing permissions and limitations ++ under the License. ++ ++ Author: Mingchuan Wu and Yancheng Li ++ Create: 2022-08-18 ++ Description: ++ This file contains the implementation of the ArrayWidenPass class. ++*/ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include "PluginAPI/PluginServerAPI.h" ++#include "PluginServer/PluginLog.h" ++#include "PluginAPI/ControlFlowAPI.h" ++#include "user/StructReorder.h" ++ ++namespace PluginOpt { ++using std::string; ++using std::vector; ++using std::cout; ++using namespace mlir; ++using namespace mlir::Plugin; ++using namespace PluginAPI; ++using namespace PinServer; ++using namespace std; ++ ++mlir::MLIRContext *context; ++mlir::OpBuilder* opBuilder = nullptr; ++std::map defs_map; ++std::map opNameMap; ++ ++ ++static void ProcessStructReorder(uint64_t *fun) ++{ ++ std::cout << "Running first pass, structreoder\n"; ++ ++} ++ ++int StructReorderPass::DoOptimize(uint64_t *fun) ++{ ++ ProcessStructReorder(fun); ++ return 0; ++} ++} +\ No newline at end of file +diff --git a/user/user.cpp b/user/user.cpp +index 16f0687..ee2031a 100644 +--- a/user/user.cpp ++++ b/user/user.cpp +@@ -22,12 +22,15 @@ + #include "user/ArrayWidenPass.h" + #include "user/InlineFunctionPass.h" + #include "user/LocalVarSummeryPass.h" ++#include "user/StructReorder.h" + + void RegisterCallbacks(void) + { + PinServer::PluginServer *pluginServer = PinServer::PluginServer::GetInstance(); +- pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); +- pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); ++ // pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); ++ // pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); + // PluginOpt::ManagerSetup setupData(PluginOpt::PASS_PHIOPT, 1, PluginOpt::PASS_INSERT_AFTER); + // pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); ++ PluginOpt::ManagerSetup setupData(PluginOpt::PASS_MAC, 1, PluginOpt::PASS_INSERT_AFTER); ++ pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); + } +-- +2.33.0 + diff --git a/0020-Pin-server-Add-CGnodeOp.patch b/0020-Pin-server-Add-CGnodeOp.patch new file mode 100644 index 0000000..1e47de9 --- /dev/null +++ b/0020-Pin-server-Add-CGnodeOp.patch @@ -0,0 +1,325 @@ +From bf910a189fdbf1be97dbbb2fa8e4b7d14163d002 Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Fri, 3 Mar 2023 10:52:13 +0800 +Subject: [PATCH 20/23] [Pin-server] Add CGnodeOp + + +diff --git a/include/Dialect/PluginOps.td b/include/Dialect/PluginOps.td +index 93ba116..9554067 100644 +--- a/include/Dialect/PluginOps.td ++++ b/include/Dialect/PluginOps.td +@@ -22,6 +22,34 @@ include "PluginDialect.td" + include "mlir/Interfaces/SideEffectInterfaces.td" + include "mlir/Interfaces/CallInterfaces.td" + ++def CGnodeOp : Plugin_Op<"callgraphnode", [NoSideEffect]> { ++ let summary = "callgraph node operation"; ++ let description = [{ ++ TODO. ++ }]; ++ ++ let arguments = (ins UI64Attr:$id, ++ StrAttr:$symbolName, ++ OptionalAttr:$definition, ++ UI32Attr:$order); ++ let regions = (region AnyRegion:$bodyRegion); ++ ++ // Add custom build methods for the operation. These method populates ++ // the `state` that MLIR uses to create operations, i.e. these are used when ++ // using `builder.create(...)`. ++ let builders = [ ++ OpBuilderDAG<(ins "uint64_t":$id, ++ "StringRef":$symbolName, ++ "bool":$definition, ++ "uint32_t":$order)> ++ ]; ++ ++ let extraClassDeclaration = [{ ++ // Value GetDecl(); ++ bool IsRealSymbol(); ++ }]; ++} ++ + 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 923dd44..e8c0a50 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -45,6 +45,10 @@ public: + virtual int GetDeclSourceLine(int64_t) = 0; + virtual int GetDeclSourceColumn(int64_t) = 0; + ++ // CGnodeOp ++ virtual vector GetAllCGnode() = 0; ++ virtual CGnodeOp GetCGnodeOpById(uint64_t) = 0; ++ + virtual vector GetAllFunc() = 0; + virtual FunctionOp GetFunctionOpById(uint64_t) = 0; + virtual vector GetDecls(uint64_t) = 0; +diff --git a/include/PluginAPI/PluginServerAPI.h b/include/PluginAPI/PluginServerAPI.h +index 3da28f5..71b59b0 100644 +--- a/include/PluginAPI/PluginServerAPI.h ++++ b/include/PluginAPI/PluginServerAPI.h +@@ -36,6 +36,12 @@ public: + PluginServerAPI () = default; + ~PluginServerAPI () = default; + ++ // CGnodeOp ++ vector GetAllCGnode() override; ++ CGnodeOp GetCGnodeOpById(uint64_t) override; ++ // mlir::Value GetDeclFromCGnode(uint64_t); ++ bool IsRealSymbolOfCGnode(uint64_t); ++ + vector GetAllFunc() override; + FunctionOp GetFunctionOpById(uint64_t); + vector GetDecls(uint64_t) override; +diff --git a/include/PluginServer/PluginCom.h b/include/PluginServer/PluginCom.h +index 6535362..d507b6f 100755 +--- a/include/PluginServer/PluginCom.h ++++ b/include/PluginServer/PluginCom.h +@@ -57,6 +57,7 @@ public: + string GetStringDataResult(void); + vector GetFunctionOpResult(void); + vector GetLocalDeclResult(void); ++ mlir::Plugin::CGnodeOp GetCGnodeOpResult(void); + mlir::Plugin::LoopOp LoopOpResult(void); + vector LoopOpsResult(void); + vector > EdgesResult(void); +@@ -73,6 +74,7 @@ private: + PluginJson json; + int64_t integerResult; + string stringResult; ++ mlir::Plugin::CGnodeOp cgnode; + vector funcOpData; + vector decls; + vector loops; +diff --git a/include/PluginServer/PluginJson.h b/include/PluginServer/PluginJson.h +index 8e00afa..eddbb2a 100755 +--- a/include/PluginServer/PluginJson.h ++++ b/include/PluginServer/PluginJson.h +@@ -33,6 +33,9 @@ using std::vector; + namespace PinJson { + class PluginJson { + public: ++ // CGnodeOp ++ mlir::Plugin::CGnodeOp CGnodeOpJsonDeSerialize(const string& data); ++ + void FuncOpJsonDeSerialize(const string&, vector&); + void LocalDeclOpJsonDeSerialize(const string&, + vector&); +diff --git a/include/PluginServer/PluginServer.h b/include/PluginServer/PluginServer.h +index b651140..d993505 100644 +--- a/include/PluginServer/PluginServer.h ++++ b/include/PluginServer/PluginServer.h +@@ -163,6 +163,11 @@ public: + RemoteCallClientWithAPI(funName, params); + return pluginCom.GetLocalDeclResult(); + } ++ mlir::Plugin::CGnodeOp GetCGnodeOpResult(const string& funName, const string& params) ++ { ++ RemoteCallClientWithAPI(funName, params); ++ return pluginCom.GetCGnodeOpResult(); ++ } + mlir::Plugin::LoopOp LoopOpResult(const string& funName, const string& params) + { + RemoteCallClientWithAPI(funName, params); +diff --git a/include/user/StructReorder.h b/include/user/StructReorder.h +index 1d05e56..3938121 100644 +--- a/include/user/StructReorder.h ++++ b/include/user/StructReorder.h +@@ -23,6 +23,7 @@ + + #include "PluginServer/PluginOptBase.h" + ++ + namespace PluginOpt { + class StructReorderPass : public PluginOptBase { + public: +diff --git a/lib/Dialect/PluginOps.cpp b/lib/Dialect/PluginOps.cpp +index ab0e3ce..928dc53 100644 +--- a/lib/Dialect/PluginOps.cpp ++++ b/lib/Dialect/PluginOps.cpp +@@ -87,6 +87,36 @@ static uint64_t getBlockAddress(mlir::Block* b) + } + } + ++// ===----------------------------------------------------------------------===// ++// 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)); ++} ++ ++// Value CGnodeOp::GetDecl() ++// { ++// PluginAPI::PluginServerAPI pluginAPI; ++// uint64_t nodeId = idAttr().getInt(); ++// return pluginAPI.GetDeclFromCGnode(nodeId); ++// } ++ ++bool CGnodeOp::IsRealSymbol() ++{ ++ PluginAPI::PluginServerAPI pluginAPI; ++ uint64_t nodeId = idAttr().getInt(); ++ return pluginAPI.IsRealSymbolOfCGnode(nodeId); ++} ++ ++// ===----------------------------------------------------------------------===// ++ + void FunctionOp::build(OpBuilder &builder, OperationState &state, + uint64_t id, StringRef funcName, bool declaredInline, Type type) + { +diff --git a/lib/PluginAPI/PluginServerAPI.cpp b/lib/PluginAPI/PluginServerAPI.cpp +index ff9c90e..5297357 100644 +--- a/lib/PluginAPI/PluginServerAPI.cpp ++++ b/lib/PluginAPI/PluginServerAPI.cpp +@@ -171,6 +171,42 @@ mlir::Value PluginServerAPI::CreateSSAOp(mlir::Type t) + return PluginServer::GetInstance()->GetValueResult(funName, params); + } + ++// CGnodeOp =============== ++ ++vector PluginServerAPI::GetAllCGnode() ++{ ++ Json::Value root; ++ string funName = "GetCGnodeIDs"; ++ string params = root.toStyledString(); ++ vector res; ++ vector ids = PluginServer::GetInstance()->GetIdsResult(funName, params); ++ for (auto id : ids) { ++ res.push_back(GetCGnodeOpById(id)); ++ } ++ return res; ++} ++ ++CGnodeOp PluginServerAPI::GetCGnodeOpById(uint64_t id) ++{ ++ Json::Value root; ++ string funName = __func__; ++ root["id"] = std::to_string(id); ++ string params = root.toStyledString(); ++ CGnodeOp cgnodeop = PluginServer::GetInstance()->GetCGnodeOpResult(funName, params); ++ return cgnodeop; ++} ++ ++bool PluginServerAPI::IsRealSymbolOfCGnode(uint64_t id) ++{ ++ Json::Value root; ++ string funName = __func__; ++ root["id"] = std::to_string(id); ++ string params = root.toStyledString(); ++ return PluginServer::GetInstance()->GetBoolResult(funName, params); ++} ++ ++// ======================== ++ + vector PluginServerAPI::GetAllFunc() + { + Json::Value root; +diff --git a/lib/PluginServer/PluginCom.cpp b/lib/PluginServer/PluginCom.cpp +index ab171c7..ddf0605 100755 +--- a/lib/PluginServer/PluginCom.cpp ++++ b/lib/PluginServer/PluginCom.cpp +@@ -59,6 +59,12 @@ vector PluginCom::GetLocalDeclResult(void) + return retOps; + } + ++mlir::Plugin::CGnodeOp PluginCom::GetCGnodeOpResult(void) ++{ ++ mlir::Plugin::CGnodeOp retop = cgnode; ++ return retop; ++} ++ + vector PluginCom::LoopOpsResult(void) + { + vector retLoops = loops; +@@ -125,6 +131,8 @@ void PluginCom::JsonDeSerialize(const string& key, const string& data) + { + if (key == "FuncOpResult") { + json.FuncOpJsonDeSerialize(data, this->funcOpData); ++ } else if (key == "CGnodeOpResult") { ++ this->cgnode = json.CGnodeOpJsonDeSerialize(data); + } else if (key == "LocalDeclOpResult") { + json.LocalDeclOpJsonDeSerialize(data, this->decls); + } else if (key == "LoopOpResult") { +diff --git a/lib/PluginServer/PluginJson.cpp b/lib/PluginServer/PluginJson.cpp +index 14a6ef4..ba2136b 100755 +--- a/lib/PluginServer/PluginJson.cpp ++++ b/lib/PluginServer/PluginJson.cpp +@@ -328,6 +328,25 @@ void PluginJson::StringDeSerialize(const string& data, string& result) + result = root["stringData"].asString(); + } + ++CGnodeOp PluginJson::CGnodeOpJsonDeSerialize(const string& data) ++{ ++ Json::Value root; ++ Json::Reader reader; ++ reader.parse(data, root); ++ fprintf(stderr, "dgy server cgnode json %s\n", root.toStyledString().c_str()); ++ ++ mlir::OpBuilder builder(PluginServer::GetInstance()->GetContext()); ++ uint64_t id = GetID(root["id"]); ++ Json::Value attributes = root["attributes"]; ++ uint32_t order = GetID(attributes["order"]); ++ map nodeAttributes; ++ JsonGetAttributes(attributes, nodeAttributes); ++ bool definition = false; ++ if (nodeAttributes["definition"] == "1") definition = true; ++ auto location = builder.getUnknownLoc(); ++ return builder.create(location, id, nodeAttributes["symbolName"], definition, order); ++} ++ + void PluginJson::FuncOpJsonDeSerialize( + const string& data, vector& funcOpData) + { +diff --git a/user/StructReorder.cpp b/user/StructReorder.cpp +index bdc7abb..a23d256 100644 +--- a/user/StructReorder.cpp ++++ b/user/StructReorder.cpp +@@ -47,8 +47,33 @@ std::map opNameMap; + + static void ProcessStructReorder(uint64_t *fun) + { +- std::cout << "Running first pass, structreoder\n"; ++ fprintf(stderr, "Running first pass, structreoder\n"); + ++ PluginServerAPI pluginAPI; ++ vector allnodes = pluginAPI.GetAllCGnode(); ++ fprintf(stderr, "allnodes size is %d\n", allnodes.size()); ++ for (auto &nodeOp : allnodes) { ++ context = nodeOp.getOperation()->getContext(); ++ mlir::OpBuilder opBuilder_temp = mlir::OpBuilder(context); ++ opBuilder = &opBuilder_temp; ++ string name = nodeOp.symbolNameAttr().getValue().str(); ++ fprintf(stderr, "Now process symbol : %s \n", name.c_str()); ++ uint32_t order = nodeOp.orderAttr().getInt(); ++ fprintf(stderr, "Now process order : %d \n", order); ++ if (nodeOp.IsRealSymbol()) ++ fprintf(stderr, "Now process IsRealSymbol \n"); ++ } ++ ++ vector allFunction = pluginAPI.GetAllFunc(); ++ fprintf(stderr, "allfun size is %d\n", allFunction.size()); ++ for (auto &funcOp : allFunction) { ++ context = funcOp.getOperation()->getContext(); ++ mlir::OpBuilder opBuilder_temp = mlir::OpBuilder(context); ++ opBuilder = &opBuilder_temp; ++ string name = funcOp.funcNameAttr().getValue().str(); ++ fprintf(stderr, "Now process func : %s \n", name.c_str()); ++ } ++ + } + + int StructReorderPass::DoOptimize(uint64_t *fun) +-- +2.33.0 + diff --git a/0021-Pin-server-The-lto-flag-is-used-to-control-the-pass-.patch b/0021-Pin-server-The-lto-flag-is-used-to-control-the-pass-.patch new file mode 100644 index 0000000..afe8a22 --- /dev/null +++ b/0021-Pin-server-The-lto-flag-is-used-to-control-the-pass-.patch @@ -0,0 +1,51 @@ +From 28e8bb19d239ba0e223a980c85da41950fb97295 Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Fri, 3 Mar 2023 11:12:44 +0800 +Subject: [PATCH 21/23] [Pin-server] The lto flag is used to control the pass + execution. + + +diff --git a/include/user/StructReorder.h b/include/user/StructReorder.h +index 3938121..d3e4486 100644 +--- a/include/user/StructReorder.h ++++ b/include/user/StructReorder.h +@@ -30,10 +30,8 @@ public: + StructReorderPass() : PluginOptBase(HANDLE_MANAGER_SETUP) + { + } +- bool Gate() +- { +- return true; +- } ++ bool Gate(); ++ + int DoOptimize() + { + uint64_t *fun = (uint64_t *)GetFuncAddr(); +diff --git a/user/StructReorder.cpp b/user/StructReorder.cpp +index a23d256..612a093 100644 +--- a/user/StructReorder.cpp ++++ b/user/StructReorder.cpp +@@ -81,4 +81,18 @@ int StructReorderPass::DoOptimize(uint64_t *fun) + ProcessStructReorder(fun); + return 0; + } ++ ++bool StructReorderPass::Gate() ++{ ++ PluginServerAPI pluginAPI; ++ if (pluginAPI.IsLtoOptimize()) { ++ fprintf(stderr, "\n The LTO flag is open \n"); ++ return true; ++ } ++ if (pluginAPI.IsWholeProgram()) { ++ fprintf(stderr, "\n The whole program flag is open \n"); ++ return true; ++ } ++ return false; ++} + } +\ No newline at end of file +-- +2.33.0 + diff --git a/0022-Pin-server-Add-support-for-decl-and-field-SetDeclNam.patch b/0022-Pin-server-Add-support-for-decl-and-field-SetDeclNam.patch new file mode 100644 index 0000000..c8e3935 --- /dev/null +++ b/0022-Pin-server-Add-support-for-decl-and-field-SetDeclNam.patch @@ -0,0 +1,701 @@ +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 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 GetAllFunc() = 0; + virtual FunctionOp GetFunctionOpById(uint64_t) = 0; ++ virtual vector GetFuncDecls(uint64_t) = 0; ++ virtual llvm::SmallVector 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 GetDecls(uint64_t) = 0; + virtual LoopOp AllocateNewLoop(uint64_t) = 0; + virtual vector 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 GetAllFunc() override; + FunctionOp GetFunctionOpById(uint64_t); ++ vector GetFuncDecls(uint64_t) override; ++ llvm::SmallVector 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 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 GetFunctionOpResult(void); + vector GetLocalDeclResult(void); ++ vector GetFuncDeclsResult(void); ++ llvm::SmallVector GetFieldsResult(void); ++ mlir::Plugin::DeclBaseOp GetBuildDeclResult(void); ++ ++ mlir::Plugin::FieldDeclOp GetMakeNodeResult(void); ++ + mlir::Plugin::CGnodeOp GetCGnodeOpResult(void); + mlir::Plugin::LoopOp LoopOpResult(void); + vector LoopOpsResult(void); +@@ -77,6 +83,7 @@ private: + mlir::Plugin::CGnodeOp cgnode; + vector funcOpData; + vector decls; ++ vector declOps; + vector loops; + mlir::Plugin::LoopOp loop; + vector > edges; +@@ -86,6 +93,9 @@ private: + uint64_t idResult; + vector idsResult; + mlir::Value valueResult; ++ mlir::Plugin::DeclBaseOp declOp; ++ mlir::Plugin::FieldDeclOp fielddeclOp; ++ llvm::SmallVector 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&); + void LocalDeclOpJsonDeSerialize(const string&, + vector&); ++ void FuncDeclsOpJsonDeSerialize(const string&, ++ vector&); ++ void FieldOpsJsonDeSerialize(const string&, llvm::SmallVector&); + void LoopOpsJsonDeSerialize(const string&, vector&); + void EdgesJsonDeSerialize(const string&, + vector>&); +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 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 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 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 PluginServerAPI::GetDecls(uint64_t funcID) + return PluginServer::GetInstance()->GetLocalDeclResult(funName, params); + } + ++vector 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(code)); ++ string params = root.toStyledString(); ++ ++ return PluginServer::GetInstance()->GetMakeNodeResult(funName, params); ++} ++ ++llvm::SmallVector 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(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 PluginCom::GetFuncDeclsResult(void) ++{ ++ vector retOps = declOps; ++ declOps.clear(); ++ return retOps; ++} ++ ++mlir::Plugin::FieldDeclOp PluginCom::GetMakeNodeResult(void) ++{ ++ mlir::Plugin::FieldDeclOp retOp = fielddeclOp; ++ return retOp; ++} ++ ++llvm::SmallVector PluginCom::GetFieldsResult(void) ++{ ++ llvm::SmallVector retOps = fieldsOps; ++ fieldsOps.clear(); ++ return retOps; ++} ++ ++mlir::Plugin::DeclBaseOp PluginCom::GetBuildDeclResult(void) ++{ ++ mlir::Plugin::DeclBaseOp retOp = declOp; ++ return retOp; ++} ++ + vector PluginCom::LoopOpsResult(void) + { + vector 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(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& 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(opValue.getDefiningOp()); ++ declOps.push_back(d); ++ } ++} ++ ++void PluginJson::FieldOpsJsonDeSerialize(const string& data, ++ llvm::SmallVector& 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(opValue.getDefiningOp()); ++ fieldOps.push_back(d); ++ } ++} ++ + void PluginJson::LoopOpsJsonDeSerialize( + const string& data, vector& 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(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(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(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(); + mlir::OpBuilder *opBuilder = PluginServer::GetInstance()->GetOpBuilder(); + mlir::Value declOp = opBuilder->create(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(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(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(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(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( + 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( + opBuilder->getUnknownLoc(), id, IDefineCode::COMPONENT, readOnly, component, field, retType); +-- +2.33.0 + diff --git a/0023-Pin-server-Add-StructReorderPASS-demo.patch b/0023-Pin-server-Add-StructReorderPASS-demo.patch new file mode 100644 index 0000000..a2faf5a --- /dev/null +++ b/0023-Pin-server-Add-StructReorderPASS-demo.patch @@ -0,0 +1,382 @@ +From 959277b19b4a1a8991d05e2db4bdd5374e6c308e Mon Sep 17 00:00:00 2001 +From: d00573793 +Date: Mon, 6 Mar 2023 23:01:18 +0800 +Subject: [PATCH 23/23] [Pin-server] Add StructReorderPASS demo + + +diff --git a/include/PluginAPI/BasicPluginOpsAPI.h b/include/PluginAPI/BasicPluginOpsAPI.h +index d659662..d9f348d 100644 +--- a/include/PluginAPI/BasicPluginOpsAPI.h ++++ b/include/PluginAPI/BasicPluginOpsAPI.h +@@ -72,6 +72,7 @@ public: + 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 PluginIR::PluginTypeBase GetDeclType(uint64_t declId) = 0; + + virtual vector GetDecls(uint64_t) = 0; + virtual LoopOp AllocateNewLoop(uint64_t) = 0; +diff --git a/include/PluginAPI/PluginServerAPI.h b/include/PluginAPI/PluginServerAPI.h +index 239dd23..c18bba9 100644 +--- a/include/PluginAPI/PluginServerAPI.h ++++ b/include/PluginAPI/PluginServerAPI.h +@@ -65,6 +65,7 @@ public: + void SetTypeFields(uint64_t declId, uint64_t fieldId) override; + void LayoutType(uint64_t declId) override; + void LayoutDecl(uint64_t declId) override; ++ PluginIR::PluginTypeBase GetDeclType(uint64_t declId) override; + + vector GetDecls(uint64_t) override; + PhiOp GetPhiOp(uint64_t) override; +diff --git a/include/PluginServer/PluginCom.h b/include/PluginServer/PluginCom.h +index af819ad..7deb615 100755 +--- a/include/PluginServer/PluginCom.h ++++ b/include/PluginServer/PluginCom.h +@@ -60,6 +60,7 @@ public: + vector GetFuncDeclsResult(void); + llvm::SmallVector GetFieldsResult(void); + mlir::Plugin::DeclBaseOp GetBuildDeclResult(void); ++ PluginIR::PluginTypeBase GetDeclTypeResult(void); + + mlir::Plugin::FieldDeclOp GetMakeNodeResult(void); + +@@ -93,6 +94,7 @@ private: + uint64_t idResult; + vector idsResult; + mlir::Value valueResult; ++ PluginIR::PluginTypeBase pTypeResult; + mlir::Plugin::DeclBaseOp declOp; + mlir::Plugin::FieldDeclOp fielddeclOp; + llvm::SmallVector fieldsOps; +diff --git a/include/PluginServer/PluginServer.h b/include/PluginServer/PluginServer.h +index 29a790b..81f92e9 100644 +--- a/include/PluginServer/PluginServer.h ++++ b/include/PluginServer/PluginServer.h +@@ -183,6 +183,12 @@ public: + return pluginCom.GetBuildDeclResult(); + } + ++ PluginIR::PluginTypeBase GetDeclTypeResult(const string& funName, const string& params) ++ { ++ RemoteCallClientWithAPI(funName, params); ++ return pluginCom.GetDeclTypeResult(); ++ } ++ + vector GetLocalDeclResult(const string& funName, const string& params) + { + RemoteCallClientWithAPI(funName, params); +diff --git a/lib/PluginAPI/PluginServerAPI.cpp b/lib/PluginAPI/PluginServerAPI.cpp +index 537d389..e8a1f4c 100644 +--- a/lib/PluginAPI/PluginServerAPI.cpp ++++ b/lib/PluginAPI/PluginServerAPI.cpp +@@ -613,6 +613,15 @@ void PluginServerAPI::LayoutType(uint64_t declId) + PluginServer::GetInstance()->RemoteCallClientWithAPI(funName, params); + } + ++PluginIR::PluginTypeBase PluginServerAPI::GetDeclType(uint64_t declId) ++{ ++ Json::Value root; ++ string funName = __func__; ++ root["declId"] = std::to_string(declId); ++ string params = root.toStyledString(); ++ return PluginServer::GetInstance()->GetDeclTypeResult(funName, params); ++} ++ + void PluginServerAPI::LayoutDecl(uint64_t declId) + { + Json::Value root; +diff --git a/lib/PluginServer/PluginCom.cpp b/lib/PluginServer/PluginCom.cpp +index 573de13..aaf4ba8 100755 +--- a/lib/PluginServer/PluginCom.cpp ++++ b/lib/PluginServer/PluginCom.cpp +@@ -91,6 +91,12 @@ mlir::Plugin::DeclBaseOp PluginCom::GetBuildDeclResult(void) + return retOp; + } + ++PluginIR::PluginTypeBase PluginCom::GetDeclTypeResult(void) ++{ ++ PluginIR::PluginTypeBase retType = pTypeResult; ++ return retType; ++} ++ + vector PluginCom::LoopOpsResult(void) + { + vector retLoops = loops; +@@ -161,6 +167,14 @@ void PluginCom::JsonDeSerialize(const string& key, const string& data) + this->cgnode = json.CGnodeOpJsonDeSerialize(data); + } else if (key == "LocalDeclOpResult") { + json.LocalDeclOpJsonDeSerialize(data, this->decls); ++ } else if (key == "FuncDeclsOpResult") { ++ json.FuncDeclsOpJsonDeSerialize(data, this->declOps); ++ } else if (key == "MakeNodeResult") { ++ Json::Value node; ++ Json::Reader reader; ++ reader.parse(data, node); ++ mlir::Value v = json.ValueJsonDeSerialize(node); ++ this->fielddeclOp = llvm::dyn_cast(v.getDefiningOp()); + } else if (key == "LoopOpResult") { + this->loop = json.LoopOpJsonDeSerialize (data); + } else if (key == "LoopOpsResult") { +@@ -180,9 +194,6 @@ void PluginCom::JsonDeSerialize(const string& key, const string& data) + } else if (key == "DeclOpResult") { + mlir::Value decl = json.DeclBaseOpJsonDeSerialize(data); + this->declOp = llvm::dyn_cast(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") { +@@ -192,6 +203,8 @@ void PluginCom::JsonDeSerialize(const string& key, const string& data) + Json::Reader reader; + reader.parse(data, node); + this->valueResult = json.ValueJsonDeSerialize(node); ++ } else if (key == "PluginTypeResult") { ++ this->pTypeResult = json.TypeJsonDeSerialize(data); + } else if (key == "GetPhiOps") { + json.GetPhiOpsJsonDeSerialize(data, this->opData); + } else if (key == "IntegerResult") { +diff --git a/lib/PluginServer/PluginJson.cpp b/lib/PluginServer/PluginJson.cpp +index 7c2abbe..c7ce788 100755 +--- a/lib/PluginServer/PluginJson.cpp ++++ b/lib/PluginServer/PluginJson.cpp +@@ -333,7 +333,6 @@ CGnodeOp PluginJson::CGnodeOpJsonDeSerialize(const string& data) + Json::Value root; + Json::Reader reader; + reader.parse(data, root); +- fprintf(stderr, "dgy server cgnode json %s\n", root.toStyledString().c_str()); + + mlir::OpBuilder builder(PluginServer::GetInstance()->GetContext()); + uint64_t id = GetID(root["id"]); +diff --git a/user/InlineFunctionPass.cpp b/user/InlineFunctionPass.cpp +index d982d44..a51e6fe 100755 +--- a/user/InlineFunctionPass.cpp ++++ b/user/InlineFunctionPass.cpp +@@ -33,7 +33,7 @@ static void UserOptimizeFunc(void) + if (allFunction[i].declaredInlineAttr().getValue()) + count++; + } +- printf("declaredInline have %d functions were declared.\n", count); ++ fprintf(stderr, "declaredInline have %d functions were declared.\n", count); + } + + int InlineFunctionPass::DoOptimize() +diff --git a/user/LocalVarSummeryPass.cpp b/user/LocalVarSummeryPass.cpp +index ccee9f7..c22bad4 100755 +--- a/user/LocalVarSummeryPass.cpp ++++ b/user/LocalVarSummeryPass.cpp +@@ -51,10 +51,6 @@ static void LocalVarSummery(void) + std::string tyName = stTy.getName(); + printf(" struct name is : %s\n", tyName.c_str()); + +- llvm::ArrayRef paramsType = stTy.getBody(); +- for (auto tty :paramsType) { +- printf("\n struct arg id : %d\n", tty.dyn_cast().getPluginTypeID()); +- } + llvm::ArrayRef paramsNames = stTy.getElementNames(); + for (auto name :paramsNames) { + std::string pName = name; +diff --git a/user/StructReorder.cpp b/user/StructReorder.cpp +index 612a093..f4e824e 100644 +--- a/user/StructReorder.cpp ++++ b/user/StructReorder.cpp +@@ -44,6 +44,138 @@ mlir::OpBuilder* opBuilder = nullptr; + std::map defs_map; + std::map opNameMap; + ++static void dump_structtype(PluginIR::PluginTypeBase type) ++{ ++ if (auto stTy = type.dyn_cast()) { ++ std::string tyName = stTy.getName(); ++ fprintf(stderr, " struct name is : %s\n", tyName.c_str()); ++ ++ llvm::ArrayRef paramsNames = stTy.getElementNames(); ++ for (auto name :paramsNames) { ++ std::string pName = name; ++ fprintf(stderr, "\n struct argname is : %s\n", pName.c_str()); ++ } ++ } ++} ++ ++ ++static void reorder_fields(FieldDeclOp& field, FieldDeclOp& newfield) ++{ ++ if (!field) { ++ field = newfield; ++ unsigned size = newfield.GetTypeSize(); ++ } else { ++ FieldDeclOp tmp = field; ++ // unsigned size = tmp.getResultType().dyn_cast().getPluginTypeID(); ++ unsigned size = newfield.GetTypeSize(); ++ if (newfield.GetTypeSize() > tmp.GetTypeSize()) { ++ newfield.SetDeclChain(tmp); ++ field = newfield; ++ } ++ } ++} ++ ++static void create_new_fields(mlir::Plugin::DeclBaseOp& decl, llvm::SmallVector recordfields) ++{ ++ PluginAPI::PluginServerAPI pluginAPI; ++ FieldDeclOp fd; ++ for (auto &fielddecl : recordfields) { ++ FieldDeclOp field = pluginAPI.MakeNode(IDefineCode::FieldDecl); ++ field.SetName(fielddecl); ++ field.SetType(fielddecl); ++ field.SetDeclAlign(fielddecl); ++ ++ field.SetSourceLocation(fielddecl); ++ field.SetUserAlign(fielddecl); ++ field.SetAddressable(fielddecl); ++ field.SetNonAddressablep(fielddecl); ++ field.SetVolatile(fielddecl); ++ field.SetDeclContext(decl.idAttr().getInt()); ++ ++ reorder_fields(fd, field); ++ ++ } ++ pluginAPI.SetTypeFields(decl.idAttr().getInt(), fd.idAttr().getInt()); ++ pluginAPI.LayoutType(decl.idAttr().getInt()); ++ pluginAPI.LayoutDecl(decl.idAttr().getInt()); ++ fprintf(stderr, "reorder struct type after :>>>\n"); ++ dump_structtype(pluginAPI.GetDeclType(decl.idAttr().getInt())); ++} ++ ++static void create_new_type(mlir::Plugin::DeclBaseOp& decl, llvm::SmallVector recordfields) ++{ ++ create_new_fields(decl, recordfields); ++} ++ ++static void create_new_types(llvm::SmallVector recordTypes, ++ llvm::SmallVector recordDecls, llvm::SmallVector recordFields) ++{ ++ for (int i = 0; i < recordTypes.size(); i++) { ++ ++ auto type = recordTypes[i].dyn_cast(); ++ mlir::MLIRContext m_context; ++ m_context.getOrLoadDialect(); ++ PluginIR::PluginTypeBase rPluginType = PluginIR::PluginUndefType::get(&m_context); ++ StringRef name = type.getName(); ++ StringRef newName = name.str() + ".reorg." + to_string(i); ++ PluginAPI::PluginServerAPI pluginAPI; ++ DeclBaseOp decl = pluginAPI.BuildDecl(IDefineCode::TYPEDECL, newName, rPluginType); ++ ++ create_new_type(decl, recordFields); ++ ++ } ++ ++} ++ ++static void record_decl(mlir::Plugin::DeclBaseOp decl, llvm::SmallVector& recordDecls) ++{ ++ if (llvm::find(recordDecls, decl) == recordDecls.end()) ++ { ++ recordDecls.push_back(decl); ++ } ++} ++ ++static void record_fields(DeclBaseOp decl, llvm::SmallVector& recordFields) ++{ ++ PluginAPI::PluginServerAPI pluginAPI; ++ llvm::SmallVector fields = pluginAPI.GetFields(decl.idAttr().getInt()); ++ recordFields.insert(recordFields.end(), fields.begin(), fields.end()); ++} ++ ++static PluginIR::PluginTypeBase record_type(PluginIR::PluginTypeBase type, llvm::SmallVector& recordTypes, ++ DeclBaseOp decl, llvm::SmallVector& recordFields) ++{ ++ if (llvm::find(recordTypes, type) == recordTypes.end()) ++ { ++ recordTypes.push_back(type); ++ } ++ record_fields(decl, recordFields); ++ return type; ++} ++ ++static PluginIR::PluginTypeBase inner_type(PluginIR::PluginTypeBase type) ++{ ++ while(type.isa() || type.isa()) { ++ if (auto t = type.dyn_cast()) { ++ type = t.getElementType().dyn_cast(); ++ } else if (auto t = type.dyn_cast()) { ++ type = t.getElementType().dyn_cast(); ++ } ++ } ++ return type; ++} ++ ++ ++static bool handle_type(PluginIR::PluginTypeBase type) ++{ ++ type = inner_type(type); ++ if (type.isa()) { ++ fprintf(stderr, "handle struct type :>>>\n"); ++ dump_structtype(type); ++ return true; ++ } ++ return false; ++} + + static void ProcessStructReorder(uint64_t *fun) + { +@@ -57,14 +189,15 @@ static void ProcessStructReorder(uint64_t *fun) + mlir::OpBuilder opBuilder_temp = mlir::OpBuilder(context); + opBuilder = &opBuilder_temp; + string name = nodeOp.symbolNameAttr().getValue().str(); +- fprintf(stderr, "Now process symbol : %s \n", name.c_str()); + uint32_t order = nodeOp.orderAttr().getInt(); +- fprintf(stderr, "Now process order : %d \n", order); + if (nodeOp.IsRealSymbol()) +- fprintf(stderr, "Now process IsRealSymbol \n"); ++ fprintf(stderr, "process RealSymbol : %s/%d \n", name.c_str(), order); + } + + vector allFunction = pluginAPI.GetAllFunc(); ++ llvm::SmallVector recordTypes; ++ llvm::SmallVector recordDecls; ++ llvm::SmallVector recordFields; + fprintf(stderr, "allfun size is %d\n", allFunction.size()); + for (auto &funcOp : allFunction) { + context = funcOp.getOperation()->getContext(); +@@ -72,6 +205,19 @@ static void ProcessStructReorder(uint64_t *fun) + opBuilder = &opBuilder_temp; + string name = funcOp.funcNameAttr().getValue().str(); + fprintf(stderr, "Now process func : %s \n", name.c_str()); ++ uint64_t funcID = funcOp.idAttr().getValue().getZExtValue(); ++ ++ vector decls = pluginAPI.GetFuncDecls(funcID); ++ ++ for (auto &decl : decls) { ++ auto type = decl.getResultType().dyn_cast(); ++ if (!handle_type(type)) continue; ++ type = record_type(inner_type(type), recordTypes, decl, recordFields); ++ ++ record_decl(decl, recordDecls); ++ } ++ ++ create_new_types(recordTypes, recordDecls, recordFields); + } + + } +diff --git a/user/user.cpp b/user/user.cpp +index ee2031a..6bfa524 100644 +--- a/user/user.cpp ++++ b/user/user.cpp +@@ -27,10 +27,10 @@ + void RegisterCallbacks(void) + { + PinServer::PluginServer *pluginServer = PinServer::PluginServer::GetInstance(); +- // pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); +- // pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); ++ pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); ++ pluginServer->RegisterOpt(std::make_shared(PluginOpt::HANDLE_BEFORE_IPA)); + // PluginOpt::ManagerSetup setupData(PluginOpt::PASS_PHIOPT, 1, PluginOpt::PASS_INSERT_AFTER); + // pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); +- PluginOpt::ManagerSetup setupData(PluginOpt::PASS_MAC, 1, PluginOpt::PASS_INSERT_AFTER); +- pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); ++ // PluginOpt::ManagerSetup setupData(PluginOpt::PASS_MAC, 1, PluginOpt::PASS_INSERT_AFTER); ++ // pluginServer->RegisterPassManagerOpt(setupData, std::make_shared()); + } +-- +2.33.0 + diff --git a/pin-server.spec b/pin-server.spec index c0db07e..02ca53e 100644 --- a/pin-server.spec +++ b/pin-server.spec @@ -1,6 +1,6 @@ Name: pin-server Version: 0.4.0 -Release: 5 +Release: 6 Summary: Pin (Plug-IN framework) server provides plugin APIs for compiler optimization developers to develop optimization pass. License: Apache 2.0 URL: https://gitee.com/openeuler/pin-server @@ -22,9 +22,17 @@ Patch9: 0009-Pin-server-Support-functiontype-structtype.eg.patch Patch10: 0010-Pin-server-Add-ComponentOp-ConstructorOp-AddressOp-F.patch Patch11: 0011-Pin-server-Add-NopOp-EHElseOp-AsmOp-SwitchOp-LabelOp.patch Patch12: 0012-Pin-server-Support-Vectortype.patch -Patch13: 0013-Pin-server-Support-Vectortype.patch +Patch13: 0013-Pin-server-Fix-Definecode-name.patch Patch14: 0014-Pin-server-Fix-AWC-pass-can-complice-can-compile-a-c.patch -Patch15: 0015-Pin-server-Fix-strip-problem.patch +Patch15: 0015-Pin-server-Bugfix-for-SwitchOp-change-it-to-terminat.patch +Patch16: 0016-Pin-server-Bugfix-for-GetFunctionById.patch +Patch17: 0017-Refactoring-Modify-API-parameters-to-improve-usabili.patch +Patch18: 0018-Build-Fix-strip-problem.patch +Patch19: 0019-Pin-server-Init-a-SimpleIPAPASS.patch +Patch20: 0020-Pin-server-Add-CGnodeOp.patch +Patch21: 0021-Pin-server-The-lto-flag-is-used-to-control-the-pass-.patch +Patch22: 0022-Pin-server-Add-support-for-decl-and-field-SetDeclNam.patch +Patch23: 0023-Pin-server-Add-StructReorderPASS-demo.patch %description Pin (Plug-IN framework) server provides plugin APIs for compiler optimization developers to develop optimization pass. @@ -55,6 +63,14 @@ A demo for pin-server %patch13 -p1 %patch14 -p1 %patch15 -p1 +%patch16 -p1 +%patch17 -p1 +%patch18 -p1 +%patch19 -p1 +%patch20 -p1 +%patch21 -p1 +%patch22 -p1 +%patch23 -p1 mkdir -p _build cd _build @@ -95,6 +111,12 @@ find %{_libdir} -type f -name "libMLIRServerAPI.so" -exec strip "{}" ";" %config(noreplace) /etc/ld.so.conf.d/%{name}-%{_arch}.conf %changelog +* Tue Mar 07 2023 dingguangya - 0.4.0-6 +- Type:Update +- ID:NA +- SUG:NA +- DESC:Sync patch from openEuler/pin-server + * Mon Mar 6 2023 wumingchuan - 0.4.0-5 - Type:Update - ID:NA