From 45aef6b87b4e6a5b6d4965bf6f2996c4fff823eb Mon Sep 17 00:00:00 2001 From: liyancheng <412998149@qq.com> Date: Mon, 28 Apr 2025 10:53:17 +0800 Subject: [PATCH] [Sync] Sync patches from openeuler/gcc Including the following patches: - 0361-Enhancing-BOLT-Optimization-with-AI.patch - 0362-Modify-cache-size-for-hip10a-and-hip10c.patch - 0363-SVE-Add-std-find-with-sve.patch - 0364-CFGO-Enable-flag_profile_partial_training-for-CFGO-b.patch (cherry picked from commit 12431fbfb4f83b8fca5bb910537ed36ce099f6c2) --- ...-Enhancing-BOLT-Optimization-with-AI.patch | 72 +++ ...ify-cache-size-for-hip10a-and-hip10c.patch | 43 ++ 0363-SVE-Add-std-find-with-sve.patch | 530 ++++++++++++++++++ ..._profile_partial_training-for-CFGO-b.patch | 30 + gcc.spec | 18 +- 5 files changed, 692 insertions(+), 1 deletion(-) create mode 100644 0361-Enhancing-BOLT-Optimization-with-AI.patch create mode 100644 0362-Modify-cache-size-for-hip10a-and-hip10c.patch create mode 100644 0363-SVE-Add-std-find-with-sve.patch create mode 100644 0364-CFGO-Enable-flag_profile_partial_training-for-CFGO-b.patch diff --git a/0361-Enhancing-BOLT-Optimization-with-AI.patch b/0361-Enhancing-BOLT-Optimization-with-AI.patch new file mode 100644 index 0000000..8852f96 --- /dev/null +++ b/0361-Enhancing-BOLT-Optimization-with-AI.patch @@ -0,0 +1,72 @@ +From 3dd233c1a7b20de2182ae4e98909ddace6612a0a Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E9=99=88=E9=B8=BF?= +Date: Tue, 25 Feb 2025 16:32:39 +0800 +Subject: [PATCH] Enhancing BOLT Optimization with AI. + +--- + gcc/ipa-hardware-detection.cc | 2 +- + gcc/onnx.fdata | 2 +- + gcc/opts.cc | 13 ++++++++++++- + 3 files changed, 14 insertions(+), 3 deletions(-) + +diff --git a/gcc/ipa-hardware-detection.cc b/gcc/ipa-hardware-detection.cc +index 75b74aa03..6b36d685c 100644 +--- a/gcc/ipa-hardware-detection.cc ++++ b/gcc/ipa-hardware-detection.cc +@@ -89,7 +89,7 @@ create_part_bb (basic_block last_bb, tree part_base) + &gsi, PLUS_EXPR, unsigned_type_node, part_base, + build_int_cst (unsigned_type_node, 4294963967)); + gcond *cond = gimple_build_cond (LE_EXPR, part_cond, +- build_int_cst (unsigned_type_node, 2), ++ build_int_cst (unsigned_type_node, 128), + NULL_TREE, NULL_TREE); + gimple_set_location (cond, input_location); + gsi_insert_before (&gsi, cond, GSI_SAME_STMT); +diff --git a/gcc/onnx.fdata b/gcc/onnx.fdata +index 234b1a045..77f4d9b1d 100644 +--- a/gcc/onnx.fdata ++++ b/gcc/onnx.fdata +@@ -1 +1 @@ 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 +\ No newline at end of file ++656137356462666463346364333361623035396139323366643262383764363763323530613631653861653634666630333030316562323662346133633566313233326432366139383465346338376266393132363438333765656463366235613461313434346139333334396265306163333731646537376430643834323664623863366163343363643130313435636565623834363361316133393230363937653835653762353534626439663133633538623062353439646237616630333237666136663433386334626639643465303163653832333062643863333664336630376231643964316231663933656333386338656262303734376137313565643963396535653131303763646533393234333735613333633132353061393531333935623539643834373266303861633739373862366663376365383233326139383939363566373061373361613939336537366631353334346563313061373365663635633332663437653136383235343635623234366430373330366336363237623962656465373233346131343264313137653838643334616430346339363732613237623866636364313232613934343261643231386531356430343965303330306332326266336634626163333461643139653962326566303064343333623037313762303934626336363537616339343637306633633066333231613063623339333539376461316632653234353938616133616463623534356232346135666261616339646638373031356633306161626465643665633066616264623965656138613233353331303236363565616133323131653935643363353832366663633434626236376663386335666364333530336433353234383031636264353761616638663031613263353738326438656265623236653338323232386565626464393034633962373835363264656664616439353336623462376139333134656662373033626135336138333136643032636430653334303861616439333736306363383862306439623962646435383931613161653334623666313236366366373962356536656434396231303338646265323666386461366430396262353536313433636132653466623061346164303635636162336536383062306637306438626232646636393462353563366437386531316463383239373361643230643566333736663330656538643461313161306163666361663064383962373736636162323565383865336630333461343939336231366437386265323439626332336166376262623837353163376533353066636339313233323761613766333633343432623331373530376432376534623831333339383964633439653966303663303439623739346133626330646333373831393930316439326233646565623761646664356230336233363230383833616266643463626536336133346664656433373630343738343262373863646131373633653939636430616439393731306435313664323166313530636464393664613738643461356437333564343036316262353462313336663335313763323661363564343330623965363866616534323163616337613964356465333333663739313835623363316462346539643539636435303166306664366135313063333630336531336532346134306234626632313565333739356139613430643630613834353666623762363363326431316538313730316132333165383561666434623564623831616263316464353664323731373332656430323435663836393162646335646164333437366436663633353630373762316161316436333461393763343130396235396237333534376639343063316463386432316330663138373338386632643361386565636665653766643836373930326664346163333162613163396664663531626161326134333762666330393261316637333265326138663036363736333734326230373730613665323665333266326265356534376133373330393466336639623431383863383433643563346265613561326134616334626262646637666163376365333962323036323537333737313534313066323364623937303534623665623237306566636366623763623431373666383236383134326365613136653238623231646339353938373030656631646238653961643434653765313834316231346231323563636633356131376538636666613866303638323362643436636638353665346166323633623861616639363862613835306234643961666662656334393366613066653061383333653965343633653837613263636530633863303861313363636361346132613431363962336539613463313366633934633761363761623039396365393263633638656134376162616631363838616238613137323032663864613035313363353335396432373530363233663234343136346339663435333834656630366537353336306137366434646264303466303633663630386363636337383066316631323836353135393134646139373035323637346164303965323536666335393864636364346433383564616435383862366464326130336536313934636139386438373462333162366230623165323533336263313430386430643661386261633061313631613639313232313734383136336464636231323130336231613131373336636238656635353635626666303535663331363332353338313363396334313631333034656133666365353561643830356565633137346638643739636136376432303761633436666465336232356236653164353163346461656165333038653266336161383966633961323462376262386430363536323932373263343731313562356139336265383765336139643837333966623265386131666561366161333138353261663139303338393733346335313934363761393137633266616431663436343236613231663865636236346133616662623761373633663830623231393063616534633032316538626436633731643261313866666339353836373133363939623966636239333637373764323863663964376134323134613133346335326162363334363334386666396666336534646565616264363966356566323465346538613762623864303766646338666264643466666537303263623162326539653435643130313061386235623631306232303139633962653661303038376162323666343263356465313035393535313531373665623537363237373934366266303434333463303562646535623762313565326631393061643033613838363963333933396162363834393636613136613036656435356339616665636134313034663335343465646335333738663063616330353634316466336438373835326638633037656234396239303730613338336332613839323837643561333235393366323531303032666436616435313137313166383433396531626137353932616538333330653164326438656166343339363262366264326632376564396434396333356565343733383137666333386462313164333630303936336137323863313634613031393931613164363237643262353162376133643935373036306336346161376563383862316365613139376535626535626234666331363163303835336362393535613530636234643633626364386566396132333232373733633230393865663664636334393131643133383736373833653261383661623632343237653937366164386564633433396130313166306430316134653864643263343835653438383687144d4395a52c41e3842b41b03f3743f207264565084e41e0fbdf3bd429b13da15eb33d7e47b93b309daa3890d2d93d0000803f2bd5bbb95024b1399db4d33b2956c2392e99b93969b868ba90d4eb3bd611a9b92d66c739a2115b3b1257b6b9ed46b2b917deac3b5b0d2a3c14887e3ce74b3eba00000000386ea33945cf5abb9cbce9ba3c4ff0ba5cc05b3bb4bc9eb91e09b03a6113e9ba3e17b539267dab397fdea9b906eea5397713973bfc7a2c3b51ff733b50c313bb000000003ea5d239842c8c3b6d275e3af5c58b394139b2391f56403bf47e56bb357a81bbc956923b57d2cc39909aaf3944807e3c4a78cbba9938a9b9d84ba7b99796bcb9d7bea5b925e37a39ff19a73ba25dc1397357b1b9c13cd6bb2d36423b6da35a3b90e500bbd402a0b95f930bbbbddfaeb9071fa9395281a6b934e3a23b0f238a3b93e1973964d9a9b98b2f273ceb4a9aba3ccab6b9e3ba033b48220ebb19fcaf3b6290a93b034407bb782fa1b89335943bb388a7b9655cc0b96a361d3c67b9b0b99e28cf39076f2dbaf05afdbafa6cb43962bc2e3bd590bebc30339f3b4476a23963e6663bd7ad183ca5c00cbb8a69c13956f574ba97dcf93b97098d3bd471ae3bcbb06dbbfddca9b9d7c803bc3eb703bc9bdaa8bb1c6718bc8e5bcebb224c013bcb7684bb4d85943b2ef403bcc090893bf736aa3beb62a13b3c1cb6bbb821a7bbaee808bbfe3dd33c0000008027b0f5bbd6e09d3ce2db183d576fb7bb3b9761bc4111813be54cbcbbab65043c93ce1cbce0b3c6bbca4e953bb347fabbc466ff3a88f532bc11bf4c3b72636dbc00000080850afebbaaba5e3b476f973c7ae755bbde44dbbbfac1633bab7793bbf3ae90bb010a84bb3a1c2cbc6597d6badcd277bbddbbfe3b5898933b6063903b0d8fb33b028d8e3b2adcdcba9f1585bb2e91b9bb582aa03b6334f8bb6e31333b5569253b1e71533b8e977e3bcaf945bba6b59c3b603ab2bb02c88e3b0ae4493bfc457ebb2ae3ddbbe8f9943b0c38a4bb160ed73b73adab3bb6100e3bf28fd83baa70603bad2683bb9d90033c52703a3c9546693b7d34903b63a6b83bf1af9cbb3b19a23bedd0f8bb58efb13b105b72bb17300abc025488bb0a5b543e33573a3b24eff2bb286f75bb5d55a9bbd8e4803beea116bca9cc2d3b1e1205bc1adf75bbfcaa413bf8b491bb3050903b6537a83c1736213cc6271abaf7b6293c98bae33be7b710bb07e333ba55389dbb41441f3c8bf89abbb9acb6bbdeb9acbb416e053be7a63fba124e36bc396d97bb000000809a5a083c15d242bca07d0abca36bba3c09ac8e3cf4ae85bb51f5cd3b8abb18bccc0f383c4a58dc3b335a9ebba65c0b3c2324d9bb35bbb83c748069bba62961bc000000003e13193c863f71bb752b1cbc578e6b3b5807f33b633e9abb9e8dac3c78dcb03c7b35193ac5df483cca37e83ad74a50bcbfd529bc33469cbb786498bbafc6c1bbe0f895bba7a7ed3a8ef7a339cb5ccd3be140abbbc2041a3ce9e950bb828f5ebbd63a6fbbdd1d85bb9d07a93cdc24a7bb765ac53b467b96bbe863b4bb083ea73a7869f83b4cf49dbb874003ba2440dfbb356db8bbf63d2abb79b4d5bb3b1bafbb27487139a45115bc45e7a8bcf34775bbfb9e98bb68e4c7bb1e930fb736e8acbb6c4b753cce27b5bb830ba83c91ce1b3cdc1def3ae198133ef5e688bb6b67073cdd1ac53a27b589ba81469fbbe150293c3c2884bba35bdd3b1583ba3ac3a194bb3debb13c495799bb078c2ebc384b7d3c97a8493cebb6853c73bb4d3c024dd83c696ca13b1cc702bc6847243ce3ac5dbcfa771abc96221fbc6147fabb3641023cb496023d28f266bb00000000bf65693ccfff0d3cbf68a8bb3b268bbc15de51bca098e1bb9c5980bdec61ee3c66cf983c1024423c51e0febb12336c3c25bd1c3dcebf50bc88eb4cbc0eaea73c00000000c56c163c597c5fbcaa7b593cb7d2e33b7b235a3c0c2447bc95c9edbba8320abc75b98b3cb7d19a3cf51d623bcd0a023d7e91ef3c725604bc91fafdbbdf1f21bc2f3bfcbb274a493b7c78393cdb0e213c01a719bc0a0368bd6ad23cbc210741bc0288df3c6303d1bb8c93bbbb97420fbcbe16353cc8bc18bcf9a61c3d62882a3c8a25683cff2e01bcb0580e3c5b11f33c47dd10bc5b522abc4230df3c6ca21c3d13c0103c8129e33c199e5c3c05752dbc9515f0bba0b724bcac0b383c1f2b12bcbe768d3c80baf23cd6fbc9bb1b04843c84da173cae2dbabc64e63dbc08d8613cbd872b3c029c2c3ce63be03c5e41853c608888bd90f692bd68bf2c3cd0f843bc4497bcbb3161e4bb4ede983c42e72bbc0283dd3b176925bcd6d71bbc7ba42cbb911a6a3dadca0b3c68582fbcc664f23c629c1b3c4f33133cd046413c7eb83c3ddbe0d1baf307ad3b00000080101215bcc0708e3ca925dd3b7899f33cfdb1493dc7bbf43bfb8b5dbb6ee9d2bb584924bcb3cf0abc0b6c0c3ce93e14bccd51943a3302dd3acfabb03ca9c22cbc000000005cb22abcaef7f33cdf6aae3ba949d6bb1ef214bc878db23c3863783b62c5363b67d0eb3c5e192dbc75b57cbb3d43ecbae55cd1bb0cd10a3c00d4083c8efd223cccb5063c1b2d70bb3abcbd3c883c14bc0f01133cee04963c6d7bad3c7480353cba707fbbc16cf63bcdd4a939ad1f123cde2f0cbc2c76053c59ff09bb009bba3cb24a0cbca7750b3c64f9493d982287bbbe111e3c7f48483cd59b5bbbea43e1baf906243d99f3e1bbbd01863c4f95d73c25a8073cfa81273c42548f3cef4b153c800841bc318aa9bb7c98873a55c218bc1338373dfa26bb3c22f2c53c6bbc0dbcc7900e3d0819da3ccec359bb9a671fbcfee714bcbb3f74bb8851ce3c1c76ac3cd7fef039437e0a3ccb42bcba11ea103a388af63b94700f3a4ef6293ad86816b900078b3bd1c62cba4ee1213a7a4b2a3bb98b30ba291c30ba4d97813b71c3033c9815a33b627549ba000000804646103a39a742bb747c0dbbe3ff41bb1186043b9aad27ba947610bad46e52bac8a9053acb9e223a86122dbafce80f3ae1144cba610bc73a34b4543be4f2bbbb00000000dbcd253ac4727d3bcf8cf33a44811d3ac114213ab973fd3a78684ebbfd3384bb29a1ed3a4a70063a11fb103a3f3aa83b629d2aba74f52cba6d1d2cba7aad31bab36e2bba566e013a79481d3b5c663c3a09cf2fba731f29bcc28e1c3b7067313b8bbaa6b9454d28ba15bab6bad4e82eba107a263a51992bbabaa220babbdc023bfd62103a28172dba1db3003cd7ef11b9c15330bae79bbc3a25ae20ba21b1feb95d37183be0206fba67882bbb784a883bba292cba034132ba4df5f43b60222fbaf5b10a3a75e20a3996f8f1bad29f0e3adb20b8397d2257bc2faa893ba3d90f3ab059bf3abba4db3b7757cdb9cde80d3a934d85bb4b8be639fadd0e3b2bb99b3b6dc792bb95cf2dbae68660be8b1d7f3e2632363e6a588c3e0dc7453e8a4979bd1d81593e87b001beae177e3e4f7449be4d9119be437e10bed7162dbe5e43333e3d94acbe80726ebd000000008bb1683edfc6573ebafeb0bdda2e62be36b673bed771d6bd2c5f453e93cd52be9a55963e74b73f3e90e102be14af6c3e2db5afbe2920f4bec3a4fabdc533b53e00000080be5a753e34650dbe4d70473f2edcce3d45ca513ebb4615be2b554bbf9d8900bf1c142f3e7350a23efc363f3dce2ea5bed70f5dbe30da00be4a45fabd5c2c24bebf70f5bdec31433dac40363ef82f333e4d140fbe16dca83e1aabccbd39e8c2bd7f85c2bd7d4bd7bd62b629bf3e2d0bbe0a0a2d3edcbcf6bd11c8c3be4ca7123e92f7543ea87e02be0c1d2d3e5f362abebc491bbe7f4c95bd614426bee96ed8bed1ba3c3e666850bee6ddd53eda2819be1c5efbbd970e2abed2e41c3e043410be6a7d983ecb6910be90d301bf8248823e5c5f1f3e50043c3ed31cfbbdb4c6663e1b1d083e27e14b3eee2aecbd72008c3eb518e03e444e783e3fe10a3e59940dbe1c03e6be9f11fdbd845eda3dbbd702beb486b7bdce1210be4662cabd997aff3ca8acd8bd5d06843d914d02beb963c83d9ca89c3d954a933d7154ab3da863b4bd1ba5283ef949f03c000000004c7ceebddd4ad1bdb34f333d5226db3d8e4ee83d5ec3593d8c34cabd488ed83de8691abe0e1ec4bd1041853dd79cf2bd503b2f3e7b316f3e4cdf7b3d0f623abe000000807d95fbbd06008d3ddcd1c6be1f1152bd17cdd6bd0a1d983d8d68d03ea043833eba4ab0bdf7d026be8359c0bc3967213e041ce33d3e29833d14a97e3d139ca73da1ae793d8060c4bc8356b7bde92cb7bd2ed5913d1c2d2abe50a24f3ddcf4463d94d5473d83a45a3dfce4b13ed5ce8d3dd2d1b0bdde047b3d6462433e65aa94bdaa15dabdfbda843ddf6caebd139fae3db36f9e3d67e8183d6bf4aa3d48e8573e985cbdbdc40fd63dbacb50be5309983d43cb7f3ddaafad3d4ad59ebd6bfe923d7fa51cbe58b4933de72d873e13a905bede95a0bd7d6cbabdcc197e3d5e80ecbd63418abd023cccbd87c7723da8b70fbe2a2867be97f7febde8028dbd3f9c8e3d8e4a6b3e19c6803d64c364be492c7e3ea28b373e97c28b3e8750453edc6c7ebdc7ad5a3ebebd01bead267d3ef16349beeb7919beaf7510be7b8e2dbe0fc8333e5bb5a0bea8de6ebd00000080e2f0673e49ed5b3e0ff5b0bdadf362be411c79be6dc5d6bd38f5473e5cfe52be16a8953ea54c3f3efbec02bec1e56b3ea8e6a6beceeefcbe360af8bde438b13e00000000fe7f743e219a0bbe578b503f0c26cf3d7a3a513e365516be9dbc4bbfd3f500bf66902f3e5686a13efa6a403dd3e599be7b1e5dbe9ce800be3b6cfabddc0224be459ef5bd6a68443da0f7363ee9db323ee40d0fbe9c41a63e8c16cbbd8073c2bdc758c5bd759dd7bd9bd829bf9d2c0bbe6ac32c3e52e9f6bd1dcdb9be9ba9123eaa61543eaa8a02beaf7d2d3ebbb72abe432f1bbe509694bd083127be2a22cdbec25e3d3e8c9950be2984e23e170217be3d83fbbd95da29be504f1d3ebd2b10bec5ca973e92d110be045402bf55c9813e1ceb1f3ed27c403ef27ffabd3b0a663e5ed4073e34104d3ecfe2eebde06a8b3e4098ea3e7f7e7c3ea2ba0a3ead3e0dbe56e6e7be4d34fdbda585d93d565202be9adfb6bdd9830fbe879ac9bde754003dfad4d7bd69c8833d9cc801bea9a2c73def389c3ddaed923dddc2aa3d3cc1b3bdc90c283ebfadf13c00000000f887edbd1c7dd0bd6f8b333d324cda3da364e73d3ead593d736fc9bd35b7d73d87d519bedf5fc3bd5c00853d67a4f1bd58a12e3e929a6e3ecf6f7b3da3c539be000000006f93fabd0aa88c3d88b0c6bebaf651bd98f4d5bd99ae973df84dd03e3efc823e46afafbd813726bec6c4c1bc63d1203e0f38e23d56ed823d85417e3dfb17a73ddb51793d9acec5bc5aafb6bd5682b6bd407b913d899329be5d954f3dedfb463d3dd9473dd18b5a3d75b6b13ebc7c8d3d7832b0bdc9a57a3d02c6423e454294bde339d9bd419b843d8dd4adbdce06ae3d31fc9d3d5952193d8662aa3d264d573eafabbcbdf03bd53d532f50be229b973dad607f3dfe20ad3d86599ebd9fa1923d940f1cbe814e933d2fe8863eda2105be8016a0bd11c0b9bd30a57d3d8f8eebbd6eee89bd1e75cbbdf16a723d0f290fbe186166be26f5fdbd51aa8cbd14418e3da3b26a3ef78e803db37c55be8869803e551f343ee1688d3ef091463e67047abd32cf543e448a01beb9c97f3e5edf43be38bb19bef68410be0e5427be2b1c313eda8aa5be8b506bbd000000001f106a3ea4754d3e08b6afbd824756be411864be609dd5bd781b453ed7a654beea8f973e7373403ecebe02be091e6e3e4d0aacbe8d43eabed2b3f5bd1d09b73e00000080f3ed763e3d9d09be7ae8433fd0eccd3d6ccb523eb88314bec41f4cbfad7a00bfb3112d3eafc0a33e9b7c3a3d956b9ebe160a5fbeb9af00beb8d9f9bd597c24bebbf7f4bd1724403d29fd333e8996323ec9160fbee170a63ea862cabde5e5c1bd27dfc3bdf772d6bd58af2cbf06240bbe0b7d2d3eae46f6bdbadcbfbe0ae7113eb604563e525a02be213f2b3e9a632bbe177c1bbef8df94bd6ac827be0811d4be4cee393eff3152bee817cd3eac6e14be13f6fabd0d742abe89e31b3e3a3e10be16c5993ea6e910be3fe703bfac2f833ef7a21d3e7909373e8ee3f7bdd21e683eddac073e9689483e3d17eebdeb118d3edf18e23eadd2783e23610a3e06310bbef644e6be7ea1fcbdd5fc54be10f67e3ee44a323e40788c3e81c4443ef9a975bd46e1523e93c9ffbdb4e77d3ea3f442be80fe17be65d30ebeed6f26be7f4a2f3efb84a4be77da67bd00000000242e683e481d4c3e10a2adbdd0c855be48bc62bef58fd2bdbc95443e4eb652be269f963eb89e3e3ea51801bec03a6c3ea7feaabef522eabedd0ff4bdd458b63e000000001c0c753eadc408beb11d433f38f3ca3d58f1503e7ba413beaa0b4cbff38300bfe6452b3e46cfa23e204c383d95699dbe50115dbe5e19febd0d9cf6bd6fb722be14bef1bdc62d3c3d292d323ee5ef313e1d660dbe7c24a63e8ad5c8bdf659c0bd7e0dc1bd856cd3bd5f882cbf457609be5eb42b3e130df3bd07cabebe3a36103e2128543ed9b400be3f72293eb79729be3bbc19bea27493bd7b0026be49f4d2be4216383e044450be0965cc3e0f9213bee4b7f7bd54ab28be262a1a3ef8880ebeb615993e2f3b0fbe2ec103bf733d823e33e41b3e43a3353ea33af6bd793b663e5506063e46aa463e6cffeabd171e8c3e1e40e23e3653783e79b8083e09560abe8942e6be3d6ff9bdbd38d93d863e02bebf73b6bd4a890fbed80bc9bdf4adfb3c5db3d7bd6f6a823d34b501be4a36c73d35f69a3d6f9f913d6f17aa3dd251b3bd7c66283ede43ec3c00000080903fedbd9345d0bdc3a9303d1506da3d815ee73d29ce563d1dc8c7bdcc47d73ddbee19beeecac2bdf8a3833d3564f1bd010b2f3e814a6f3e1579793d78ea39be00000080c45dfabda5c78b3d4464c7be72ac4fbd4780d5bde0c0963d090bd13e3866833e4436afbd9f6326be3986bdbc511e213eb3dbe13d858e813d097d7b3dc9e3a53d9088763de970c1bcde44b6bd13e0b5bd472b903d739129bee15d4d3dd9b3443d1167453db9af573d3f56b23eca288c3d9c79afbdb1db773d2c51433e6f8f93bd58cfd8bd553e833d5e58adbdba47ad3d43bc9c3d72ed163d379ea93dedf6573e1a4fbcbd4fc8d43dae9a50be7ecf963d489e7c3d47f5ab3d02bc9dbd1253913d5c271cbef35d923de557873e491805be1b819fbdf021b9bd76a77b3d5f44ebbdc82689bd8737cbbd642b703d59300fbe636d65beae3efcbd3fe88bbd665d8d3d2b616b3e6f5e7e3d33c4ef3d5a4ff3bd7221abbd56eb05be0ea3bcbdde3df03cb7dfc9bdeb15773d1eb0f2bd5dc1ba3dd366923d99b6893d81cd9f3d1c33a8bd0aed1c3e4f05e13c00000080dacfddbd5efae8bdeae7273d86fcec3d8ad5023e45194c3db68abbbdffc7c93d53820fbe25d1b6bddc5d793dd2a2e1bdba0d233ec440853ea3646b3d857249be000000007043eabd30ab833d07e5cfbe76a644bdd424c8bdbff98d3d7c0be53e2564933ec465a4bd3e031bbe2e56b5bcca32163e3192d33daa7b753da05e6e3def8e9c3d62bf693d4910b9bc23efaabdd2cfaabd035c883d22501ebef256423d6b493a3d002e3b3dc8e94c3de1f9c33ea59f843d07eda4bdcdfd6a3daec8353e0fc58abd45e9cabd99a0783d9faaa2bd18e4a23d8b0c943d8d7d0f3db27d9f3d48dd483e4686b0bdc977c73d3ebb61beade78d3d7a6b6f3da931a23d523394bd726f893d4b9311be6fee893da5ab933ee588f8bdb6d395bdc374c6bda6756d3d41f9dbbdec1c81bde952bebd800b633d339705bec81c70be3e29ecbd59ab83bdd329853df8b67e3eb00a713ddfe7da3d302f03bedef5b7bd617710be3adecabd9925003dac34d9bdff59843d94a402be1adfc83dc9099d3d93a6933da9bbab3dbad0b4bd7523293e061df13c000000803316efbdebccd1bd67cf333d53b0db3d8ee3e83d1c555a3dfab0cabd6816d93d61d91abe7895c4bd4295853d833af3bdefc02f3e6800703e197b7c3d20f43abe00000000ea3afcbd76558d3dc78ec7becc9652bde652d7bd9478983d8d2ed13eacb8833e0bb5b0bda74d27be3905c1bcc5dd213ed4ace33d817c833dbf4b7f3deb03a83de74e7a3d9a0fc5bc92c5b7bdcf9ab7bd5030923de4ac2abe712a503d8179473d7a5a483d66365b3d318db23ea6278e3d893bb1bd31a67b3db0fe433ee10395bd989edabd042f853df9d5aebd7b08af3dc5d19e3dd85a193d715bab3d3f9c583ee0cfbdbde795d63d457751bed464983d2137803d951bae3da5349fbd095a933dee161dbe810d943d77a7873e8b0306be42f6a0bd9eddbabd9fb67e3db718edbd44958abd3cbaccbd105f733df81b10bef0ee67be7fa0ffbd3c588dbd8ff28e3def146c3e0718813de067dc3d06c0edbd469cb0bdeadf02be9afab7bdf09be93cdb30d3bd137f703d05c5ecbd0b1cc03da3928e3dee15863dd94aa73dd501adbd8925193ee9f7db3c0000008069b6d8bd8bd8d8bd54ad233dc8f8de3d90f3ef3d7c8c463dcc09b7bd9ce5c43de6400cbe894cb2bd5ab9723da474dcbd0a1c1f3e7f24853e7081683d7f3629be000000806996e4bd6029833d2114cebebb803fbda83cc3bd89748e3d60d6fe3ef831963e57f5a8bdeb7f17be8437b0bc0497123e6177ce3db5ee6e3d23fd673d627f983d127a633d12e6b3bc091ab0bd9d90a6bd6dc3843dcf6f1abe97e73d3d42b3353db840363d7958473d2e08d53e711d813d78cea0bde6b0643d7357313eab9c8cbda337c6bd9000723d57d4a6bd08de9e3db62e903d2adc0a3dc98a9b3da3e4433e9761b6bda3a2c23d88e95cbe44258e3dc703693d85019e3d260797bd4ed0853dad460ebec774863d7b2d9a3e4bddf2bdaf889cbd62bdbebdd3b36a3d1eead6bd600882bd10dac5bd982e5d3d5b8d02be3cc450be27a8e6bdc1da84bd8da8843d7dbe813ec89a6a3d5d4fd93d504a02bef881b6bdda840fbe6651c9bd08e5fc3c039fd7bde720833dfabf01be1a5ac73de7b49b3d255c923dbf54aa3d0961b3bd2b1b283e27d3ed3c00000000bf63edbd2f3ed0bd8cc5313d5e17da3d593de73d7e1b583daf29c9bd3481d73d4fdc19bef20ec3bdf15a843dc583f1bd42b22e3e17b56e3ef0137a3d86d939be00000080327bfabd7f108c3d1eafc6be445850bdf2b8d5bd3027973d7c49d03e1809833e8d49afbd494426beb813bebcb2dc203eb50ce23d8f44823d19e57c3d21a3a63dc8ed773d3b12c2bc7b52b6bd2322b6bd84e7903d63a229be96fa4d3d0855453df235463de0fc583de3bab13e86e38c3d66c9afbd4844793d62dc423e51b693bdd100d9bd36f5833da96cadbd4d9fad3d067b9d3de17a173d2ef6a93d9f66573ea456bcbd4703d53dde4750be7513973da7067e3d68b4ac3dbbdb9dbdc20f923d03181cbe9ac1923db0f4863e731b05bec99b9fbd8f67b9bdef4c7c3d4e68ebbd955389bd3531cbbdf603713db5290fbeafa966be4ce2fdbd4e138cbdb0ab8d3d20cd6a3ebec67f3d9ef957bec152813e51cb353e30558e3ebd52483e7b4a7fbd8d69563e912703beafcb803e766246beae671bbe1e3012bed9ca29be58b7323e5333a6be425070bd0000000002d56b3e9e104f3eb773b2bd96c058be00b365bea4b5d8bd05fb473e264856be637f983e1c29423e675d04be1de46f3e63e3acbeebabebbed539fabdc7e5b73e0000008056b7783e41f20bbe89cb433f31f4d03db489543e23e316be25e44cbf124b01bfc8ae2e3e2cb1a43e2ba9403df0169fbee4a860be1f4e02be7910fdbd392e26befc28f8bd68ad443d439d353ed46c353e7ac010be6a06a83ec8a1cebdf813c6bd4ed7c6bd5a93d9bd51652dbfe8c90cbe592c2f3e997af9bd79a1c0beb47e133eabc4573e0df903be26d92c3ea30c2dbe23271dbe1b9e98bde47029bea0c8d4bef08a3b3e45d453be30e9cd3e5fcf16beb92dfebdf1282cbe84801d3e71e411bedab19a3e8e8e12be2aad04bfee17843efd391f3e6195383e086cfcbde1e1693e263f093eca2b4a3edc29f1bd7efb8d3e0590e33ef7c97b3ebbf50b3e55880dbe9ddbe7be46e8ffbd1e25dc3d43edebbdb496b2bde2cb01be45cbb6bd770cdf3c01c6d8bdc1256f3d43f5eabd8362c53d3cc28d3d4c54853dd29ba53d9770afbd10b4173ecd44da3c000000007929d7bda647d6bdc5a7223d5f05df3dcf97f03d8766453d51a8aebd044bb93dab090bbe092cb1bd0b5d713d14dcdabd85401f3ef69e863e5642673d834627be0000000027e2e2bd9f81833d66c6cfbe2b5e3ebd45efc1bd2f718f3db1c6033fe13b983e9b6eabbd711b16bea4adaebcd0d0103e190bc23db6976d3d9daf663d159c973d4532623dd556b2bc09a2b2bde48ba5bdf103843d55930ebecdbc3a3dfc6c323d04ba2c3d4a32463d0351da3ec763803dded69fbdad67633de850323e85e68cbd5ce2c4bd54a5703dbedaa8bd0bf1953d535b8f3da31c073d67eb923d5e27463e09a1b9bd6537b73d18d55dbe873e8f3d0bb5673df5129d3d348197bdfb0e853dd2060dbeb05e7d3daf629c3e4dfaf0bd170c9abdae6abcbde6c6693d0463d5bdf8c081bd8700cabdae54513df47a01be929b4abeac77dabd8ba984bd5f2e853dc5af833e124a693da068db3d435203beb583b8bd3e9310be5542cbbd5318013dc8b9d9bd6eef843d55bf02beff62c93d6e9d9d3d903b943d7c4bac3d1b60b5bdac48293e54fff23c000000800d6aefbdb152d2bd28e5343d122edc3df060e93d657b5b3d5716cbbda297d93decde1abedbfcc4bd882a863d5e8cf3bd52e42f3e28f76f3e889f7d3df5ae3abe000000000d91fcbd8ce78d3dd882c7be65b053bd17b2d7bd7b08993d5422d13e67b2833e2a45b1bdc15b27beeca6c2bc9806223ef729e43df711843d263b803d8595a83d58797b3d59b0c6bcfd53b8bd1a0fb8bd67c5923d5abe2abe1d48513d1a93483da975493de55b5c3de780b23ee0bc8e3dbaa9b1bda4d07c3d8618443e2c9895bd10fddabd50c4853da666afbd4696af3def649f3d875f1a3d24eaab3de3ac583eff5cbebd1d18d73de03451bef2f5983d2acc803dc3abae3dd1c79fbde8ee933da02a1dbe939f943df69f873ee62506be5d89a1bdf268bbbdc9d87f3de56dedbd112a8bbdd742cdbde882743d663810be419467be8de4ffbdfcec8dbd77838f3dfa106c3effac813dbb9bd83df8e801be3be5b5bd5c1f0fbe06acc8bdc9bcfc3cc8ecd6bd0ab4823d0c5f01be68b1c63dba2d9b3d33de913d7bc1a93d9ec6b2bd76ae273e0ec5ed3c00000000c2aaecbd1590cfbd9163313d7863d93de182e63df77c573d8680c8bddaced63d3f7419bedf6dc2bd69ec833df5c8f0bdb5442e3e68416e3e4a4b793dc16a39be00000000a3bcf9bd9f9a8b3dbc70c6befed24fbd1c0cd5bdaea5963d030ad03ee3ce823e66b2aebdb3d925be5c59bebc4671203edb54e13d8bd8813d0d167c3dea11a63d5025773d6255c2bcd7b5b5bd8f8ab5bd1b6b903d653529bedd6c4d3df0d3443de5b2453dab5b583d587eb13e516b8c3dc436afbdba79783d666c423e6c3893bd4e52d8bd1787833dfcd6acbd3f09ad3d1ff29c3d1640173d2f63a93dfdf4563e91b5bbbd4c52d43d74d64fbe0592963dcf357d3de31dac3dd9539dbd6592913d44af1bbe5244923d61ba863e42b904be32129fbd88c8b8bd8a817b3d3fb0eabdcee088bd3986cabd3046703d5bc40ebe001b66be521ffdbd859d8bbd10348d3dc4596a3e52f37e3dd45312bfaa602f3fe11df63ebb01413fd9d0073f7a322cbe4829113ff6b1b0be71a42e3fb04c06bf5589d1be8e02c5be4ccee5be0ce2f13e93a161bf7fa221be0000008066e21f3fe5430c3f2b1371be2dd712bf8b9d1bbfebcd91be8376073f3e0611bfeac64e3f7c9e033f4456b2be03a1223f78686abf9a0ca0bf4028a9bed568793f0000000054a3283f4649bdbe97d3044098a78d3eb917103f8020ccbea7380bc00f93afbf6e6cec3e44555f3fdc9c023e1ef757bfe81018bf1187afbe5e6baabecc24e0bec01aa7bed44b053ef6d5f53e55fcf53e6312c3bed4af633f98978bbe09c985be245586bef96492be41baedbf6cb8bdbe2880ed3e13f7a7be76a582bfc688c73edc3f123fd4cbb1be33ebe93eab18eabe37eed3be14f64dbe0e34e5be785690bfe6ddfd3ea95b0fbf14af8b3f3207ccbef42fabbe9c3ee8be041ed53e8aa7c4bea8cd513faa28c6beffc3b4bf8917333f1f72d73eb7f2f93ebba5aabe9d8a1e3fcd9fb93ef1dd083f7006a3bef684403fd48d9a3fe9ab2a3f1f4fbd3e516fbfbe72649dbf5459acbe3ce2d63ea5fae63e06cfa93e0415b53e83fcd73e8a1c973ee8499d3e09299f3e10e6c63e0965983e4656b23e3343b03e9e43b23e57bd953ee7f3f33e658b873e941a7bbe04d2bb3efa54463f9b0d723ede9fb43e4aa5163f555c8c3e7521803ed201e23e9267873eb546b83e07bcb03e8701af3ef7e2da3e2b1a333fcc08b23e71089b3e6536c2bdf12ce43ec3c4a43ec9deee3e6c04af3e90f0c53e19aa783ed7025a3f4a48103f9794d23ef147973ed7634a3e9084ee3ef8e9e73e1837a83e1fe2ac3e7ea6bb3e24ec9b3e3dc32f3e27f7bd3e2315cd3e3a67af3e5dde993e6209bd3e991da23e0112953eeb4cc73e4ea7373f4389b63e53e5bd3e38aba33ea7beed3e2dded33eadb68e3ecaeeb23ec79a963ef6c5d53ef7deb93e4ef4a53e4b2ec33e7825013f4d50bf3efc34e03e747f973e4718a23eeadfc03ea089cb3eab6da43e8e25a33ebef7e43ea9b3ea3eebbb0f3fcbaa8f3ef829043fcc263e3f917b973e8b8aa43ea938eb3ef7ec9a3e9acda03e25379f3ef927b13e73b5b23eedf0d13e6f15993ef928033fdae3d63e81e4963d +\ No newline at end of file +diff --git a/gcc/opts.cc b/gcc/opts.cc +index 432b822e8..7508fc817 100644 +--- a/gcc/opts.cc ++++ b/gcc/opts.cc +@@ -3486,12 +3486,19 @@ common_handle_option (struct gcc_options *opts, + break; + + case OPT_fauto_bolt_: +- opts->x_flag_auto_bolt = true; ++ if (get_optimize_decision_from_ai4c ()) ++ { ++ opts->x_flag_auto_bolt = true; ++ } + /* FALLTHRU */ + case OPT_fauto_bolt: + if (opts->x_flag_bolt_use) + error_at (loc, + "-fauto-bolt conflicts with -fbolt-use."); ++ if (get_optimize_decision_from_ai4c ()) ++ { ++ opts->x_flag_auto_bolt = true; ++ } + break; + + case OPT_fbolt_use_: +@@ -3499,6 +3506,10 @@ common_handle_option (struct gcc_options *opts, + if (opts->x_flag_auto_bolt) + error_at (loc, + "-fauto-bolt conflicts with -fbolt-use."); ++ if (get_optimize_decision_from_ai4c ()) ++ { ++ opts->x_flag_bolt_use = true; ++ } + break; + + case OPT_fbolt_target_: +-- +2.25.1 + diff --git a/0362-Modify-cache-size-for-hip10a-and-hip10c.patch b/0362-Modify-cache-size-for-hip10a-and-hip10c.patch new file mode 100644 index 0000000..cf4a2cd --- /dev/null +++ b/0362-Modify-cache-size-for-hip10a-and-hip10c.patch @@ -0,0 +1,43 @@ +From a7a7cc3f77c10daf759681b1a45b68319d45f1ab Mon Sep 17 00:00:00 2001 +From: liyunfei +Date: Wed, 9 Apr 2025 17:13:03 +0800 +Subject: [PATCH] Modify cache size for hip10a and hip10c + +Modify the L1cache size and L2cache size of the hip10a and hip10c. + +Signed-off-by: Tian Tao +--- + gcc/config/aarch64/aarch64.cc | 8 ++++---- + 1 file changed, 4 insertions(+), 4 deletions(-) + +diff --git a/gcc/config/aarch64/aarch64.cc b/gcc/config/aarch64/aarch64.cc +index a06c2c515..389dcd646 100644 +--- a/gcc/config/aarch64/aarch64.cc ++++ b/gcc/config/aarch64/aarch64.cc +@@ -1592,9 +1592,9 @@ static const cpu_prefetch_tune hip09_prefetch_tune = + static const cpu_prefetch_tune hip10a_prefetch_tune = + { + 0, /* num_slots */ +- 64, /* l1_cache_size */ ++ 128, /* l1_cache_size */ + 64, /* l1_cache_line_size */ +- 512, /* l2_cache_size */ ++ 1024, /* l2_cache_size */ + true, /* prefetch_dynamic_strides */ + -1, /* minimum_stride */ + -1 /* default_opt_level */ +@@ -1603,9 +1603,9 @@ static const cpu_prefetch_tune hip10a_prefetch_tune = + static const cpu_prefetch_tune hip10c_prefetch_tune = + { + 0, /* num_slots */ +- 64, /* l1_cache_size */ ++ 96, /* l1_cache_size */ + 64, /* l1_cache_line_size */ +- 512, /* l2_cache_size */ ++ 1024, /* l2_cache_size */ + true, /* prefetch_dynamic_strides */ + -1, /* minimum_stride */ + -1 /* default_opt_level */ +-- +2.25.1 + diff --git a/0363-SVE-Add-std-find-with-sve.patch b/0363-SVE-Add-std-find-with-sve.patch new file mode 100644 index 0000000..03b5502 --- /dev/null +++ b/0363-SVE-Add-std-find-with-sve.patch @@ -0,0 +1,530 @@ +From ed2666ad49a52ff3950b5ad4e0127fe4a9d1bef7 Mon Sep 17 00:00:00 2001 +From: blunce +Date: Mon, 7 Apr 2025 16:47:16 +0800 +Subject: [PATCH] [SVE] Add std::find with sve + +--- + gcc/Makefile.in | 1 + + gcc/common.opt | 8 + + gcc/gimple-ssa-expand-sve.cc | 256 ++++++++++++++++++ + gcc/passes.def | 1 + + gcc/testsuite/g++.dg/tree-ssa/find-with-sve.C | 137 ++++++++++ + gcc/tree-pass.h | 1 + + libgcc/config/aarch64/sve_std_find.c | 32 +++ + libgcc/config/aarch64/t-aarch64 | 1 + + 8 files changed, 437 insertions(+) + create mode 100644 gcc/gimple-ssa-expand-sve.cc + create mode 100644 gcc/testsuite/g++.dg/tree-ssa/find-with-sve.C + create mode 100644 libgcc/config/aarch64/sve_std_find.c + +diff --git a/gcc/Makefile.in b/gcc/Makefile.in +index ef7733580..ab6ad8206 100644 +--- a/gcc/Makefile.in ++++ b/gcc/Makefile.in +@@ -1413,6 +1413,7 @@ OBJS = \ + gimple-ssa-backprop.o \ + gimple-ssa-evrp.o \ + gimple-ssa-evrp-analyze.o \ ++ gimple-ssa-expand-sve.o \ + gimple-ssa-isolate-paths.o \ + gimple-ssa-nonnull-compare.o \ + gimple-ssa-split-paths.o \ +diff --git a/gcc/common.opt b/gcc/common.opt +index e6ffa1c58..23544740d 100644 +--- a/gcc/common.opt ++++ b/gcc/common.opt +@@ -3870,4 +3870,12 @@ fifcvt-allow-complicated-cmps + Common Var(flag_ifcvt_allow_complicated_cmps) Optimization + Allow RTL if-conversion pass to deal with complicated cmps (can increase compilation time). + ++ffind-with-sve ++Common Var(flag_find_with_sve) Init(0) Optimization ++Enable replace std::find with sve ++ ++fsve-expand-std-find-threshold ++Common Var(sve_expand_std_find_threshold) Init(8) Optimization ++Minimal length of the array to search ++ + ; This comment is to ensure we retain the blank line above. +diff --git a/gcc/gimple-ssa-expand-sve.cc b/gcc/gimple-ssa-expand-sve.cc +new file mode 100644 +index 000000000..9bac95212 +--- /dev/null ++++ b/gcc/gimple-ssa-expand-sve.cc +@@ -0,0 +1,256 @@ ++/* replace the std::find with sve. ++ Copyright (C) 2005-2022 Free Software Foundation, Inc. ++ ++This file is part of GCC. ++ ++GCC is free software; you can redistribute it and/or modify ++it under the terms of the GNU General Public License as published by ++the Free Software Foundation; either version 3, or (at your option) ++any later version. ++ ++GCC is distributed in the hope that it will be useful, ++but WITHOUT ANY WARRANTY; without even the implied warranty of ++MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++GNU General Public License for more details. ++ ++You should have received a copy of the GNU General Public License ++along with GCC; see the file COPYING3. If not see ++. */ ++ ++#include "config.h" ++#include "system.h" ++#include "coretypes.h" ++#include "tree.h" ++#include "function.h" ++#include "cfg.h" ++#include "basic-block.h" ++#include "gimple.h" ++#include "gimple-iterator.h" ++#include "tree-pass.h" ++#include "context.h" ++#include "target.h" ++#include "toplev.h" ++#include "cfghooks.h" ++#include "tree-cfg.h" ++#include "cfgloop.h" ++#include "gimple-ssa.h" ++#include "gimple-pretty-print.h" ++ ++namespace { ++ ++#define TRACE_FUNCTION(fun) \ ++ if (dump_file) \ ++ { \ ++ fprintf (dump_file, "\nprocess function: \n"); \ ++ dump_function_to_file (fun, dump_file, TDF_NONE);\ ++ fprintf (dump_file, "\n"); \ ++ } ++ ++#define TRACE_STMT(stmt) \ ++ if (dump_file) \ ++ { \ ++ fprintf (dump_file, "\nprocess stmt: \n"); \ ++ print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);\ ++ fprintf (dump_file, "\n"); \ ++ } ++ ++#define TRACE_REPLACE_STMT(stmt) \ ++ if (dump_file) \ ++ { \ ++ fprintf (dump_file, "\nprocess replace stmt: \n");\ ++ print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);\ ++ fprintf (dump_file, "\n"); \ ++ } ++ ++#define TRACE_ARG3_TYPE(type) \ ++ if (dump_file) \ ++ { \ ++ fprintf (dump_file, "\nprocess arg3 type: \n"); \ ++ dump_node (type, TDF_NONE, dump_file); \ ++ fprintf (dump_file, "\n"); \ ++ } ++ ++const pass_data pass_data_find_with_sve = { ++ GIMPLE_PASS, /* type */ ++ "find_with_sve", /* name */ ++ OPTGROUP_NONE, /* optinfo_flags */ ++ TV_NONE, /* tv_id */ ++ 0, /* properties_required */ ++ 0, /* properties_provided */ ++ 0, /* properties_destroyed */ ++ 0, /* todo_flags_start */ ++ TODO_cleanup_cfg | TODO_update_ssa | TODO_update_address_taken ++ | TODO_rebuild_cgraph_edges, /* todo_flags_finish */ ++}; ++ ++class pass_find_with_sve : public gimple_opt_pass { ++public: ++ pass_find_with_sve (gcc::context *ctx) : ++ gimple_opt_pass (pass_data_find_with_sve, ctx) ++ {} ++ ++ virtual bool gate (function *fun) override ++ { ++ if (!flag_find_with_sve) ++ return false; ++ ++ if (!targetm.vector_mode_supported_p (V2DImode)) ++ return false; ++ ++ return true; ++ } ++ ++ virtual unsigned int execute (function *fun) override ++ { ++ TRACE_FUNCTION (fun->decl); ++ basic_block bb; ++ FOR_EACH_BB_FN (bb, fun) ++ { ++ for (gimple_stmt_iterator gsi = gsi_start_bb (bb); ++ !gsi_end_p (gsi); gsi_next (&gsi)) ++ { ++ gimple *stmt = gsi_stmt (gsi); ++ if (std_find_check (stmt)) ++ replace_std_find (gsi); ++ } ++ } ++ ++ return 0; ++ } ++ ++private: ++ uint8_t bit_width; ++ const char *null_name = ""; ++ ++ bool std_find_check (gimple *stmt) ++ { ++ if (!is_gimple_call (stmt)) ++ return false; ++ ++ tree fndecl = gimple_call_fndecl (stmt); ++ if (fndecl == nullptr || DECL_NAME (fndecl) == nullptr) ++ return false; ++ ++ const char *fn_name = IDENTIFIER_POINTER (DECL_NAME (fndecl)); ++ if (strcmp (fn_name, "find") != 0) ++ return false; ++ ++ if (DECL_CONTEXT (fndecl) == nullptr ++ || TREE_CODE (DECL_CONTEXT (fndecl)) != NAMESPACE_DECL) ++ return false; ++ ++ const char *namespace_name ++ = IDENTIFIER_POINTER (DECL_NAME (DECL_CONTEXT (fndecl))); ++ if (strcmp (namespace_name, "std") != 0) ++ return false; ++ ++ if (gimple_call_num_args (stmt) != 3) ++ return false; ++ ++ tree arg1 = DECL_ARGUMENTS (fndecl); ++ tree arg2 = TREE_CHAIN (arg1); ++ tree arg3 = TREE_CHAIN (arg2); ++ ++ tree arg3_type = TREE_TYPE (arg3); ++ if (TREE_CODE (arg3_type) != REFERENCE_TYPE) ++ return false; ++ ++ tree main_type = TREE_TYPE (arg3_type); ++ TRACE_ARG3_TYPE (main_type); ++ if (TREE_CODE (main_type) == INTEGER_TYPE) ++ { ++ if (TYPE_PRECISION (main_type) != 64) ++ return false; ++ ++ const char *type_name = get_type_name_arg3 (main_type); ++ if ((strcmp (type_name, "long unsigned int") != 0) ++ && (strcmp (type_name, "long int") != 0)) ++ return false; ++ ++ this->bit_width = 64; ++ } else if (TREE_CODE (main_type) == POINTER_TYPE) ++ this->bit_width = 64; ++ else ++ return false; ++ ++ return true; ++ } ++ ++ const char *get_type_name_arg3 (tree main_type) ++ { ++ enum tree_code code = TREE_CODE (main_type); ++ enum tree_code_class tclass = TREE_CODE_CLASS (code); ++ ++ if (tclass == tcc_type) ++ { ++ if (TYPE_NAME (main_type)) ++ { ++ if (TREE_CODE (TYPE_NAME (main_type)) == IDENTIFIER_NODE) ++ return IDENTIFIER_POINTER (TYPE_NAME (main_type)); ++ else if (TREE_CODE (TYPE_NAME (main_type)) == TYPE_DECL ++ && DECL_NAME (TYPE_NAME (main_type))) ++ return IDENTIFIER_POINTER ( ++ DECL_NAME (TYPE_NAME (main_type))); ++ } ++ } ++ ++ return null_name; ++ } ++ ++ void replace_std_find (gimple_stmt_iterator gsi) ++ { ++ switch (this->bit_width) ++ { ++ case 64: ++ replace_std_find_u64 (gsi); ++ break; ++ case 32: ++ case 16: ++ case 8: ++ default:; ++ } ++ } ++ ++ void replace_std_find_u64 (gimple_stmt_iterator gsi) ++ { ++ gimple *stmt = gsi_stmt (gsi); ++ tree old_fndecl = gimple_call_fndecl (stmt); ++ TRACE_STMT (stmt); ++ ++ // arguments list process: ++ auto_vec args; ++ for (unsigned i = 0; i < gimple_call_num_args (stmt); ++i) ++ args.safe_push (gimple_call_arg (stmt, i)); ++ tree new_arg = build_int_cst (unsigned_char_type_node, ++ sve_expand_std_find_threshold); ++ args.safe_push (new_arg); ++ ++ // functon declare process: ++ tree old_type = TREE_TYPE (old_fndecl); ++ tree ret_type = TREE_TYPE (old_type); ++ tree arg_types = NULL_TREE; ++ for (tree t = TYPE_ARG_TYPES (old_type); t; t = TREE_CHAIN (t)) ++ arg_types = tree_cons (NULL_TREE, TREE_VALUE (t), arg_types); ++ arg_types = tree_cons (NULL_TREE, unsigned_char_type_node, arg_types); ++ arg_types = nreverse (arg_types); ++ tree new_fndecl_type = build_function_type (ret_type, arg_types); ++ tree new_fndecl = build_fn_decl ("__sve_optimized_find_u64", ++ new_fndecl_type); ++ TREE_PUBLIC (new_fndecl) = 1; ++ DECL_EXTERNAL (new_fndecl) = 1; ++ ++ // call function process: ++ gcall *new_call = gimple_build_call_vec (new_fndecl, args); ++ if (gimple_has_lhs (stmt)) ++ gimple_call_set_lhs (new_call, gimple_call_lhs (stmt)); ++ gsi_replace (&gsi, new_call, true); ++ update_stmt (gsi_stmt (gsi)); ++ TRACE_REPLACE_STMT (gsi_stmt (gsi)); ++ } ++}; ++} // namespace ++ ++gimple_opt_pass *make_pass_find_with_sve (gcc::context *ctx) ++{ ++ return new pass_find_with_sve (ctx); ++} +diff --git a/gcc/passes.def b/gcc/passes.def +index 49001adde..08213f2bc 100644 +--- a/gcc/passes.def ++++ b/gcc/passes.def +@@ -70,6 +70,7 @@ along with GCC; see the file COPYING3. If not see + PUSH_INSERT_PASSES_WITHIN (pass_local_optimization_passes) + NEXT_PASS (pass_fixup_cfg); + NEXT_PASS (pass_rebuild_cgraph_edges); ++ NEXT_PASS (pass_find_with_sve); + NEXT_PASS (pass_local_fn_summary); + NEXT_PASS (pass_early_inline); + NEXT_PASS (pass_warn_recursion); +diff --git a/gcc/testsuite/g++.dg/tree-ssa/find-with-sve.C b/gcc/testsuite/g++.dg/tree-ssa/find-with-sve.C +new file mode 100644 +index 000000000..66d03e2cf +--- /dev/null ++++ b/gcc/testsuite/g++.dg/tree-ssa/find-with-sve.C +@@ -0,0 +1,137 @@ ++/* { dg-do compile } */ ++/* { dg-options "-std=c++11 -O3 -ffind-with-sve -march=armv8-a+sve -fdump-tree-optimized" } */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++ ++void test_u64() ++{ ++ std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9}; ++ ++ std::uint64_t x = 100; ++ std::cin >> x; ++ ++ auto it = std::find(v.begin(), v.end(), x); // matched : No.1 ++ ++ if (it != v.end()) ++ std::cout << "ok!\n"; ++ else ++ std::cout << "fail!\n"; ++} ++ ++void test_s64() ++{ ++ std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9}; ++ ++ std::int64_t x = 100; ++ std::cin >> x; ++ ++ auto it = std::find(v.begin(), v.end(), x); // matched : No.2 ++ ++ if (it != v.end()) ++ std::cout << "ok!\n"; ++ else ++ std::cout << "fail!\n"; ++} ++ ++void test_array() ++{ ++ const unsigned N = 1024 * 1024 * 16; ++ long *arr = new long[N]; ++ long *p; ++ for (unsigned i = 0; i < N; ++i) ++ arr[i] = i; ++ for (unsigned i = N - 1000; i < N - 1; ++i) { ++ p = std::find(arr, arr + N, arr[i]); // matched : No.3 ++ assert(p == arr + i); ++ unsigned j = i - 10; ++ p = std::find(arr + j, arr + j + 1, arr[j]); // matched : No.4 ++ assert(p == arr + j); ++ p = std::find(arr + j + 1, arr + j + 1, arr[j + 2]); // matched : No.5 ++ assert(p == arr + j + 1); ++ p = std::find(arr + j + 2, arr + j + 1, arr[j + 2]); // matched : No.6 ++ assert(p == arr + j + 1); ++ } ++ p = std::find(arr, arr + N, (long)-1); // matched : No.7 ++ assert(p == arr + N); ++} ++ ++void test_string() ++{ ++ std::vector v; ++ for (int i = 0; i < 5; i++) ++ v.push_back(std::to_string(123 + i)); ++ ++ for (int i = 0; i < 5; i++) { ++ auto it = std::find(v.begin(), v.end(), std::to_string(124 + i)); // not matched ++ ++ if (it != v.end()) ++ std::cout << "ok!\n"; ++ else ++ std::cout << "failed!\n"; ++ } ++} ++ ++void test_s32() ++{ ++ std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9}; ++ ++ std::int32_t x = 100; ++ ++ auto it = std::find(v.begin(), v.end(), x); // not matched ++ ++ if (it != v.end()) ++ std::cout << "ok!\n"; ++ else ++ std::cout << "failed!\n"; ++} ++ ++void test_u16() ++{ ++ std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9}; ++ ++ std::uint16_t x = 100; ++ ++ auto it = std::find(v.begin(), v.end(), x); // not matched ++ ++ if (it != v.end()) ++ std::cout << "ok!\n"; ++ else ++ std::cout << "failed!\n"; ++} ++ ++void test_u16_point() ++{ ++ std::vector v = {1, 2, 3, 4, 5, 6, 7, 8, 9}; ++ std::vector v_ptr; ++ ++ for (auto &item : v) ++ v_ptr.push_back(&item); ++ ++ std::uint16_t x = 100; ++ ++ auto it = std::find(v_ptr.begin(), v_ptr.end(), &x); // matched : No.8 ++ ++ if (it != v_ptr.end()) ++ std::cout << "ok!\n"; ++ else ++ std::cout << "fail!\n"; ++} ++ ++int main() ++{ ++ test_u64(); ++ test_s64(); ++ test_array(); ++ test_string(); ++ test_s32(); ++ test_u16(); ++ test_u16_point(); ++ return 0; ++} ++ ++/* { dg-final { scan-tree-dump-times "__sve_optimized_find_u64" 8 "optimized" } } */ +diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h +index 468353d13..e01d86fb1 100644 +--- a/gcc/tree-pass.h ++++ b/gcc/tree-pass.h +@@ -503,6 +503,7 @@ extern gimple_opt_pass *make_pass_modref (gcc::context *ctxt); + extern gimple_opt_pass *make_pass_coroutine_lower_builtins (gcc::context *ctxt); + extern gimple_opt_pass *make_pass_coroutine_early_expand_ifns (gcc::context *ctxt); + extern gimple_opt_pass *make_pass_adjust_alignment (gcc::context *ctxt); ++extern gimple_opt_pass *make_pass_find_with_sve (gcc::context *ctx); + + /* IPA Passes */ + extern simple_ipa_opt_pass *make_pass_ipa_lower_emutls (gcc::context *ctxt); +diff --git a/libgcc/config/aarch64/sve_std_find.c b/libgcc/config/aarch64/sve_std_find.c +new file mode 100644 +index 000000000..0caf1f4f6 +--- /dev/null ++++ b/libgcc/config/aarch64/sve_std_find.c +@@ -0,0 +1,32 @@ ++#include ++#include ++ ++#pragma GCC target ("+sve") ++ ++uint64_t *__sve_optimized_find_u64 (uint64_t *first, uint64_t *last, ++ uint64_t const *value, uint8_t threshold) ++{ ++ if (first + threshold > last) ++ goto Tail; ++ ++ uint64_t m = svcntd (); ++ uint64_t n = (last - first) / m; ++ svbool_t flag_true = svptrue_b64 (); ++ for (; n-- > 0;) ++ { ++ svuint64_t v3 = svld1_u64 (flag_true, (uint64_t *)first); ++ svbool_t v4 = svcmpeq_n_u64 (flag_true, v3, (uint64_t *)value); ++ if (svptest_any (flag_true, v4)) ++ break; ++ first += m; ++ } ++ ++Tail: ++ while (first < last) ++ { ++ if (*first == *value) ++ return first; ++ ++first; ++ } ++ return first; ++} +diff --git a/libgcc/config/aarch64/t-aarch64 b/libgcc/config/aarch64/t-aarch64 +index 5a8feb184..cc2357431 100644 +--- a/libgcc/config/aarch64/t-aarch64 ++++ b/libgcc/config/aarch64/t-aarch64 +@@ -19,6 +19,7 @@ + # . + + LIB2ADD += $(srcdir)/config/aarch64/sync-cache.c ++LIB2ADD += $(srcdir)/config/aarch64/sve_std_find.c + + # Add sme runtime to shared libgcc + LIB2ADDEH += \ +-- +2.25.1 + diff --git a/0364-CFGO-Enable-flag_profile_partial_training-for-CFGO-b.patch b/0364-CFGO-Enable-flag_profile_partial_training-for-CFGO-b.patch new file mode 100644 index 0000000..0ee3bb4 --- /dev/null +++ b/0364-CFGO-Enable-flag_profile_partial_training-for-CFGO-b.patch @@ -0,0 +1,30 @@ +From c5a8fc1ec35310b5f030c05e11af1c32ccf79e4c Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E7=BC=96=E8=AF=91=E5=B0=8F=E4=BC=99?= <412998149@qq.com> +Date: Tue, 15 Apr 2025 11:42:33 +0000 +Subject: [PATCH] [CFGO] Enable flag_profile_partial_training for CFGO by + default Enable flag_profile_partial_training for CFGO by default for better + performance. +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Signed-off-by: 编译小伙 <412998149@qq.com> +--- + gcc/opts.cc | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/gcc/opts.cc b/gcc/opts.cc +index 7508fc817..162e14bc2 100644 +--- a/gcc/opts.cc ++++ b/gcc/opts.cc +@@ -2125,6 +2125,7 @@ enable_cfgo_optimizations (struct gcc_options *opts, + SET_OPTION_IF_UNSET (opts, opts_set, flag_modulo_sched, value); + SET_OPTION_IF_UNSET (opts, opts_set, flag_selective_scheduling, value); + SET_OPTION_IF_UNSET (opts, opts_set, flag_rename_registers, value); ++ SET_OPTION_IF_UNSET (opts, opts_set, flag_profile_partial_training, value); + + SET_OPTION_IF_UNSET (opts, opts_set, param_max_inline_insns_auto, 185); + SET_OPTION_IF_UNSET (opts, opts_set, param_inline_unit_growth, 66); +-- +2.25.1 + diff --git a/gcc.spec b/gcc.spec index 7a27a0b..21df78d 100644 --- a/gcc.spec +++ b/gcc.spec @@ -2,7 +2,7 @@ %global gcc_major 12 # Note, gcc_release must be integer, if you want to add suffixes to # %%{release}, append them after %%{gcc_release} on Release: line. -%global gcc_release 77 +%global gcc_release 78 %global _unpackaged_files_terminate_build 0 %global _performance_build 1 @@ -135,6 +135,10 @@ Provides: bundled(libbacktrace) Provides: bundled(libffi) Provides: gcc(major) = %{gcc_major} +# The following comments `patches for all arch` are intended +# to collaborate with the openEuler MCP service to automatic sync +# from openEuler/gcc. +# patches for all arch Patch1: 0001-Version-Set-version-to-12.3.1.patch Patch2: 0002-RISCV-Backport-inline-subword-atomic-patches.patch Patch3: 0003-CONFIG-Regenerate-configure-file.patch @@ -466,6 +470,10 @@ Patch357: 0357-struct-reorg-disable-malloc-support-when-struct_layo.patch Patch358: 0358-struct-reorg-fix-residual-ssa_name-issue.patch Patch359: 0359-tracer-static-Fix-divide-by-zero-error.patch Patch360: 0360-Struct-reorg-Re-enable-malloc-support-below-ptr_comp.patch +Patch361: 0361-Enhancing-BOLT-Optimization-with-AI.patch +Patch362: 0362-Modify-cache-size-for-hip10a-and-hip10c.patch +Patch363: 0363-SVE-Add-std-find-with-sve.patch +Patch364: 0364-CFGO-Enable-flag_profile_partial_training-for-CFGO-b.patch # Part 1001-1999 %ifarch sw_64 @@ -1612,6 +1620,10 @@ not stable, so plugins must be rebuilt any time GCC is updated. %patch -P358 -p1 %patch -P359 -p1 %patch -P360 -p1 +%patch -P361 -p1 +%patch -P362 -p1 +%patch -P363 -p1 +%patch -P364 -p1 %ifarch sw_64 %patch -P1001 -p1 @@ -4239,6 +4251,10 @@ end %doc rpm.doc/changelogs/libcc1/ChangeLog* %changelog +* Mon Apr 28 2025 liyancheng <412998149@qq.com> - 12.3.1-78 +- Type: Sync +- DESC: Sync patches from openeuler/gcc. + * Wed Mar 19 2025 liyancheng <412998149@qq.com> - 12.3.1-77 - Type:Bugfix - DESC: Re-enable malloc support below ptr_compression -- Gitee