This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Linaro gcc mirror + linaro-local branches".

The branch, hsa has been updated via b38386c70287847060725d1c9c35dceb1f52049e (commit) via 8241864b2732daf530b85d2ed91582dbed65af72 (commit) via bdf88cd3e5a04e95d0dda5bd258e33475b257b51 (commit) via e8838fbf768aafd6384e3c547a5c83ff0b7c1c78 (commit) via 43acffb2e6bb9aa5d77cfea156e8bfd1e96a4837 (commit) via 1cc00a09a342deb39d96470785b11a2e6a9816c3 (commit) via 2e7845fd79051cf65a9e3544ae45b5d26a67f663 (commit) via 9d93412246c62dbc68190ccc1862fe570dec66b5 (commit) via 67842e8e4b62da09a0c97ce069bef5407fa4048c (commit) via bd10f27e42d5487ff37a83273aa94bf301bd66a5 (commit) via 40bdfbcc4d3ea167c61e835a71f7194c793c5314 (commit) via c8047e010e0bac287b0d00585a81fba4bead8659 (commit) via 3c537ec79cfcf161cf699fd32af9d872eed58886 (commit) via 668de2f7109d29355d24e77e6528545c23e182cb (commit) via 44121e9f4bf1c8bc5cfabb675c60c450d9f71d35 (commit) via 381fe25ad46aab4b037db3f93de9166a1e193f8a (commit) via 01872b8791fe8eefec76e613475d209ae72fc2d9 (commit) via 82cbe1be27852e78cc89a39555903833cd2292f4 (commit) via ffe67beb46890413231059464b7e6b412f49a5d2 (commit) via 4f0e25cabe7dddbb8b66880519ef5d1598d758eb (commit) via 9e9379bd2244eeeee7bd93c630827e34e11e44dc (commit) via 83c60000092ee9c5ab8dd8c3c7ecd6b3d0140c9b (commit) via a21bc0fdfe3e09b8379b1bc896f6732e0a6a9d2b (commit) via 80b8a97a9aad4c8d8a4e23cc3d5911a2f81e699d (commit) via b127ad66d1c53f6713f72a4978db0d1bfa411f4d (commit) via 9a56363e14dfb9c83b950c5d1f6fe04bf227624b (commit) via 8697277d3818237717b7b73cd2445804d7a93a1d (commit) via 282b12fe58b0ea2e8bc10c8309691b8bf74247b1 (commit) via e7966fe9160bb22110f35c47c2c143745604787b (commit) via 7832d94be769e42c34451b6f93f21868d74a6a8d (commit) via 1caa6ab13b481da391da0a26ee16335a68077378 (commit) via 535b528ef4fc7a38674432519ee4ed4379f073cd (commit) via e3c1971eb7660ea34d5585814c0a9bd0bddc5a00 (commit) via a29fd1b863db71413b000e51dc545e564c139b6d (commit) via 61453505645d677fcfb33f8c4269e5a6a933ee14 (commit) via a7081fa00f9e4089a0f9f336ad85a86deaf3717c (commit) via 5c3c2309eec982ca268a43fdd831e52160bdb0dc (commit) via e2c4a09ac84838edd25dfe60c95218f30d346a8e (commit) via 0446c24409c82d7399e9a9d00553d4d902ace22d (commit) via 05e51540227be0d9b820d013dafc0adb219fcbbf (commit) via 86d0644b457c60c20a034e85dee9a18d6069e0f5 (commit) via 451e3cfae492e7af316476314841853f9dd01177 (commit) via 4177c6958b02d95648295cd7951815b54a627ab5 (commit) via 32e17df0dc70dc48200952ff07b25cc4eff73f06 (commit) via a558802e49f849205c116da53dbcb34ec249615f (commit) via e9b064423e9d4e31514663bfef85baa49427993b (commit) via ec19b613ce9110877bc2893ce05fb23d18829437 (commit) via 71512c05194a9726afe1fd9c7d1afaf2025658e9 (commit) via 4db8dd0c57d0626ae40f14175d1fbd6dbe500bec (commit) via 1d375a798853792b1bf504f554c367ec0fbfc047 (commit) via 1d99ab0ae54d0adac2dcd1c1b2105dd09cac2d7e (commit) via a3c81e6142cd845d47a6df50a3b0da74d1df9f1b (commit) via 9a1bd12f5d9158fc1c4a83703f2a4cb5fd78513d (commit) via 31300ecb8bbec82c062c6f948d9b8da115ebdcf6 (commit) via 90b6ad4bb60cabee178b7e24312b359fc6f7510a (commit) via 874cca8bc8e9e04b57314781c9057924376dc91f (commit) via a5baeed086bcca781ab064dae948db9442fe57c3 (commit) via 7506bd97f1921d6b4f18a976557bfab7d529ec3b (commit) via d0e616ab460584ef1b6aeffdf17cdbcaf851291a (commit) via 48fc4cfe4eb9fc1545fb4c323a7e08a89046150d (commit) via 2a6eea59691ef6eefe631b5490f26c199d0e228b (commit) via 3cd8a8a5999f4d09967e9cdc5041ba624e1ad484 (commit) via 55a01181758c6670bff32f10885dbcf0832027d6 (commit) via 1e3173830911a0e22f17baea24d79643a5f533dc (commit) via c9137c819b1e15403179a514ce944650c1b9f595 (commit) via b58783c79c47f6cda88e7c4ee8e30eeb02921ea1 (commit) via 67f430416a5ea2dd2776e071651a72b694d5dc35 (commit) via e47b92fe2cb226c31952a0e541c829ded2caf31b (commit) via c122116264ad36ada8f09b9efe490af69d52bd16 (commit) via 89216e9ee91815faa118e2961419609cb30be83d (commit) via c915fa325ed9976fcfad02d46b898a0d01091b27 (commit) via 408ab4c9dbda20fb0fa0f6908210f69f03c29edf (commit) via 7c35064efa24e7372807e780b3d6c87916c4b5e0 (commit) via e507d748901ee31ec4afe7d45bbde47af2767d2a (commit) via a2f9b7c9c6d7658d7f2fa8ddb7f0f057946bb85d (commit) via 90194b2f2fecb8b9dc0e6c928509c6802bdbb37a (commit) via 6475b4618a63cbf3d773ac207877a26e8269ec0f (commit) via 1b86a644333b5255e1ed3786bf1ab86c095435e1 (commit) via 28e890547b6797b6216e0dfef616ab80a2b1921a (commit) via e1c33af9fd2ab64cee8e103ca39637e8f6e8724f (commit) via d9f6f79ee2b34d4dbdd280f1be2adfa798328565 (commit) via 4b8eb6ca093c25ad26dc10e5da9f54d61d1056ff (commit) via 880e4baa6b4beeaa504cd8dfadf50594e22b3d69 (commit) via 35267be7a9367176c88de597bd842ea94e695568 (commit) via fb1481e42bc15a45e8b0c68538d274e5f75fb03f (commit) via 968f733d8e3787fe1fcb1cfd3d0e44f1b9924c01 (commit) via 3d3b7ccd954a6d06c0ec95773c3d1b8bc10ae98a (commit) via b77049e845c1dd1d5d81c8f7301265bc32ed7b9f (commit) via e7f9a223d5858f6be027ca5c434ad908ca494e5c (commit) via 906a94039a0d9dc5c525d9be56c73b42d7a9e39c (commit) via 1e5e38587c894d8ea804934c1d65fdab4303edf0 (commit) via f0a719d1545daafb88a7a0a8f8705cea90cc7062 (commit) via 3528fbd582b0772ac711c1fea98f7ae5764f6894 (commit) via 959a496cc1029c6a80d1f3df83665abcbf86e2c6 (commit) via 1464518be776d99cf3d4dac4317ee9593d873407 (commit) via d69a4955403cbb9cf3332b8511be5c5629335843 (commit) via 42af43304cfcc1d4d91bc475bcc2c31a203ebfba (commit) via e71db74a3bbb8e0919e2766680fc951d936e9206 (commit) via 7acfc10f3e1f42ca1ff4c3525daed7a9aec47888 (commit) via 471788790907d4d1a3bcc0ba9b776a046d92e296 (commit) via fa769cc5dd37fa13481cf56650e843a80be94620 (commit) via 97e9c847f8ac4da66d5c9cc0454a962edabb2a70 (commit) via 42af8c2ad26601793b2e22e9592458feb92bd2e4 (commit) via 834409abb31543f669540be8f5a47f0d95969b5e (commit) via d277282f5a5dad072bfb4507ba6155dbe247328d (commit) via 577fe31bb1a37a8aa6bb8af393ae2c752a4636ea (commit) via 10a13d5e15345e1908f458b2514dba16f4da518e (commit) via 2cc308f8f19128d1ee12cc4ec4a6e79eedfac105 (commit) via 32e90dc6a0cda452b426b370326e315ac6f10f02 (commit) via fd425e6293fb8306af74b3048352d97e1d67b922 (commit) via f410e1f5b44007c6cf6609df0afc16e7dcfeabd2 (commit) via eb2d3e4a67c699257e42280e6bf800b8a92ffad7 (commit) via 1fa42b0566972abc668f3aa88e5534092af99c2c (commit) via bdccabb2604c4a2f714cea5846ad8526cd2eb496 (commit) via d64cb7f0cfa2c6eaaa675b7ec8b43dfe2001ca52 (commit) via ea105790f97a65717c706b9cb38af8577336b209 (commit) via 7394c9c2f5d535b482b94ca135668c1e9b28448f (commit) via d7297b92c1e556bff99be72a361eed65491249b8 (commit) via fd05d4972341f82c701cac78e54c98eacbc3b195 (commit) via d5b363112c501314c5f8aed62e523d98eea38a7b (commit) via 2f5c65337195218908bcc96fffa3cbd3c6b3330b (commit) via d65d306250d3aac9370e2e2084244d55903d3eb1 (commit) via d987e66324e188d6d1c65a6f5cdc36e5102f9920 (commit) via e667550e6920a87480dc00447702523a76cc4ae4 (commit) via 486bdb6ad9baff5ded41604b719de93d73a2e7ce (commit) via 9585883595217157c02cc0f10e500bbfcc72f31b (commit) via bd36070721826b9bc5c21a1e41ab26c6859647dd (commit) via 9e6be88a3d71728da9dcabfea3697f689d3dbd33 (commit) via 12dcc3b7405a43e28010b2f5c186bf6f5f809397 (commit) via 4171562ac9828de791442664d5bb432683ece771 (commit) via a18eed18f800d806b804b69aef2f6a783f21c795 (commit) via 03ca6f4ed72214cce1f0f01a43d12164ec723a4b (commit) via 11e0a6ff52af34193a365c613cab12df0a135ec8 (commit) via 1d5ad6812771997d16b69ab1c2acd71998e4b52d (commit) via bffbb74dac421042faeaae1bf1030b042f1d1ff3 (commit) via b4d2245978090f6d4f0459b04896d5b97c237821 (commit) via cf3a33c871e183d9bf07efb3015bf5583ef9f482 (commit) via a24ef8d231d1015c5a4ee68050ed78f5582342fe (commit) via 04feb56e6acd497d0add042232afd7940ef61adb (commit) via adb2df5592cdf8e70aa44c0f3c447da1d0134f4c (commit) via cc36aead6a4e5017477c9c0836672317128ed6b3 (commit) via 9bd7a189c372465fb757ecd67336379779f4ea60 (commit) via c2c2e50e3b6f2dc6800dd7eca4ddcb06c20383a3 (commit) via 06072e790e2325a0d373fb87f8012d647f31d743 (commit) via cf7341220ca3f8749ba81c06f41b23b198c56ac8 (commit) via 146896ec5334049e9aeb354dc0784e2c4a1ab371 (commit) via 1c26a2eecb5e772ca2639b2201d593c9a4afdd69 (commit) via 754e0869048f4c058982b3b75300fb0eb555b79d (commit) via 48bd2bec89d68195aec2cc3d1dc480b2192b8f69 (commit) via 6870ed496d3b0879a7d356e038c4e1953d72ee66 (commit) via 02b9d350b7613363884d6503754a062f9692cfc0 (commit) via 800478e66a7b89ba40414dd90a072c2987c054d5 (commit) via f01bcbfbccaf08c27dcf5063529491f0d921dbe0 (commit) via 376fa1e56967aee9e3376a75e9fb024338204ea0 (commit) via d3c64041b32b6962ad6b2d879231537a477631fb (commit) via 30b1ba428c325867d8314c21ce159e207b4b6d9f (commit) via 168a6cd2692428e03a4f4f45e24ca6ab380c2cbb (commit) via 36c2deebe0f663e0879fea4d4c87900cbdcd5778 (commit) via 23bab442d4ec6335f2cf6b88b49de91b047aff7c (commit) via 49005727b4e25248faf7d386c0a1ac18ff3114c1 (commit) via 97a82d408b146d0dad30e5c8a8bcfa6a8e6057e1 (commit) via 98b69bccadeae2fb64adde8ff008f79ec5963381 (commit) via d7a904bc5095619f4baa84acdf6d08ee67f693bf (commit) via 6a6d1669d43d5e568a9853733a02886dde2f7ade (commit) via 6f6c75e2c9c4abdd87d4c4b15c3ace2f74906966 (commit) via f6f5b85fe147b64f3b3d4cdc2d4a25dba353b223 (commit) via a84cae9031653443ed9861ed5af4bd4ffb773110 (commit) via 5d4f3ed8fef038c3a16e962831119564c8094cb0 (commit) via c539ca6d154190665f81482c5dc9cae5b861f636 (commit) via 5ac78bd34de721a28af3daf2550c48ba94d9c537 (commit) via b9d66f8d6f14445944c43c3e5410c5735f2d3b6a (commit) via b3f7a35351e062c422203e3c402a2b745ec24519 (commit) via fb96738dad371f6f1c006f649f9457203bb13085 (commit) via f8cec994b23cf83b1ced51137571e3bd62a71323 (commit) via 971f8266c94e387c1aae0d5d3703979d597ccd91 (commit) via 29a2cef8fc18e275a2d7f2b11b7b04113f05e770 (commit) via d9ba0dd6af146ac43f52cad4fcfaf4c56b2210cf (commit) via 0617d4e0de77a17d367b936035cc801e1f2c17f0 (commit) via 602bd329fa132b6caa9a9fc41f53cb30d62b316e (commit) via 6eb777bd8435d0687732603ca88eea9630a11e26 (commit) via 0949f227af296ee9e41793c80847f7b5fef937e6 (commit) via 23da1614d7ec9aa0620bb380f5387dc287ec5f06 (commit) via 43ec128c05f42e114924fcfa08e92153983f9873 (commit) via 830e7ac12645c9104fe81f00724726a4663afd6b (commit) via f7f6d6ee22a297b4169cb54d94f75ddcc86953b4 (commit) via 2b40f9baba4db2dd26a3bcb5e24dbb18d9fd97db (commit) via ec380e5f84c9ac875305e6fd9fcfca50dda2d0d1 (commit) via ef5e7d0d1d32a846712c42ac60fb9b226f2a3814 (commit) via bd79788195e59b579bfcc495ef042c6d2c65e264 (commit) via 6dd27d6d4a829c72ff8e70f922d00665835ab216 (commit) via be23b16fde27a3bc050e177abd965de0c4f2f04a (commit) via 6b4402853b6c8f5f6c3ea6ca0509ee5e3889d870 (commit) via 59f8b296e7b9b528e5a106bbd59d9c0d635be95a (commit) via 633f7124c9ab331782a1aa0d93cd4991b7766b7a (commit) via 6c4e00d816fe915ff71bef4eabd568070e48c92c (commit) via 5aed2291d3bc1f64bf35c4b063fee933ee2a7d17 (commit) via e5e7bb9a0ae4c360b361c7194ee6caf14d0722ef (commit) via 688586d582115b1c851208d6e048a69568ff68f3 (commit) via 1ec9e8bd2fd96c748f2a7f41e56c5b43c9e7e507 (commit) via d4cf9ac735ae4a87f98c650f9b4b24d581600429 (commit) via a5cb3e801bf03e345cc5ca46c91e61534c39fc0c (commit) via 762490218c1b7f16f7b79f133b0f49405eefae11 (commit) via f4ae4202283385f3739c095b13f0b74240cc3058 (commit) via 846375635e60fa5cbf8630763686de71a8fc039c (commit) via 5f21d2be012c2ad6f8d6575e429193f9d9b60707 (commit) via 27de91b1dde771fdc814ee409aa8bab37dc6feb7 (commit) via 6290f0dba92f487dc1c1e4da339edf419096c123 (commit) via 4eff8521e15042878285e2077afbb84c2b20e920 (commit) via f755666bb9b781a6fe122def37a9f237723de00f (commit) via ceab5d011aa89b8c1fc07315af6846bb42c410c8 (commit) via fbfe1b55fef922fb4c5f1acd1e9c9494e893fadd (commit) via 671608f2add4edfe9ed1b2b001a7a1041210f346 (commit) via 141d9a97f446ba3b634bad0c44d5ee1b721423e1 (commit) via aa3e402e1d13e754e43aff87ee05a393af16c580 (commit) via 96177d13e19487b232627b13e337b1a23ead622b (commit) via 0cf907e5e32f0d3dcc53de3e08af34af6b98e40e (commit) via 3ba9ebd11c0c3feeca27d2990960b03819a70af4 (commit) via 4d2c64202e7b6f958a7cd829118e883d28c7e26b (commit) via 65f988f7a1eb0beb3d02e90034b0bf8b48e02d11 (commit) via 14677da9ae68b3f517bf1225340d4f39429f37e1 (commit) via 5e9fcc706c2df9b91b8e8a3188a8f6dc0dcf89bc (commit) via 12dfa5b6083e7965adb156fe9ddbdac289b8e4e2 (commit) via 4175480310bb6a77afe50d681a2ff10470ae5e84 (commit) via 4dcba1dc7b68bc67fffe28a5e974eea02a6b3bd2 (commit) via 7cf4130d6ede1658935066522bfb4a3fb232907e (commit) via 69693ea7b7ed45a12cbd505b2a66257fd4e81669 (commit) via 0094ca3ae265da1e51dcd60bc465f50833567586 (commit) via d955aa4f3e71d9e91a22f94760ee416e051c9d06 (commit) via 0c6fd2e5aff4705feade1433b586753beef233b2 (commit) via 7a0ae4afd303140420c053145e5b2ce63c035724 (commit) via 001eae4fdfd6047b1ec3d506afd225e648df0a7c (commit) via 16d83c02b51c0e5f9f43d28477013f44afda81d0 (commit) via faf67f0c4508f805dbda667f2f984485d1625702 (commit) via b141a4bcc9ac87f465d5bffb1b393c182ec8bbe5 (commit) via b5fbf2dc2a3211c36efc6b595874f64429f856b2 (commit) via 4e81b3844cd6cce0b73a7be8b50f6dd124e61f08 (commit) via f215226bd6f034190a61c6c601b9109ce6644977 (commit) via e4288bad18d39a108ac1bb57b5b8ccbbf9e31e53 (commit) via 387f98728aa5d5d60def6d48d286356ef693e40f (commit) via ed5fff77de3c47a483d4266954828dd7511e148d (commit) via 85da1e829454a390be5aa1190e2aa19c24d4b233 (commit) via f3e197643e7405a0237c5c606fc09565ca9be832 (commit) via d34b1105d2d6c15004f2b46c4ec77252e7a85cb7 (commit) via ec2e0095a3a5988b03a2706b5ffe0e807b238ba8 (commit) via 23d1032f15175e34834efb86c9c87b4241424a96 (commit) via 0c71fb4f75c6a1422ac14db9a9bd769c14096280 (commit) via 5da5e2838d2b06cb910bbd6832be4ac3d5e8dd65 (commit) via 4b498588196a9170c9b8c9356d6825807e096228 (commit) via ee34b0e4d43c0cbfd3d30247d1e349ccd99df01f (commit) via e031629a89911d8048d2f6fbc7a8878d763bb39e (commit) via d5fb61356f9ecdaf8d7e23fd4cef50a793ef059f (commit) via 091deb37761b46205932413776447534ff417629 (commit) via 613732c1f5aaa8941c1e45b762a89aaaf10d36e1 (commit) via 8a6732650cc541a7fca21987667343da4d244e72 (commit) via cbfc4bfa9965a87780a24f47a72e9849180ab043 (commit) via 22fd03a551df35a59ba22f3f68464a7b25379c32 (commit) via ad7173b950b018232beaea51a9c31be0a2555f37 (commit) via 3c17973d9e981a2c51be073ca3ccd13c25048bde (commit) via f4ff098af3cb440cf2d584ad0a74d01afbd98f8b (commit) via b837d1923826a45554502cbcb7f4b9ed56673da0 (commit) via 3445be6e4a937f7ec19e5107beb87c59bf9727b0 (commit) via f581cceb3653a3f3c24f7fc83c9419b331a21f85 (commit) via cede6403d0fc4ebd0a416d7e74b1ee0a9b6d2010 (commit) via ac549b40f2fd7aaf7aa4557f2fdf0f602db6151e (commit) via 576d4555940264b594088f94d3c4b78d1f72bbb8 (commit) via eae1ecb4918474af2840cd4b8b5657eb4fe46df7 (commit) via b594087e1afe41db9d100f08644715702d6cfc1b (commit) via 298e7f9ad0f29a52d5ec5034a95dbb1a25e51dea (commit) via 770ff93bf67f88fe2bba4ff6258b0bb5b674be22 (commit) via fd0399c10a0e44871b57b69acb7eb2021f63f932 (commit) via dd106147059b09755b74e6df75fa7ff4c020a1c2 (commit) via 9937801191a8686d18a79c105b3c3b419c51f174 (commit) via 142dd62a9ecab4559e6d7b0be471b9dbbebe8956 (commit) via 54cef8b2c6aca00172697b4fd5b9b6a2e4565d01 (commit) via a3c76fda3034a5890bdb8dd753e6ebbb2b69eaeb (commit) via 20e6ed7b2406f3cbad7db3baabd9afb88334675e (commit) via f48c7f4a6a9a70f95dab2da3bcd5544eb513b4cf (commit) via 577041e3f5772d7793caff2b7aa93ebc05b89325 (commit) via ce41e81a59b1687879492dd8039c720f17204130 (commit) via deb7cbe52b2c4e2e77854648ac62e5621d774f00 (commit) via 596d942b73a55b02107de9872d50ac417c1f1326 (commit) via 4c8f3f72f374bdbc1f668d9a81c9b6856dd7d202 (commit) via 25626f45d4dc0b3ae4f09e47a05a4835559d1257 (commit) via b13fec6aea5fd7619826a52045dfc941d542b615 (commit) via b0655ed9e6e0a529debe49c2fc15f3457f7fcfa2 (commit) via 955b6519fccf69179a385055a50f4a2b0fcfd3e6 (commit) via cc16f5e2efeddcfaafe30d7f43daf920708a0114 (commit) via 5b11c9b9071c416628f26b25abfe59fe6b34d5c4 (commit) via 5b5f6cc30bd57724c96c3bbbbb0d472712ab2fea (commit) via a27e538c109959fc60eb679493932bb64769ed00 (commit) via b9ea6dbbecce6a4c7772efee97d9241858ff1f8d (commit) via 964f793c121e2d2bc68a29fcc1def75180f669b4 (commit) via 5ef5d6bbdb6028b6724c8878119c7e16a24e0ab8 (commit) via a1c392b51038f5a1206a73577a80060d8e7b0bab (commit) via ffff0e9578ae4eadc569ecffaa212e72377fda34 (commit) via fa4f365b8559743b59ae52801d74b7dbd4da4fce (commit) via 14a6e10c3985adc02f126b1ce5a2f52906e52349 (commit) via 33cb48f09f1eef3eca649caf463017ee0833f3e5 (commit) via b37104f6577fab9f423b408adb2697e1982f3e4e (commit) via d49d9e38a49d8ecc580cc6c0cb24a571d5786cf7 (commit) via 374fac5db1e3c3a2622705ae097f8685af34d1a4 (commit) via 1f6b3916b7a2d5a5a1ef52f745815b3ffcf11baf (commit) via 12b9e102c31e61c07166f78a6b448b989191ddf2 (commit) via 09dc5bfc84a33430b7011920856ab60e1b44a559 (commit) via e0abc01acaab4f3c32d2520e75364df4803f6aba (commit) via 87eb018353c4ea3db4992cf3c325e08a70a2d7df (commit) via 207695d55ce9c75bc5ea1582a087f508039656b8 (commit) via 425ae6f18d229abada00788b079a75d913d2fa2a (commit) via 53e2e97ebf7b576cc1948123ab45133ddbee6a54 (commit) via c961aa181a74fc4c3c839940f76c1e5141d426c8 (commit) via c35df805322e6a8b34e5aa0a0706e4b51a4b0f46 (commit) via c1eaf614446b243a382b3decd9437b6328a5f9fb (commit) via 156dba859d6d9c279f1c4cd10fe030e4fdf2e31d (commit) via 98e960a5157ecc5ef2d8b4e138a6657d4f458814 (commit) via 9e034d188726e3ebdb754ad0b99b4ed8ef8f3a45 (commit) via 8aaac84f5fc2626b3ba462feb5f2f2f46e54ab19 (commit) via a8aefbef590f00d9335f3ee40610fd94f3df75c3 (commit) via 6c39f921e7fd65e7fa8858e10e156f9d7a71b847 (commit) via a1142483ea07e69c8a522b4e8ec2689f28fa526c (commit) via 6bb09dc930e5aec3ab3b01c5bce7455c4e70674b (commit) via abf3beedf4e8aeb33c72851339aa0388178396aa (commit) via 6b7cfb9c850f777a90c9a85a1ffc304658410d29 (commit) via 431da5f0e26e328c59411469cb90f428a76f4292 (commit) via 25538e3ce5981a4fef4ae5dff10e6855daecb106 (commit) via 4a48c27700a4c4876a2cc6f2e5bd52d0f5bb2d9f (commit) via e49bc3d4c8712dc98e3f73d4098d84ae463e1c4e (commit) via f591a95d1532ac7791c146a8e55ba3a32b3e476f (commit) via a1d0f6e13c20b5180246ae2e8649676099cee370 (commit) via de231ec29421ac250e9592b99987f0d39e708bdd (commit) via 85f988d00b85b2b428d7f92336fee9e0045efc12 (commit) via 58ddcdad095a1ebd98cfe8d520e4acab71a006ab (commit) via 0200602eaac600a7b9218dec1d2908396268b705 (commit) via 1d7a23a1e7eafc85861d451bbafff9aea8f6cf64 (commit) via bd19243af856af0bb2a6737eada863ab2dc1e30c (commit) via 42fcf9ee5d40de268a295ac638f3d906cf02b562 (commit) via 23d64a17f5ae088c8b6e04f5db94f6cacc0492d2 (commit) via 435172d141d9080a7944f18d971badf4363a2636 (commit) via c1c0e9ee89f7776ec8fddc692efa7453430d291e (commit) via 75e094310303a8ba0c32994c5568210955c4463e (commit) via 88323eef3b70c34b43b15781c00a3964c1cd7fbd (commit) via 5bc2f83c1e43f88e824ec34c4c2f8d0cf836fcab (commit) via 505aa56acd1ed5326f880576c766a0841bb20831 (commit) via 0e8e2501bdd9e25c9d95013f7300b6faa9a1e3d6 (commit) via 5941b5d3779b892d267dabce135ba3949c2f1193 (commit) via 06af5c8030b959ca099304bb3864f426c86625fc (commit) via 5b988b24f5e557e19242d50179aa4e3e0c3752d9 (commit) via 68621ee7d126fe090271bfa33bfce9f68247042e (commit) via 325ea54a05baf4e83011f1152adfb60bdd22181c (commit) via 0f6714c2c2bcacfc25d5e720d75d099f5ffd2473 (commit) via 1ec7c7d277c3f7d92c8956b6051effb9ff064488 (commit) via ed13ef4d5cfa27a6f00fdf8954eb66d31d80c7aa (commit) via 53a7bd71ddaa01f1a04cc74bfe5b8d2f975a5711 (commit) via 99838ed7075b729130895888cd20a421ea4227ca (commit) via 41e117358ed4bb389ce63c2fa769b77c67513944 (commit) via 0f93641f41997fd9440eb22c3392a10ded9db6c7 (commit) via 40b80fad41bf57c0b99a898f91a94e13e797ade5 (commit) via 38457529e47452f4f020ae4089b87d9821eeb073 (commit) via 7f2289e8bd05a4e886a328197652e9c171e42899 (commit) via 11dd476c09277840ec9883692eb4a83136db3c19 (commit) via a082866db76d04db4e9dd2d6af45a2f9c20d1fa9 (commit) via 0744fd81c16fac8123936b120a196f04db67bbdc (commit) via ddda48dcf288834963d5bd073a293835e7937643 (commit) via 496d3abc0026005d64334389f23f3e80071f083d (commit) via ce3ddd15d55dd68999fa4055f191712cedc8cfac (commit) via 3cc0c1c5322271672ee3c4b7a8176ab9074bb991 (commit) via 800f9fe93bd16c0ae28b7ebb2efd72ddf46302e3 (commit) via 0879c97940ebf1ae0996508221adf88ffe03f44a (commit) via 1ac3baa24235864928e30e04e325e23af1155945 (commit) via 3a55998e603c80a4df23e9caf3d4281fa1bb31a1 (commit) via 7a6462cae8da25dd49e07039b5d6648f8b4cbcf7 (commit) via 2a9a34447dc69b93289f5f7fb2dc6dffcfee9d2a (commit) via 5c826a3c930ca48e720623224fda42edf1f7e615 (commit) via 967c34893fc434603323856fd65ac88c0d375900 (commit) via 3dafd1b4f71f754473b98a3d081fe99258189493 (commit) via 7097da817729818fd8e3bf4c95ab3cb3b0828448 (commit) via a4f5959666ea4d2a88c118611d854669b4df4510 (commit) via 7e1e440b41e74fba188b101284b7d95012e38930 (commit) via 6fe5dc7719723d68d241c57e62193d8ea8fde4fb (commit) via d21bbc3fddc29c0303efca183be36b4d1f022c8e (commit) via a4712db540f6baa031a472da04323b5c8717fc2f (commit) via 1774df35222fb21e5b38e5ed7b1083310070c25b (commit) via 286710f66cd28105c0ed9bf85f518980ae119bb3 (commit) via 4905002bb29e81f67c5f4f20dfc1dc399015199b (commit) via 8fb94dd34f325201b329936c4469718f2ee808ae (commit) via d2654d7fe7bf2ea0c30a2c3302aac25a7008b450 (commit) via 7c3e9fea3390049600db0700b1e1d557ae01c1b2 (commit) via 6381d49fc706b3f7f2b2972a70edc3491bc3939b (commit) via a6b9f513eee5543f78ab4356e70dd95be1c2a78e (commit) via dc70c7707542425e4a4fa651fc6477c301eba472 (commit) via e4c462624d828e47988ee555b690178defa1e840 (commit) via f6663122b11f9c700ca08e7678c7c4d77da23dbb (commit) via 0bf0c7922570f90172ab21c8fa7782bff9e2fe60 (commit) via 5b3090e1bd010a8ee940784fef78219d38e70f71 (commit) via 864f2df48e2a301041e8aa0bc24b518618db407d (commit) via 301703e769ea24ba9a035d85b3e546b988f96bc5 (commit) via fff0639d11d19abdddde269a02a89d24914f098f (commit) via b93d7bbdffe25c8d5f27bde3cffbbb09c94904d2 (commit) via 7241256e55f9c2e10d1cacaf1cd9b019598c101d (commit) via 57ba130aca0f56ed6eafb46f6c1256985bca3f1a (commit) via 8109ba1da3606a97733d3e1f47ff5b306f124e6f (commit) via 1788ccc2ea191fd7d570dc7854f31f20230967a2 (commit) via 5c63a176f39f2fd789345c2fc59f5f8e39352902 (commit) via c81571725914852e514ccdd4ef33062dcb02a36f (commit) via 68330f0f18e9ec9a767d74e49db5ad6a4a04afce (commit) via 658273889b8ab77b333bb859085aa9a71a3c1ca1 (commit) via 6487b64671c7e24b748a73af9895c88cfad6cdbb (commit) via e49b6cbdfe159b04d1758db72b1a310c38e6d3cc (commit) via 83c45efdb70d37c2f8fe45cbf0245c108a2b1995 (commit) via 934a3b04e91680e060426809076d166223aba32e (commit) via 97ba860ef32969a1054716baf7f3966843c8b58a (commit) via 947782de183e517a10eec36e3d32f9e38f44f9cb (commit) via ae11e7e60bcc52c3eee762be09e1e94cf08bdf9c (commit) via 76626a24a21f07fe584618e380d46a347a174dcd (commit) via d0163b3ed22f3db027ab6ccf034a2b23362fb124 (commit) via f1c53664adf013f2ad2105fe28a40e871a4f136c (commit) via 5258a4c42424782490a21b57af12f6f1dab815d2 (commit) via 9d0137f201b80bb68c76f5421918ccf6a4ccafc3 (commit) via 06707d2bc06745ef47b3158b4a99ae8d8ae5bb9c (commit) via ed20400de1faaf9f4ebdd7f6c518b93814af54cb (commit) via 3625ad60ab1ad783f4afead68f44b19011e4780d (commit) via c130d11c707853c1065f765698bb6dd93706bb83 (commit) via d8e3664683835187dcb92809af58ac0e86322f67 (commit) via 056c318d00d4bc0447a4e141e1cb72c6f48053a0 (commit) via 7e4d369970834d4c4f9e1c9ea910a1fd739187e7 (commit) via c766f7b98fa1101ab1d3ecd2b33c4afe7ef5fadd (commit) via e3a904dbdc78cb45b98e8b109e0e49e759315b7c (commit) via 7f67d68c56e531d17a1d9150fac23671c052c02e (commit) via c01ee3258d0a8a4aa66f32834c5d339cf03e5790 (commit) via af2fe3f5c1e95931cf76dd8e633c9fa12c07925a (commit) via 33436616bbad6a323087cb94614e822b985f630e (commit) via 3cc70dc3acdf9e2672464c53f6c75bb84bdedb9c (commit) via 2e6c9e14a688c97e8277306166c069a0137ee992 (commit) via 391cf42b668f79f2c0dc58fb9314a179048f580b (commit) via fc0fe623c9ea9dbf572d940113b7823f97d9f0d0 (commit) via c1bee668987f371617586edafa0dfccf04162a83 (commit) via 6e98053e6984aca2ff1fb00730cc30b5acb7c658 (commit) via aa320f15fab7a4e14f3626ef64a811a1b1468443 (commit) via 81dbec5bfb4754603e295e39a767550302c1053c (commit) via 41129c36f0b331121039451621518ab9a9ef1347 (commit) via 2049d5c4fc064b1050b11ca055adac40e157cd42 (commit) via ce1cd3ac5a239347c98f99e62dff02a89cc96434 (commit) via 73bde8df3ea8ffb25faeaf47ecd706120df0a755 (commit) via 613f2c3822a13586579cfb6009eac2a6d0e7e4b4 (commit) via 9dc78f564aacef4553e77f8c5020ac6a23b85995 (commit) via 9918db4464b0b328d14819541fbc3bf855c6ade1 (commit) via 4a875e1f1d7dca1f03cc71a8234862aaf03e5d18 (commit) via debb6aabb771ed02cb7256a7719555e5fbd7d3f7 (commit) via 6689f47f53079d76bbb051d3b5da9018c2e0161a (commit) via 29e65f8eb22a557b8d6cf926c260a1e2a17bf1e4 (commit) via 527467c8c6925b2c58b82a3b4ea47aa94597e276 (commit) via f2ab3baca4933fb9e7d34a1859ae11384c3d81dc (commit) via 206f4b33a1da89c4eb1c7140a70e68466a8f8530 (commit) via f3c08b92531f2e6a4c8d769fb1096a84cca8de16 (commit) via b8b0c0292cbcf68702895298c38e1181418a3a50 (commit) via 7536ddaed3aa96eeda6c0bb0d5f493b05c0540e0 (commit) via 8789248fb7a9ed50140d0a92061e77e9b3aac82a (commit) via 488d0b0bd680aa8e0b59e6e4deeeabebb59c61be (commit) via ab2a707c83582b85a20079b53f1c8bc19942f5d1 (commit) via a3f6aaeccd02e08ab8871f212d0edce4363b5e0d (commit) via c608a51e8adfc16ba254c73e131db2082bb97d99 (commit) via 36272377179f72fa3c40234ee9f92093d6078a9c (commit) via 3052eeefc4607a7147fdc55af6d86845890eb281 (commit) via 1828cd755cf5e4a34d5638f543a059f3562ad957 (commit) via f02f5df097a93c29ff2bc416742830644744bc2f (commit) via 8b54dd2e6bc8b8eac24d4dd6615574d7d1b21e16 (commit) via 8154a3514d5fc8067a6928531d5f61cd768bd62c (commit) via 5e190f2ea6a835d97260b87d6b5c3f38f6ff5f10 (commit) via 8e3baf54dbaba3db6f98e14a07c0792c6439cbaa (commit) via ba3815c640f73408f1084f4739ecfce7e93795c7 (commit) via 6c197bf1ddfaea3872fe73d9007d7cc69f9d4cb4 (commit) via 510e444f7bb40f9dca0f77235da6d06b568976d9 (commit) via 7e13b71a502c9cf3e5f3050b32030a376820fe9f (commit) via 3d1c3406c5da06567e4ecdc5b2a35c2be93660ba (commit) via 090547bda193f5f813093754e5c70562f1877c19 (commit) via f34a836c57573eaceecd4602beb73b370d55c2a8 (commit) via f0592840091cfeb63c2927db06c3043147733dca (commit) via 8ee959f85371dff5d802ff4408539e678fd59663 (commit) via 8cfa2461f61e0e5fb822feaf70e5e900053517d9 (commit) via b5e36aca384424d1fcfdaa989db3dc93deed58f8 (commit) via 390fe7eba5c14318ab7b603392a4c0adab37436e (commit) via cf8ffb1d1a9f817b885625e0271f4a3c695c6e7d (commit) via efbe56faf916c254ca469374241fe2f8871f9b8c (commit) via 8f9a2cd7642ac72713d6bb83198e08bb3c382584 (commit) via 6e3ecd30740d9f0203bb2f368ebdde03c6a85317 (commit) via d94396a5fafa53769265592d5a102889402fa8a3 (commit) via dfafbb4010eba28b006e3c4d61496866fa412999 (commit) via 8dfcd09741e92575a9f0cf0f13917c0ee8ba1519 (commit) via ef59e3deb318e0f6648f20aed043ecaec118498e (commit) via e9f7d2bfceb0af3564d1041cff6ade424274434c (commit) via 081f3e64facc36f48b328ee2994eb27ff1713ce6 (commit) via 4312e4f4d68361692cc7d7bf1375512e6ee7a44b (commit) via f39b15c6763ca9e7165f53ad9e1ffd45c1e10c3f (commit) via 545ffec9b641439af8d9a811f00ba68f7eb14b8c (commit) via 452213131180158c3d084853766703d8988d7714 (commit) via fe5ea207f3b40671a5ef960a27fd4d23fae1f05b (commit) via 1ac7f5a63e33c5fb69b02594f54c2e70258c0019 (commit) from ec3c539e95c6c8f38f57fa57959243c258a088ef (commit)

Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below.

- Log ----------------------------------------------------------------- commit b38386c70287847060725d1c9c35dceb1f52049e Merge: ec3c539 8241864 Author: jamborm jamborm@138bc75d-0d04-0410-961f-82ee72b054a4 Date: Wed Jul 8 11:39:26 2015 +0000

Merged trunk revision 225504 into the hsa branch.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/hsa@225544 138bc75d-0d04-0410-961f-82ee72b054a4

diff --cc gcc/hsa-brig.c index fcef710,0000000..2aac30a mode 100644,000000..100644 --- a/gcc/hsa-brig.c +++ b/gcc/hsa-brig.c @@@ -1,1893 -1,0 +1,1891 @@@ +/* Producing binary form of HSA BRIG from our internal representation. + Copyright (C) 2013 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 +http://www.gnu.org/licenses/. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "defaults.h" +#include "hard-reg-set.h" +#include "hash-set.h" +#include "is-a.h" +#include "vec.h" +#include "symtab.h" +#include "input.h" +#include "alias.h" +#include "double-int.h" +#include "inchash.h" +#include "tree.h" +#include "tree-iterator.h" +#include "machmode.h" +#include "stor-layout.h" +#include "tree-cfg.h" +#include "tree-ssa-alias.h" +#include "machmode.h" +#include "output.h" +#include "gimple-expr.h" +#include "dominance.h" +#include "cfg.h" +#include "function.h" +#include "predict.h" +#include "basic-block.h" +#include "fold-const.h" +#include "gimple.h" +#include "stringpool.h" +#include "gimple-pretty-print.h" +#include "diagnostic-core.h" +#include "hash-map.h" +#include "ipa-ref.h" +#include "lto-streamer.h" +#include "cgraph.h" +#include "real.h" +#include "hsa.h" + +#define BRIG_ELF_SECTION_NAME ".brig" +#define BRIG_LABEL_STRING "hsa_brig" +#define BRIG_SECTION_DATA_NAME "hsa_data" +#define BRIG_SECTION_CODE_NAME "hsa_code" +#define BRIG_SECTION_OPERAND_NAME "hsa_operand" + +#define BRIG_CHUNK_MAX_SIZE (64 * 1024) + +/* FIXME: The code below uses endian.h routines to convert numbers to + little-endian. I suspect this only works on glibc platforms, so we might + need an alternative solution later. */ + +/* Chunks of BRIG binary data. */ + +struct hsa_brig_data_chunk +{ + /* Size of the data already stored into a chunk. */ + unsigned size; + + /* Pointer to the data. */ + char *data; +}; + +/* Structure representing a BRIG section, holding and writing its data. */ + +class hsa_brig_section +{ +public: + /* Section name that will be output to the BRIG. */ + const char *section_name; + /* Size in bytes of all data stored in the section. */ + unsigned total_size; + /* The size of the header of the section including padding. */ + unsigned header_byte_count; + /* The size of the header of the section without any padding. */ + unsigned header_byte_delta; + + /* Buffers of binary data, each containing BRIG_CHUNK_MAX_SIZE bytes. */ + vec <struct hsa_brig_data_chunk> chunks; + + /* More convenient access to the last chunk from the vector above. */ + struct hsa_brig_data_chunk *cur_chunk; + + void allocate_new_chunk (); + void init (const char *name); + void release (); + void output (); + unsigned add (const void *data, unsigned len); + void round_size_up (int factor); + void *get_ptr_by_offset (unsigned int offset); +}; + +static struct hsa_brig_section brig_data, brig_code, brig_operand; +static uint32_t brig_insn_count; +static bool brig_initialized = false; + +/* Mapping between emitted HSA functions and their offset in code segment. */ +static hash_map<tree, BrigCodeOffset32_t> *function_offsets; + +struct function_linkage_pair +{ + function_linkage_pair (tree decl, unsigned int off): + function_decl (decl), offset (off) {} + + /* Declaration of called function. */ + tree function_decl; + + /* Offset in operand section. */ + unsigned int offset; +}; + +/* Add a new chunk, allocate data for it and initialize it. */ + +void +hsa_brig_section::allocate_new_chunk () +{ + struct hsa_brig_data_chunk new_chunk; + + new_chunk.data = XCNEWVEC (char, BRIG_CHUNK_MAX_SIZE); + new_chunk.size = 0; + cur_chunk = chunks.safe_push (new_chunk); +} + +/* Initialize the brig section. */ + +void +hsa_brig_section::init (const char *name) +{ + section_name = name; + /* While the following computation is basically wrong, because the intent + certainly wasn't to have the first character of name and padding, which + are a part of sizeof (BrigSectionHeader), included in the first addend, + this is what the disassembler expects. */ + total_size = sizeof (BrigSectionHeader) + strlen(section_name); + chunks.create (1); + allocate_new_chunk (); + header_byte_delta = total_size; + round_size_up (4); + header_byte_count = total_size; +} + +/* Free all data in the section. */ + +void +hsa_brig_section::release () +{ + for (unsigned i = 0; i < chunks.length (); i++) + free (chunks[i].data); + chunks.release (); + cur_chunk = NULL; +} + +/* Write the section to the output file to a section with the name given at + initialization. Switches the output section and does not restore it. */ + +void +hsa_brig_section::output () +{ + struct BrigSectionHeader section_header; + char padding[8]; + + section_header.byteCount = htole64 (total_size); + section_header.headerByteCount = htole32 (header_byte_count); + section_header.nameLength = htole32 (strlen(section_name)); + assemble_string ((const char*) &section_header, 16); + assemble_string (section_name, (section_header.nameLength)); + memset (&padding, 0, sizeof (padding)); + /* This is also a consequence of the wrong header size computation described + in a comment in hsa_brig_section::init. */ + assemble_string (padding, 8); + for (unsigned i = 0; i < chunks.length (); i++) + assemble_string (chunks[i].data, chunks[i].size); +} + +/* Add to the stream LEN bytes of opaque binary DATA. Return the offset at + which it was stored. */ + +unsigned +hsa_brig_section::add (const void *data, unsigned len) +{ + unsigned offset = total_size; + + gcc_assert (len <= BRIG_CHUNK_MAX_SIZE); + if (cur_chunk->size > (BRIG_CHUNK_MAX_SIZE - len)) + allocate_new_chunk (); + + memcpy (cur_chunk->data + cur_chunk->size, data, len); + cur_chunk->size += len; + total_size += len; + + return offset; +} + +/* Add padding to section so that its size is divisible by FACTOR. */ + +void +hsa_brig_section::round_size_up (int factor) +{ + unsigned padding, res = total_size % factor; + + if (res == 0) + return; + + padding = factor - res; + total_size += padding; + if (cur_chunk->size > (BRIG_CHUNK_MAX_SIZE - padding)) + { + padding -= BRIG_CHUNK_MAX_SIZE - cur_chunk->size; + cur_chunk->size = BRIG_CHUNK_MAX_SIZE; + allocate_new_chunk (); + } + + cur_chunk->size += padding; +} + +/* Return pointer to data by global OFFSET in the section. */ + +void* +hsa_brig_section::get_ptr_by_offset (unsigned int offset) +{ + gcc_assert (offset < total_size); + + offset -= header_byte_delta; + unsigned int i; + + for (i = 0; offset >= chunks[i].size; i++) + offset -= chunks[i].size; + + return chunks[i].data + offset; +} + +/* BRIG string data hashing. */ + +struct brig_string_slot +{ + const char *s; + char prefix; + int len; + uint32_t offset; +}; + +/* Hash table helpers. */ + - struct brig_string_slot_hasher ++struct brig_string_slot_hasher : pointer_hash <brig_string_slot> +{ - typedef brig_string_slot *value_type; - typedef brig_string_slot *compare_type; + static inline hashval_t hash (const value_type); + static inline bool equal (const value_type, const compare_type); + static inline void remove (value_type); +}; + +/* Returns a hash code for DS. Adapted from libiberty's htab_hash_string + to support strings that may not end in '\0'. */ + +inline hashval_t +brig_string_slot_hasher::hash (const value_type ds) +{ + hashval_t r = ds->len; + int i; + + for (i = 0; i < ds->len; i++) + r = r * 67 + (unsigned)ds->s[i] - 113; + r = r * 67 + (unsigned)ds->prefix - 113; + return r; +} + +/* Returns nonzero if DS1 and DS2 are equal. */ + +inline bool +brig_string_slot_hasher::equal (const value_type ds1, const compare_type ds2) +{ + if (ds1->len == ds2->len) + return ds1->prefix == ds2->prefix && memcmp (ds1->s, ds2->s, ds1->len) == 0; + + return 0; +} + +/* Deallocate memory for DS upon its removal. */ + +inline void +brig_string_slot_hasher::remove (value_type ds) +{ + free (const_cast<char*> (ds->s)); + free (ds); +} + +/* Hash for strings we output in order not to duplicate them needlessly. */ + +static hash_table<brig_string_slot_hasher> *brig_string_htab; + +/* Emit a null terminated string STR to the data section and return its + offset in it. If PREFIX is non-zero, output it just before STR too. */ + +static unsigned +brig_emit_string (const char *str, char prefix = 0) +{ + unsigned slen = strlen (str); + unsigned offset, len = slen + (prefix ? 1 : 0); + uint32_t hdr_len = htole32 (len); + brig_string_slot s_slot; + brig_string_slot **slot; + char *str2; + + /* XXX Sanitize the names without all the strdup. */ + str2 = xstrdup (str); + hsa_sanitize_name (str2); + s_slot.s = str2; + s_slot.len = slen; + s_slot.prefix = prefix; + s_slot.offset = 0; + + slot = brig_string_htab->find_slot (&s_slot, INSERT); + if (*slot == NULL) + { + brig_string_slot *new_slot = XCNEW (brig_string_slot); + + /* In theory we should fill in BrigData but that would mean copying + the string to a buffer for no reason, so we just emulate it. */ + offset = brig_data.add (&hdr_len, sizeof (hdr_len)); + if (prefix) + brig_data.add (&prefix, 1); + + brig_data.add (str2, slen); + brig_data.round_size_up (4); + + /* XXX could use the string we just copied into brig_string->cur_chunk */ + new_slot->s = str2; + new_slot->len = slen; + new_slot->prefix = prefix; + new_slot->offset = offset; + *slot = new_slot; + } + else + { + offset = (*slot)->offset; + free (str2); + } + + return offset; +} + +/* Linked list of queued operands. */ + +static struct operand_queue +{ + /* First from the chain of queued operands. */ + hsa_op_base *first_op, *last_op; + + /* The offset at which the next operand will be enqueued. */ + unsigned projected_size; + +} op_queue; + +/* Unless already initialized, initialize infrastructure to produce BRIG. */ + +static void +brig_init (void) +{ + brig_insn_count = 0; + + if (brig_initialized) + return; + + brig_string_htab = new hash_table<brig_string_slot_hasher> (37); + brig_data.init (BRIG_SECTION_DATA_NAME); + brig_code.init (BRIG_SECTION_CODE_NAME); + brig_operand.init (BRIG_SECTION_OPERAND_NAME); + brig_initialized = true; + + struct BrigDirectiveModule moddir; + memset (&moddir, 0, sizeof (moddir)); + moddir.base.byteCount = htole16 (sizeof (moddir)); + + char *modname; + if (main_input_filename && *main_input_filename != '\0') + { + const char *part = strrchr (main_input_filename, '/'); + if (!part) + part = main_input_filename; + else + part++; + asprintf (&modname, "&%s", part); + char* extension = strchr (modname, '.'); + if (extension) + *extension = '\0'; + moddir.name = brig_emit_string (modname); + free (modname); + } + else + moddir.name = brig_emit_string ("unnamed_brig_module", '&'); + moddir.base.kind = htole16 (BRIG_KIND_DIRECTIVE_MODULE); + moddir.hsailMajor = htole32 (BRIG_VERSION_HSAIL_MAJOR) ; + moddir.hsailMinor = htole32 (BRIG_VERSION_HSAIL_MINOR); + moddir.profile = hsa_full_profile_p () ? BRIG_PROFILE_FULL: BRIG_PROFILE_BASE; + if (hsa_machine_large_p ()) + moddir.machineModel = BRIG_MACHINE_LARGE; + else + moddir.machineModel = BRIG_MACHINE_SMALL; + moddir.defaultFloatRound = BRIG_ROUND_FLOAT_DEFAULT; + brig_code.add (&moddir, sizeof (moddir)); +} + +/* Free all BRIG data. */ + +static void +brig_release_data (void) +{ + delete brig_string_htab; + brig_data.release (); + brig_code.release (); + brig_operand.release (); + + brig_initialized = 0; +} + +/* Find the alignment base on the type. */ + +static BrigAlignment8_t +get_alignment (BrigType16_t type) +{ + unsigned bit_size ; + bit_size = hsa_type_bit_size (type & ~BRIG_TYPE_ARRAY); + + if (bit_size == 1) + return BRIG_ALIGNMENT_1; + if (bit_size == 8) + return BRIG_ALIGNMENT_1; + if (bit_size == 16) + return BRIG_ALIGNMENT_2; + if (bit_size == 32) + return BRIG_ALIGNMENT_4; + if (bit_size == 64) + return BRIG_ALIGNMENT_8; + if (bit_size == 128) + return BRIG_ALIGNMENT_16; + gcc_unreachable (); +} + +/* Emit directive describing a symbol if it has not been emitted already. + Return the offset of the directive. */ + +static unsigned +emit_directive_variable (struct hsa_symbol *symbol) +{ + struct BrigDirectiveVariable dirvar; + unsigned name_offset; + static unsigned res_name_offset; + char prefix; + + if (symbol->directive_offset) + return symbol->directive_offset; + + memset (&dirvar, 0, sizeof (dirvar)); + dirvar.base.byteCount = htole16 (sizeof (dirvar)); + dirvar.base.kind = htole16 (BRIG_KIND_DIRECTIVE_VARIABLE); + dirvar.allocation = BRIG_ALLOCATION_AUTOMATIC; + + if (symbol->decl && is_global_var (symbol->decl)) + { + prefix = '&'; + dirvar.allocation = BRIG_ALLOCATION_PROGRAM ; + if (TREE_CODE (symbol->decl) == VAR_DECL) + warning (0, "referring to global symbol %q+D by name from HSA code " + "won't work", symbol->decl); + } + else + prefix = '%'; + + if (symbol->decl && TREE_CODE (symbol->decl) == RESULT_DECL) + { + if (res_name_offset == 0) + res_name_offset = brig_emit_string (symbol->name, '%'); + name_offset = res_name_offset; + } + else if (symbol->name) + name_offset = brig_emit_string (symbol->name, prefix); + else + { + char buf[64]; + sprintf (buf, "__%s_%i", hsa_seg_name (symbol->segment), + symbol->name_number); + name_offset = brig_emit_string (buf, prefix); + } + + dirvar.name = htole32 (name_offset); + dirvar.init = 0; + dirvar.type = htole16 (symbol->type); + dirvar.segment = symbol->segment; + dirvar.align = get_alignment (dirvar.type); + dirvar.linkage = symbol->linkage; + dirvar.dim.lo = (uint32_t) symbol->dim; + dirvar.dim.hi = (uint32_t) ((unsigned long long) symbol->dim >> 32); + dirvar.modifier.allBits |= BRIG_VARIABLE_DEFINITION; + dirvar.reserved = 0; + + symbol->directive_offset = brig_code.add (&dirvar, sizeof (dirvar)); + return symbol->directive_offset; +} + +/* Emit directives describing either a function declaration or + definition F. */ + +static BrigDirectiveExecutable * +emit_function_directives (hsa_function_representation *f) +{ + struct BrigDirectiveExecutable fndir; + unsigned name_offset, inarg_off, scoped_off, next_toplev_off; + int count = 0; + BrigDirectiveExecutable *ptr_to_fndir; + hsa_symbol *sym; + + name_offset = brig_emit_string (f->name, '&'); + inarg_off = brig_code.total_size + sizeof(fndir) + + (f->output_arg ? sizeof (struct BrigDirectiveVariable) : 0); + scoped_off = inarg_off + + f->input_args_count * sizeof (struct BrigDirectiveVariable); + + if (!f->declaration_p) + { + for (hash_table <hsa_noop_symbol_hasher>::iterator iter + = f->local_symbols->begin (); + iter != f->local_symbols->end (); + ++iter) + if (TREE_CODE ((*iter)->decl) == VAR_DECL) + count++; + count += f->spill_symbols.length (); + } + + next_toplev_off = scoped_off + count * sizeof (struct BrigDirectiveVariable); + + memset (&fndir, 0, sizeof (fndir)); + fndir.base.byteCount = htole16 (sizeof (fndir)); + fndir.base.kind = htole16 (f->kern_p ? BRIG_KIND_DIRECTIVE_KERNEL + : BRIG_KIND_DIRECTIVE_FUNCTION); + fndir.name = htole32 (name_offset); + fndir.inArgCount = htole16 (f->input_args_count); + fndir.outArgCount = htole16 (f->output_arg ? 1 : 0); + fndir.firstInArg = htole32 (inarg_off); + fndir.firstCodeBlockEntry = htole32 (scoped_off); + fndir.nextModuleEntry = htole32 (next_toplev_off); + fndir.linkage = f->kern_p || TREE_PUBLIC (f->decl) ? BRIG_LINKAGE_PROGRAM : + BRIG_LINKAGE_MODULE; + + if (!f->declaration_p) + fndir.modifier.allBits |= BRIG_EXECUTABLE_DEFINITION; + memset (&fndir.reserved, 0, sizeof (fndir.reserved)); + + function_offsets->put (f->decl, brig_code.total_size); + + brig_code.add (&fndir, sizeof (fndir)); + /* XXX terrible hack: we need to set instCount after we emit all + insns, but we need to emit directive in order, and we emit directives + during insn emitting. So we need to emit the FUNCTION directive + early, then the insns, and then we need to set instCount, so remember + a pointer to it, in some horrible way. cur_chunk.data+size points + directly to after fndir here. */ + ptr_to_fndir + = (BrigDirectiveExecutable *)(brig_code.cur_chunk->data + + brig_code.cur_chunk->size + - sizeof (fndir)); + + if (f->output_arg) + emit_directive_variable (f->output_arg); + for (unsigned i = 0; i < f->input_args_count; i++) + emit_directive_variable (&f->input_args[i]); + + if (!f->declaration_p) + { + for (hash_table <hsa_noop_symbol_hasher>::iterator iter + = f->local_symbols->begin (); + iter != f->local_symbols->end (); + ++iter) + { + if (TREE_CODE ((*iter)->decl) == VAR_DECL) + brig_insn_count++; + emit_directive_variable (*iter); + } + for (int i = 0; f->spill_symbols.iterate (i, &sym); i++) + { + emit_directive_variable (sym); + brig_insn_count++; + } + } + + return ptr_to_fndir; +} + +/* Emit a label directive for the given HBB. We assume it is about to start on + the current offset in the code section. */ + +static void +emit_bb_label_directive (hsa_bb *hbb) +{ + struct BrigDirectiveLabel lbldir; + char buf[32]; + + lbldir.base.byteCount = htole16 (sizeof (lbldir)); + lbldir.base.kind = htole16 (BRIG_KIND_DIRECTIVE_LABEL); + sprintf (buf, "BB_%u_%i", DECL_UID (current_function_decl), hbb->index); + lbldir.name = htole32 (brig_emit_string (buf, '@')); + + hbb->label_ref.directive_offset = brig_code.add (&lbldir, sizeof (lbldir)); + brig_insn_count++; +} + +/* Map a normal HSAIL type to the type of the equivalent BRIG operand + holding such, for constants and registers. */ + +static BrigType16_t +regtype_for_type (BrigType16_t t) +{ + switch (t) + { + case BRIG_TYPE_B1: + return BRIG_TYPE_B1; + + case BRIG_TYPE_U8: + case BRIG_TYPE_U16: + case BRIG_TYPE_U32: + case BRIG_TYPE_S8: + case BRIG_TYPE_S16: + case BRIG_TYPE_S32: + case BRIG_TYPE_B8: + case BRIG_TYPE_B16: + case BRIG_TYPE_B32: + case BRIG_TYPE_F16: + case BRIG_TYPE_F32: + case BRIG_TYPE_U8X4: + case BRIG_TYPE_U16X2: + case BRIG_TYPE_S8X4: + case BRIG_TYPE_S16X2: + case BRIG_TYPE_F16X2: + return BRIG_TYPE_B32; + + case BRIG_TYPE_U64: + case BRIG_TYPE_S64: + case BRIG_TYPE_F64: + case BRIG_TYPE_B64: + case BRIG_TYPE_U8X8: + case BRIG_TYPE_U16X4: + case BRIG_TYPE_U32X2: + case BRIG_TYPE_S8X8: + case BRIG_TYPE_S16X4: + case BRIG_TYPE_S32X2: + case BRIG_TYPE_F16X4: + case BRIG_TYPE_F32X2: + + return BRIG_TYPE_B64; + + case BRIG_TYPE_B128: + case BRIG_TYPE_U8X16: + case BRIG_TYPE_U16X8: + case BRIG_TYPE_U32X4: + case BRIG_TYPE_U64X2: + case BRIG_TYPE_S8X16: + case BRIG_TYPE_S16X8: + case BRIG_TYPE_S32X4: + case BRIG_TYPE_S64X2: + case BRIG_TYPE_F16X8: + case BRIG_TYPE_F32X4: + case BRIG_TYPE_F64X2: + return BRIG_TYPE_B128; + + default: + gcc_unreachable (); + } +} + +/* Enqueue operation OP. Return the offset at which it will be stored. */ + +unsigned int +enqueue_op (hsa_op_base *op) +{ + unsigned ret; + + if (op->brig_op_offset) + return op->brig_op_offset; + + ret = op_queue.projected_size; + op->brig_op_offset = op_queue.projected_size; + + if (!op_queue.first_op) + op_queue.first_op = op; + else + op_queue.last_op->next = op; + op_queue.last_op = op; + + if (is_a <hsa_op_immed *> (op)) + op_queue.projected_size += sizeof (struct BrigOperandConstantBytes); + else if (is_a <hsa_op_reg *> (op)) + op_queue.projected_size += sizeof (struct BrigOperandRegister); + else if (is_a <hsa_op_address *> (op)) + { + op_queue.projected_size += sizeof (struct BrigOperandAddress); + } + else if (is_a <hsa_op_code_ref *> (op)) + op_queue.projected_size += sizeof (struct BrigOperandCodeRef); + else if (is_a <hsa_op_code_list *> (op)) + op_queue.projected_size += sizeof (struct BrigOperandCodeList); + else + gcc_unreachable (); + return ret; +} + +/* Return the length of the BRIG type TYPE that is going to be streamed out as + an immediate constant (so it must not be B1). */ + +static unsigned +hsa_get_imm_brig_type_len (BrigType16_t type) +{ + BrigType16_t base_type = type & BRIG_TYPE_BASE_MASK; + BrigType16_t pack_type = type & BRIG_TYPE_PACK_MASK; + + switch (pack_type) + { + case BRIG_TYPE_PACK_NONE: + break; + case BRIG_TYPE_PACK_32: + return 4; + case BRIG_TYPE_PACK_64: + return 8; + case BRIG_TYPE_PACK_128: + return 16; + default: + gcc_unreachable (); + } + + switch (base_type) + { + case BRIG_TYPE_U8: + case BRIG_TYPE_S8: + case BRIG_TYPE_B8: + return 1; + case BRIG_TYPE_U16: + case BRIG_TYPE_S16: + case BRIG_TYPE_F16: + case BRIG_TYPE_B16: + return 2; + case BRIG_TYPE_U32: + case BRIG_TYPE_S32: + case BRIG_TYPE_F32: + case BRIG_TYPE_B32: + return 4; + case BRIG_TYPE_U64: + case BRIG_TYPE_S64: + case BRIG_TYPE_F64: + case BRIG_TYPE_B64: + return 8; + case BRIG_TYPE_B128: + return 16; + default: + gcc_unreachable (); + } +} + +/* Emit one scalar VALUE to the data BRIG section. If NEED_LEN is not equal to + zero, shrink or extend the value to NEED_LEN bytes. Return how many bytes + were written. */ + +static int +emit_immediate_scalar_to_data_section (tree value, unsigned need_len) +{ + union + { + uint8_t b8; + uint16_t b16; + uint32_t b32; + uint64_t b64; + } bytes; + + memset (&bytes, 0, sizeof (bytes)); + tree type = TREE_TYPE (value); + gcc_checking_assert (TREE_CODE (type) != VECTOR_TYPE); + unsigned data_len = tree_to_uhwi (TYPE_SIZE (type))/BITS_PER_UNIT; + if (INTEGRAL_TYPE_P (type)) + switch (data_len) + { + case 1: + bytes.b8 = (uint8_t) TREE_INT_CST_LOW (value); + break; + case 2: + bytes.b16 = (uint16_t) TREE_INT_CST_LOW (value); + break; + case 4: + bytes.b32 = (uint32_t) TREE_INT_CST_LOW (value); + break; + case 8: + bytes.b64 = (uint64_t) int_cst_value (value); + break; + default: + gcc_unreachable (); + } + else if (SCALAR_FLOAT_TYPE_P (type)) + { + if (data_len == 2) + { + sorry ("Support for HSA does not implement immediate 16 bit FPU " + "operands"); + return 2; + } + unsigned int_len = GET_MODE_SIZE (TYPE_MODE (type)); + /* There are always 32 bits in each long, no matter the size of + the hosts long. */ + long tmp[6]; + + real_to_target (tmp, TREE_REAL_CST_PTR (value), TYPE_MODE (type)); + + if (int_len == 4) + bytes.b32 = (uint32_t) tmp[0]; + else + { + bytes.b64 = (uint64_t)(uint32_t) tmp[1]; + bytes.b64 <<= 32; + bytes.b64 |= (uint32_t) tmp[0]; + } + } + else + gcc_unreachable (); + + int len; + if (need_len == 0) + len = data_len; + else + len = need_len; + + brig_data.add (&bytes, len); + return len; +} + +/* Emit an immediate BRIG operand IMM. The BRIG type of the immediate might + have been massaged to comply with various HSA/BRIG type requirements, so the + only important aspect of that is the length (because HSAIL might expect + smaller constants or become bit-data). The data should be represented + according to what is in the tree representation. */ + +static void +emit_immediate_operand (hsa_op_immed *imm) +{ + struct BrigOperandConstantBytes out; + unsigned total_len = hsa_get_imm_brig_type_len (imm->type); + + /* We do not produce HSAIL array types anywhere. */ + gcc_assert (!(imm->type & BRIG_TYPE_ARRAY)); + + memset (&out, 0, sizeof (out)); + out.base.byteCount = htole16 (sizeof (out)); + out.base.kind = htole16 (BRIG_KIND_OPERAND_CONSTANT_BYTES); + uint32_t byteCount = htole32 (total_len); + out.type = htole16 (imm->type); + out.bytes = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_operand.add (&out, sizeof(out)); + + if (TREE_CODE (imm->value) == VECTOR_CST) + { + int i, num = VECTOR_CST_NELTS (imm->value); + for (i = 0; i < num; i++) + { + unsigned actual; + actual = emit_immediate_scalar_to_data_section + (VECTOR_CST_ELT (imm->value, i), 0); + total_len -= actual; + } + /* Vectors should have the exact size. */ + gcc_assert (total_len == 0); + } + else + emit_immediate_scalar_to_data_section (imm->value, total_len); + + brig_data.round_size_up (4); +} + +/* Emit a register BRIG operand REG. */ + +static void +emit_register_operand (hsa_op_reg *reg) +{ + struct BrigOperandRegister out; + + out.base.byteCount = htole16 (sizeof (out)); + out.base.kind = htole16 (BRIG_KIND_OPERAND_REGISTER); + out.regNum = htole32 (reg->hard_num); + + switch (regtype_for_type (reg->type)) + { + case BRIG_TYPE_B32: + out.regKind = BRIG_REGISTER_KIND_SINGLE; + break; + case BRIG_TYPE_B64: + out.regKind = BRIG_REGISTER_KIND_DOUBLE; + break; + case BRIG_TYPE_B128: + out.regKind = BRIG_REGISTER_KIND_QUAD; + break; + case BRIG_TYPE_B1: + out.regKind = BRIG_REGISTER_KIND_CONTROL; + break; + default: + gcc_unreachable (); + } + + brig_operand.add (&out, sizeof (out)); +} + +/* Emit an address BRIG operand ADDR. */ + +static void +emit_address_operand (hsa_op_address *addr) +{ + struct BrigOperandAddress out; + + out.base.byteCount = htole16 (sizeof (out)); + out.base.kind = htole16 (BRIG_KIND_OPERAND_ADDRESS); + out.symbol = addr->symbol + ? htole32 (emit_directive_variable (addr->symbol)) : 0; + out.reg = addr->reg ? htole32 (enqueue_op (addr->reg)) : 0; + + /* FIXME: This is very clumsy. */ + if (sizeof (addr->imm_offset) == 8) + { + out.offset.lo = htole32 ((uint32_t)addr->imm_offset); + out.offset.hi = htole32 (((long long) addr->imm_offset) >> 32); + } + else + { + out.offset.lo = htole32 (addr->imm_offset); + out.offset.hi = 0; + } + + brig_operand.add (&out, sizeof (out)); +} + +/* Emit a code reference operand REF. */ + +static void +emit_code_ref_operand (hsa_op_code_ref *ref) +{ + struct BrigOperandCodeRef out; + + out.base.byteCount = htole16 (sizeof (out)); + out.base.kind = htole16 (BRIG_KIND_OPERAND_CODE_REF); + out.ref = htole32 (ref->directive_offset); + brig_operand.add (&out, sizeof (out)); +} + +/* Emit a code list operand CODE_LIST. */ + +static void +emit_code_list_operand (hsa_op_code_list *code_list) +{ + struct BrigOperandCodeList out; + unsigned args = code_list->offsets.length (); + + for (unsigned i = 0; i < args; i++) + gcc_assert (code_list->offsets[i]); + + out.base.byteCount = htole16 (sizeof (out)); + out.base.kind = htole16 (BRIG_KIND_OPERAND_CODE_LIST); + + uint32_t byteCount = htole32 (4 * args); + + out.elements = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (code_list->offsets.address (), args * sizeof (uint32_t)); + brig_data.round_size_up (4); + brig_operand.add (&out, sizeof (out)); +} + +/* Emit all operands queued for writing. */ + +static void +emit_queued_operands (void) +{ + for (hsa_op_base *op = op_queue.first_op; op; op = op->next) + { + gcc_assert (op->brig_op_offset == brig_operand.total_size); + if (hsa_op_immed *imm = dyn_cast <hsa_op_immed *> (op)) + emit_immediate_operand (imm); + else if (hsa_op_reg *reg = dyn_cast <hsa_op_reg *> (op)) + emit_register_operand (reg); + else if (hsa_op_address *addr = dyn_cast <hsa_op_address *> (op)) + emit_address_operand (addr); + else if (hsa_op_code_ref *ref = dyn_cast <hsa_op_code_ref *> (op)) + emit_code_ref_operand (ref); + else if (hsa_op_code_list *code_list = dyn_cast <hsa_op_code_list *> (op)) + emit_code_list_operand (code_list); + else + gcc_unreachable (); + } +} + +/* Emit directives describing the function that is used for +a function declaration. */ +static void +emit_function_declaration (tree decl) +{ + hsa_function_representation *f = hsa_generate_function_declaration (decl); + + emit_function_directives (f); + emit_queued_operands (); + + delete f; +} + +/* Emit an HSA memory instruction and all necessary directives, schedule + necessary operands for writing . */ + +static void +emit_memory_insn (hsa_insn_mem *mem) +{ + struct BrigInstMem repr; + BrigOperandOffset32_t operand_offsets[2]; + uint32_t byteCount; + + hsa_op_address *addr = as_a <hsa_op_address *> (mem->operands[1]); + + /* This is necessary because of the erroneous typedef of + BrigMemoryModifier8_t which introduces padding which may then contain + random stuff (which we do not want so that we can test things don't + change). */ + memset (&repr, 0, sizeof (repr)); + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_MEM); + repr.base.opcode = htole16 (mem->opcode); + repr.base.type = htole16 (mem->type); + + operand_offsets[0] = htole32 (enqueue_op (mem->operands[0])); + operand_offsets[1] = htole32 (enqueue_op (mem->operands[1])); + /* We have two operands so use 4 * 2 for the byteCount */ + byteCount = htole32 (4 * 2); + + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + + if (addr->symbol) + repr.segment = addr->symbol->segment; + else + repr.segment = BRIG_SEGMENT_FLAT; + repr.modifier.allBits = 0 ; + repr.equivClass = mem->equiv_class; + repr.align = BRIG_ALIGNMENT_1; + if (mem->opcode == BRIG_OPCODE_LD) + repr.width = BRIG_WIDTH_1; + else + repr.width = BRIG_WIDTH_NONE; + memset (&repr.reserved, 0, sizeof (repr.reserved)); + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit an HSA atomic memory instruction and all necessary directives, schedule + necessary operands for writing . */ + +static void +emit_atomic_insn (hsa_insn_atomic *mem) +{ + struct BrigInstAtomic repr; + BrigOperandOffset32_t operand_offsets[4]; + uint32_t byteCount; + + hsa_op_address *addr = as_a <hsa_op_address *> (mem->operands[1]); + + /* This is necessary because of the erroneous typedef of + BrigMemoryModifier8_t which introduces padding which may then contain + random stuff (which we do not want so that we can test things don't + change). */ + memset (&repr, 0, sizeof (repr)); + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_ATOMIC); + repr.base.opcode = htole16 (mem->opcode); + repr.base.type = htole16 (mem->type); + + operand_offsets[0] = htole32 (enqueue_op (mem->operands[0])); + operand_offsets[1] = htole32 (enqueue_op (mem->operands[1])); + operand_offsets[2] = htole32 (enqueue_op (mem->operands[2])); + operand_offsets[3] = htole32 (enqueue_op (mem->operands[3])); + + /* We have 4 operands so use 4 * 4 for the byteCount */ + byteCount = htole32 (4 * 4); + + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + + if (addr->symbol) + repr.segment = addr->symbol->segment; + else + repr.segment = BRIG_SEGMENT_FLAT; + repr.memoryOrder = mem->memoryorder; + repr.memoryScope = mem->memoryscope; + repr.atomicOperation = mem->atomicop; + + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit an HSA LDA instruction and all necessary directives, schedule + necessary operands for writing . */ + +static void +emit_addr_insn (hsa_insn_basic *insn) +{ + struct BrigInstAddr repr; + BrigOperandOffset32_t operand_offsets[2]; + uint32_t byteCount; + + hsa_op_address *addr = as_a <hsa_op_address *> (insn->operands[1]); + + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_ADDR); + repr.base.opcode = htole16 (insn->opcode); + repr.base.type = htole16 (insn->type); + + operand_offsets[0] = htole32 (enqueue_op (insn->operands[0])); + operand_offsets[1] = htole32 (enqueue_op (insn->operands[1])); + + /* We have two operands so use 4 * 2 for the byteCount */ + byteCount = htole32 (4 * 2); + + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + + if (addr->symbol) + repr.segment = addr->symbol->segment; + else + repr.segment = BRIG_SEGMENT_FLAT; + memset (&repr.reserved, 0, sizeof (repr.reserved)); + + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit an HSA segment conversion instruction and all necessary directives, + schedule necessary operands for writing . */ + +static void +emit_segment_insn (hsa_insn_seg *seg) +{ + struct BrigInstSegCvt repr; + BrigOperandOffset32_t operand_offsets[2]; + uint32_t byteCount; + + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_SEG_CVT); + repr.base.opcode = htole16 (seg->opcode); + repr.base.type = htole16 (seg->type); + + operand_offsets[0] = htole32 (enqueue_op (seg->operands[0])); + operand_offsets[1] = htole32 (enqueue_op (seg->operands[1])); + + /* We have two operands so use 4 * 2 for the byteCount */ + byteCount = htole32 (4 * 2); + + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + + repr.sourceType = htole16 (as_a <hsa_op_reg *> (seg->operands[1])->type); + repr.segment = seg->segment; + repr.modifier.allBits = 0; + + brig_code.add (&repr, sizeof (repr)); + + brig_insn_count++; +} + +/* Emit an HSA comparison instruction and all necessary directives, + schedule necessary operands for writing . */ + +static void +emit_cmp_insn (hsa_insn_cmp *cmp) +{ + struct BrigInstCmp repr; + BrigOperandOffset32_t operand_offsets[3]; + uint32_t byteCount; + + memset (&repr, 0, sizeof (repr)); + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_CMP); + repr.base.opcode = htole16 (cmp->opcode); + repr.base.type = htole16 (cmp->type); + + operand_offsets[0] = htole32 (enqueue_op (cmp->operands[0])); + operand_offsets[1] = htole32 (enqueue_op (cmp->operands[1])); + operand_offsets[2] = htole32 (enqueue_op (cmp->operands[2])); + /* We have three operands so use 4 * 3 for the byteCount */ + byteCount = htole32 (4 * 3); + + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + + if (is_a <hsa_op_reg *> (cmp->operands[1])) + repr.sourceType = htole16 (as_a <hsa_op_reg *> (cmp->operands[1])->type); + else + repr.sourceType = htole16 (as_a <hsa_op_immed *> (cmp->operands[1])->type); + repr.modifier.allBits = 0; + repr.compare = cmp->compare; + repr.pack = 0; + + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit an HSA branching instruction and all necessary directives, schedule + necessary operands for writing . */ + +static void +emit_branch_insn (hsa_insn_br *br) +{ + struct BrigInstBr repr; + BrigOperandOffset32_t operand_offsets[2]; + uint32_t byteCount; + + basic_block target = NULL; + edge_iterator ei; + edge e; + + /* At the moment we only handle direct conditional jumps. */ + gcc_assert (br->opcode == BRIG_OPCODE_CBR); + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_BR); + repr.base.opcode = htole16 (br->opcode); + repr.width = BRIG_WIDTH_1; + /* For Conditional jumps the type is always B1 */ + repr.base.type = htole16 (BRIG_TYPE_B1); + + operand_offsets[0] = htole32 (enqueue_op (br->operands[0])); + + FOR_EACH_EDGE (e, ei, br->bb->succs) + if (e->flags & EDGE_TRUE_VALUE) + { + target = e->dest; + break; + } + gcc_assert (target); + operand_offsets[1] = htole32 (enqueue_op + (&hsa_bb_for_bb (target)->label_ref)); + + /* We have 2 operands so use 4 * 2 for the byteCount */ + byteCount = htole32 (4 * 2); + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + repr.width = BRIG_WIDTH_1; + memset (&repr.reserved, 0, sizeof (repr.reserved)); + + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit a HSA convert instruction and all necessary directives, schedule + necessary operands for writing. */ + +static void +emit_cvt_insn (hsa_insn_basic *insn) +{ + struct BrigInstCvt repr; + BrigType16_t srctype; + auto_vec<BrigOperandOffset32_t, HSA_BRIG_INT_STORAGE_OPERANDS> operand_offsets; + uint32_t byteCount, operand_count = insn->operands.length (); + + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_CVT); + repr.base.opcode = htole16 (insn->opcode); + repr.base.type = htole16 (insn->type); + + operand_offsets.safe_grow_cleared (operand_count); + for (unsigned i = 0; i < operand_count; i++) + { + gcc_checking_assert (insn->operands[i]); + operand_offsets[i] = htole32 (enqueue_op (insn->operands[i])); + } + + byteCount = htole32 (4 * operand_count) ; + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (operand_offsets.address (), + operand_count * sizeof (BrigOperandOffset32_t)); + + if (is_a <hsa_op_reg *> (insn->operands[1])) + srctype = as_a <hsa_op_reg *> (insn->operands[1])->type; + else + srctype = as_a <hsa_op_immed *> (insn->operands[1])->type; + repr.sourceType = htole16 (srctype); + repr.modifier.allBits = 0; + /* float to smaller float requires a rounding setting (we default + to 'near'. */ + if (hsa_type_float_p (insn->type) + && (!hsa_type_float_p (srctype) + || ((insn->type & BRIG_TYPE_BASE_MASK) + < (srctype & BRIG_TYPE_BASE_MASK)))) + repr.round = BRIG_ROUND_FLOAT_NEAR_EVEN; + else + repr.round = BRIG_ROUND_NONE; + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit call instruction INSN, where this instruction must be closed + within a call block instruction. */ + +static void +emit_call_insn (hsa_insn_basic *insn) +{ + hsa_insn_call *call = dyn_cast <hsa_insn_call *> (insn); + struct BrigInstBr repr; + uint32_t byteCount; + + BrigOperandOffset32_t operand_offsets[3]; + + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_BR); + repr.base.opcode = htole16 (BRIG_OPCODE_CALL); + repr.base.type = htole16 (BRIG_TYPE_NONE); + + /* Operand 0: out-args. */ + operand_offsets[0] = htole32 (enqueue_op (call->result_code_list)); + + /* Operand 1: func */ + BrigCodeOffset32_t *func_offset = function_offsets->get + (call->called_function); + gcc_assert (func_offset != NULL); + call->func.directive_offset = *func_offset; + unsigned int offset = enqueue_op (&call->func); + + operand_offsets[1] = htole32 (offset); + /* Operand 2: in-args. */ + operand_offsets[2] = htole32 (enqueue_op (call->args_code_list)); + + /* We have 3 operands so use 3 * 4 for the byteCount */ + byteCount = htole32 (3 * 4); + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + repr.width = BRIG_WIDTH_ALL; + memset (&repr.reserved, 0, sizeof (repr.reserved)); + + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit argument block directive. */ + +static void +emit_arg_block_insn (hsa_insn_arg_block *insn) +{ + switch (insn->kind) + { + case BRIG_KIND_DIRECTIVE_ARG_BLOCK_START: + { + struct BrigDirectiveArgBlockStart repr; + repr.base.byteCount = htole16 (sizeof (repr)); + repr.base.kind = htole16 (insn->kind); + brig_code.add (&repr, sizeof (repr)); + + for (unsigned i = 0; i < insn->call_insn->input_args.length (); i++) + { + insn->call_insn->args_code_list->offsets[i] = htole32 + (emit_directive_variable (insn->call_insn->input_args[i])); + brig_insn_count++; + } + + if (insn->call_insn->result_symbol) + { + insn->call_insn->result_code_list->offsets[0] = htole32 + (emit_directive_variable (insn->call_insn->output_arg)); + brig_insn_count++; + } + + break; + } + case BRIG_KIND_DIRECTIVE_ARG_BLOCK_END: + { + struct BrigDirectiveArgBlockEnd repr; + repr.base.byteCount = htole16 (sizeof (repr)); + repr.base.kind = htole16 (insn->kind); + brig_code.add (&repr, sizeof (repr)); + break; + } + default: + gcc_unreachable (); + } + + brig_insn_count++; +} + +/* Emit a basic HSA instruction and all necessary directives, schedule + necessary operands for writing. */ + +static void +emit_basic_insn (hsa_insn_basic *insn) +{ + /* We assume that BrigInstMod has a BrigInstBasic prefix. */ + struct BrigInstMod repr; + BrigType16_t type; + auto_vec<BrigOperandOffset32_t, HSA_BRIG_INT_STORAGE_OPERANDS> operand_offsets; + uint32_t byteCount, operand_count = insn->operands.length (); + + if (insn->opcode == BRIG_OPCODE_CVT) + { + emit_cvt_insn (insn); + return; + } + + memset (&repr, 0, sizeof (repr)); + repr.base.base.byteCount = htole16 (sizeof (BrigInstBasic)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_BASIC); + repr.base.opcode = htole16 (insn->opcode); + switch (insn->opcode) + { + /* And the bit-logical operations need bit types and whine about + arithmetic types :-/ */ + case BRIG_OPCODE_AND: + case BRIG_OPCODE_OR: + case BRIG_OPCODE_XOR: + case BRIG_OPCODE_NOT: + type = regtype_for_type (insn->type); + break; + default: + type = insn->type; + break; + } + repr.base.type = htole16 (type); + + operand_offsets.safe_grow_cleared (operand_count); + for (unsigned i = 0; i < operand_count; i++) + { + gcc_checking_assert (insn->operands[i]); + operand_offsets[i] = htole32 (enqueue_op (insn->operands[i])); + } + + byteCount = htole32 (4 * operand_count) ; + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (operand_offsets.address (), + operand_count * sizeof (BrigOperandOffset32_t)); + brig_data.round_size_up (4); + + if ((type & BRIG_TYPE_PACK_MASK) != BRIG_TYPE_PACK_NONE) + { + if (hsa_type_float_p (type)) + repr.round = BRIG_ROUND_FLOAT_NEAR_EVEN; + else + repr.round = 0; + /* We assume that destination and sources agree in packing + layout. */ + if (insn->operands[2]) + repr.pack = BRIG_PACK_PP; + else + repr.pack = BRIG_PACK_P; + repr.reserved = 0; + repr.base.base.byteCount = htole16 (sizeof (BrigInstMod)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_MOD); + brig_code.add (&repr, sizeof (struct BrigInstMod)); + } + else + brig_code.add (&repr, sizeof (struct BrigInstBasic)); + brig_insn_count++; +} + +/* Emit an HSA instruction and all necessary directives, schedule necessary + operands for writing . */ + +static void +emit_insn (hsa_insn_basic *insn) +{ + gcc_assert (!is_a <hsa_insn_phi *> (insn)); + if (hsa_insn_atomic *atom = dyn_cast <hsa_insn_atomic *> (insn)) + { + emit_atomic_insn (atom); + return; + } + if (hsa_insn_mem *mem = dyn_cast <hsa_insn_mem *> (insn)) + { + emit_memory_insn (mem); + return; + } + if (insn->opcode == BRIG_OPCODE_LDA) + { + emit_addr_insn (insn); + return; + } + if (hsa_insn_seg *seg = dyn_cast <hsa_insn_seg *> (insn)) + { + emit_segment_insn (seg); + return; + } + if (hsa_insn_cmp *cmp = dyn_cast <hsa_insn_cmp *> (insn)) + { + emit_cmp_insn (cmp); + return; + } + if (hsa_insn_br *br = dyn_cast <hsa_insn_br *> (insn)) + { + emit_branch_insn (br); + return; + } + if (hsa_insn_arg_block *arg_block = dyn_cast <hsa_insn_arg_block *> (insn)) + { + emit_arg_block_insn (arg_block); + return; + } + if (hsa_insn_call *call = dyn_cast <hsa_insn_call *> (insn)) + { + emit_call_insn (call); + return; + } + emit_basic_insn (insn); +} + +/* We have just finished emitting BB and are about to emit NEXT_BB if non-NULL, + or we are about to finish emiting code, if it is NULL. If the fall through + edge from BB does not lead to NEXT_BB, emit an unconditional jump. */ + +static void +perhaps_emit_branch (basic_block bb, basic_block next_bb) +{ + basic_block t_bb = NULL, ff = NULL; + struct BrigInstBr repr; + BrigOperandOffset32_t operand_offsets[1]; + uint32_t byteCount; + + edge_iterator ei; + edge e; + + FOR_EACH_EDGE (e, ei, bb->succs) + if (e->flags & EDGE_TRUE_VALUE) + { + gcc_assert (!t_bb); + t_bb = e->dest; + } + else + { + gcc_assert (!ff); + ff = e->dest; + } + gcc_assert (ff); + if (ff == next_bb + || ff == EXIT_BLOCK_PTR_FOR_FN (cfun)) + return; + + repr.base.base.byteCount = htole16 (sizeof (repr)); + repr.base.base.kind = htole16 (BRIG_KIND_INST_BR); + repr.base.opcode = htole16 (BRIG_OPCODE_BR); + repr.base.type = htole16 (BRIG_TYPE_NONE); + /* Direct branches to labels must be width(all). */ + repr.width = BRIG_WIDTH_ALL; + + operand_offsets[0] = htole32 (enqueue_op (&hsa_bb_for_bb (ff)->label_ref)); + /* We have 1 operand so use 4 * 1 for the byteCount */ + byteCount = htole32 (4 * 1); + repr.base.operands = htole32 (brig_data.add (&byteCount, sizeof (byteCount))); + brig_data.add (&operand_offsets, sizeof (operand_offsets)); + brig_data.round_size_up (4); + memset (&repr.reserved, 0, sizeof (repr.reserved)); + brig_code.add (&repr, sizeof (repr)); + brig_insn_count++; +} + +/* Emit the a function with name NAME to the various brig sections. */ + +void +hsa_brig_emit_function (void) +{ + basic_block bb, prev_bb; + hsa_insn_basic *insn; + BrigDirectiveExecutable *ptr_to_fndir; + + brig_init (); + + brig_insn_count = 0; + memset (&op_queue, 0, sizeof (op_queue)); + op_queue.projected_size = brig_operand.total_size; + + if (!function_offsets) + function_offsets = new hash_map<tree, BrigCodeOffset32_t> (); + + for (unsigned i = 0; i < hsa_cfun->called_functions.length (); i++) + { + tree called = hsa_cfun->called_functions[i]; + + if (function_offsets->get (called) == NULL) + { + emit_function_declaration (called); + gcc_assert (function_offsets->get (called) != NULL); + } + } + + ptr_to_fndir = emit_function_directives (hsa_cfun); + for (insn = hsa_bb_for_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun))->first_insn; + insn; + insn = insn->next) + emit_insn (insn); + prev_bb = ENTRY_BLOCK_PTR_FOR_FN (cfun); + FOR_EACH_BB_FN (bb, cfun) + { + perhaps_emit_branch (prev_bb, bb); + emit_bb_label_directive (hsa_bb_for_bb (bb)); + for (insn = hsa_bb_for_bb (bb)->first_insn; insn; insn = insn->next) + emit_insn (insn); + prev_bb = bb; + } + perhaps_emit_branch (prev_bb, NULL); + ptr_to_fndir->nextModuleEntry = brig_code.total_size; + + emit_queued_operands (); +} + +/* Unit constructor and destructor statements. */ + +static GTY(()) tree hsa_ctor_statements; +static GTY(()) tree hsa_dtor_statements; + +/* Create a static constructor that will register out brig stuff with + libgomp. */ + +static void +hsa_output_kernel_mapping (tree brig_decl) +{ + unsigned map_count = hsa_get_number_decl_kernel_mappings (); + + tree int_num_of_kernels; + int_num_of_kernels = build_int_cst (integer_type_node, (int) map_count); + tree kernel_num_index_type = build_index_type (int_num_of_kernels); + tree host_functions_array_type = build_array_type (ptr_type_node, + kernel_num_index_type); + + vec<constructor_elt, va_gc> *host_functions_vec = NULL; + for (unsigned i = 0; i < map_count; ++i) + { + tree decl = hsa_get_decl_kernel_mapping_decl (i); + CONSTRUCTOR_APPEND_ELT (host_functions_vec, NULL_TREE, + build_fold_addr_expr (decl)); + } + tree host_functions_ctor = build_constructor (host_functions_array_type, + host_functions_vec); + char tmp_name[64]; + ASM_GENERATE_INTERNAL_LABEL (tmp_name, "hsa_host_functions", 1); + tree hsa_host_func_table = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier (tmp_name), + host_functions_array_type); + TREE_STATIC (hsa_host_func_table) = 1; + TREE_READONLY (hsa_host_func_table) = 1; + TREE_PUBLIC (hsa_host_func_table) = 0; + DECL_ARTIFICIAL (hsa_host_func_table) = 1; + DECL_IGNORED_P (hsa_host_func_table) = 1; + DECL_EXTERNAL (hsa_host_func_table) = 0; + TREE_CONSTANT (hsa_host_func_table) = 1; + DECL_INITIAL (hsa_host_func_table) = host_functions_ctor; + varpool_node::finalize_decl (hsa_host_func_table); + + int len = 0; + for (unsigned i = 0; i < map_count; ++i) + { + char *name = hsa_get_decl_kernel_mapping_name (i); + /* We add 1 for the terminating zero and 1 for an ampersand prefix. */ + len = len + strlen (name) + 2; + } + len++; + + char *buf = XNEWVEC (char, len); + char *p = buf; + for (unsigned i = 0; i < map_count; ++i) + { + char *name = hsa_get_decl_kernel_mapping_name (i); + int ll = strlen (name); + gcc_assert (ll > 0); + *p = '&'; + p++; + memcpy (p, name, ll); + p += ll; + *p = '\0'; + p++; + } + *p = '\0'; + tree kern_names = build_string (len, buf); + TREE_TYPE (kern_names) = build_array_type (char_type_node, + build_index_type (size_int (len))); + free (buf); + + tree hsa_image_desc_type = make_node (RECORD_TYPE); + tree id_f1 = build_decl (BUILTINS_LOCATION, FIELD_DECL, + get_identifier ("brig_module"), ptr_type_node); + DECL_CHAIN (id_f1) = NULL_TREE; + tree id_f2 = build_decl (BUILTINS_LOCATION, FIELD_DECL, + get_identifier ("kern_names"), ptr_type_node); + DECL_CHAIN (id_f2) = id_f1; + finish_builtin_struct (hsa_image_desc_type, "__hsa_image_desc", id_f2, + NULL_TREE); + + vec<constructor_elt, va_gc> *img_desc_vec = NULL; + CONSTRUCTOR_APPEND_ELT (img_desc_vec, NULL_TREE, + build_fold_addr_expr (brig_decl)); + CONSTRUCTOR_APPEND_ELT (img_desc_vec, NULL_TREE, + build1 (ADDR_EXPR, + build_pointer_type (TREE_TYPE (kern_names)), + kern_names)); + + tree img_desc_ctor = build_constructor (hsa_image_desc_type, img_desc_vec); + + ASM_GENERATE_INTERNAL_LABEL (tmp_name, "hsa_img_descriptor", 1); + tree hsa_img_descriptor = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier (tmp_name), + hsa_image_desc_type); + TREE_STATIC (hsa_img_descriptor) = 1; + TREE_READONLY (hsa_img_descriptor) = 1; + TREE_PUBLIC (hsa_img_descriptor) = 0; + DECL_ARTIFICIAL (hsa_img_descriptor) = 1; + DECL_IGNORED_P (hsa_img_descriptor) = 1; + DECL_EXTERNAL (hsa_img_descriptor) = 0; + TREE_CONSTANT (hsa_img_descriptor) = 1; + DECL_INITIAL (hsa_img_descriptor) = img_desc_ctor; + varpool_node::finalize_decl (hsa_img_descriptor); + + /* Construct the "host_table" libgomp expects. */ + tree libgomp_host_table_type = build_array_type (ptr_type_node, + build_index_type + (build_int_cst + (integer_type_node, 4))); + vec<constructor_elt, va_gc> *libgomp_host_table_vec = NULL; + tree host_func_table_addr = build_fold_addr_expr (hsa_host_func_table); + CONSTRUCTOR_APPEND_ELT (libgomp_host_table_vec, NULL_TREE, + host_func_table_addr); + offset_int func_table_size = wi::to_offset (TYPE_SIZE_UNIT (ptr_type_node)) + * map_count; + CONSTRUCTOR_APPEND_ELT (libgomp_host_table_vec, NULL_TREE, + fold_build2 (POINTER_PLUS_EXPR, + TREE_TYPE (host_func_table_addr), + host_func_table_addr, + build_int_cst (size_type_node, + func_table_size.to_uhwi + ()))); + CONSTRUCTOR_APPEND_ELT (libgomp_host_table_vec, NULL_TREE, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (libgomp_host_table_vec, NULL_TREE, null_pointer_node); + tree libgomp_host_table_ctor = build_constructor (libgomp_host_table_type, + libgomp_host_table_vec); + ASM_GENERATE_INTERNAL_LABEL (tmp_name, "hsa_libgomp_host_table", 1); + tree hsa_libgomp_host_table = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier (tmp_name), + libgomp_host_table_type); + + TREE_STATIC (hsa_libgomp_host_table) = 1; + TREE_READONLY (hsa_libgomp_host_table) = 1; + TREE_PUBLIC (hsa_libgomp_host_table) = 0; + DECL_ARTIFICIAL (hsa_libgomp_host_table) = 1; + DECL_IGNORED_P (hsa_libgomp_host_table) = 1; + DECL_EXTERNAL (hsa_libgomp_host_table) = 0; + TREE_CONSTANT (hsa_libgomp_host_table) = 1; + DECL_INITIAL (hsa_libgomp_host_table) = libgomp_host_table_ctor; + varpool_node::finalize_decl (hsa_libgomp_host_table); + + /* Generate an initializer with a call to the registration routine. */ + + /* __hsa_register_image is an a testing-only registration routine that will + go away once the transition to gomp plugin is complete. However, at th + moment we support it too. */ + tree reg_fn_type = build_function_type_list (void_type_node, ptr_type_node, + ptr_type_node, NULL_TREE); + tree reg_fn = build_fn_decl ("__hsa_register_image", reg_fn_type); + + append_to_statement_list + (build_call_expr (builtin_decl_explicit (BUILT_IN_GOMP_OFFLOAD_REGISTER), 3, + build_fold_addr_expr (hsa_libgomp_host_table), + /* 7 stands for HSA */ + build_int_cst (integer_type_node, 7), + build_fold_addr_expr (hsa_img_descriptor)), + &hsa_ctor_statements); + append_to_statement_list + (build_call_expr (reg_fn, 2, + build_fold_addr_expr (hsa_libgomp_host_table), + build_fold_addr_expr (hsa_img_descriptor)), + &hsa_ctor_statements); + + cgraph_build_static_cdtor ('I', hsa_ctor_statements, DEFAULT_INIT_PRIORITY); + + append_to_statement_list + (build_call_expr (builtin_decl_explicit (BUILT_IN_GOMP_OFFLOAD_UNREGISTER), + 3, build_fold_addr_expr (hsa_libgomp_host_table), + /* 7 stands for HSA */ + build_int_cst (integer_type_node, 7), + build_fold_addr_expr (hsa_img_descriptor)), + &hsa_dtor_statements); + cgraph_build_static_cdtor ('D', hsa_dtor_statements, DEFAULT_INIT_PRIORITY); +} + +/* Required HSA section alignment. */ + +#define HSA_SECTION_ALIGNMENT 16 + +/* Emit the brig module we have compiled to a section in the final assembly and + also create a compile unit static constructor that will register the brig + module with libgomp. */ + +void +hsa_output_brig (void) +{ + section *saved_section; + + if (!brig_initialized) + return; + + saved_section = in_section; + + switch_to_section (get_section (BRIG_ELF_SECTION_NAME, SECTION_NOTYPE, NULL)); + char tmp_name[64]; + ASM_GENERATE_INTERNAL_LABEL (tmp_name, BRIG_LABEL_STRING, 1); + ASM_OUTPUT_LABEL (asm_out_file, tmp_name); + tree brig_id = get_identifier (tmp_name); + tree brig_decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, brig_id, + char_type_node); + SET_DECL_ASSEMBLER_NAME (brig_decl, brig_id); + TREE_ADDRESSABLE (brig_decl) = 1; + TREE_READONLY (brig_decl) = 1; + DECL_ARTIFICIAL (brig_decl) = 1; + DECL_IGNORED_P (brig_decl) = 1; + TREE_STATIC (brig_decl) = 1; + TREE_PUBLIC (brig_decl) = 0; + TREE_USED (brig_decl) = 1; + DECL_INITIAL (brig_decl) = brig_decl; + TREE_ASM_WRITTEN (brig_decl) = 1; + + BrigModuleHeader module_header; + memcpy (&module_header.identification, "HSA BRIG", + sizeof(module_header.identification)); + module_header.brigMajor = htole32 (BRIG_VERSION_BRIG_MAJOR); + module_header.brigMinor = htole32 (BRIG_VERSION_BRIG_MINOR); + uint64_t section_index[3]; + + int data_padding, code_padding, operand_padding; + data_padding = HSA_SECTION_ALIGNMENT + - brig_data.total_size % HSA_SECTION_ALIGNMENT; + code_padding = HSA_SECTION_ALIGNMENT + - brig_code.total_size % HSA_SECTION_ALIGNMENT; + operand_padding = HSA_SECTION_ALIGNMENT + - brig_operand.total_size % HSA_SECTION_ALIGNMENT; + + uint64_t module_size = sizeof (module_header) + sizeof (section_index) + + brig_data.total_size + data_padding + + brig_code.total_size + code_padding + + brig_operand.total_size + operand_padding; + gcc_assert ((module_size % 16) == 0); + module_header.byteCount = htole64 (module_size); + memset (&module_header.hash, 0, sizeof (module_header.hash)); + module_header.reserved = 0; + module_header.sectionCount = htole32 (3); + module_header.sectionIndex = htole64 (sizeof (module_header)); + assemble_string ((const char *) &module_header, sizeof(module_header)); + uint64_t off = sizeof (module_header) + sizeof (section_index); + section_index[0] = htole64 (off); + off += brig_data.total_size + data_padding; + section_index[1] = htole64 (off); + off += brig_code.total_size + code_padding; + section_index[2] = htole64 (off); + assemble_string ((const char *) &section_index, sizeof (section_index)); + + char padding[HSA_SECTION_ALIGNMENT]; + memset (padding, 0, sizeof(padding)); + + brig_data.output (); + assemble_string (padding, data_padding); + brig_code.output (); + assemble_string (padding, code_padding); + brig_operand.output (); + assemble_string (padding, operand_padding); + + if (saved_section) + switch_to_section (saved_section); + + hsa_output_kernel_mapping (brig_decl); + + hsa_free_decl_kernel_mapping (); + brig_release_data (); + hsa_deinit_compilation_unit_data (); +} diff --cc gcc/hsa.h index b43a991,0000000..b9acb9d mode 100644,000000..100644 --- a/gcc/hsa.h +++ b/gcc/hsa.h @@@ -1,793 -1,0 +1,789 @@@ +/* HSAIL and BRIG related macros and definitions. + Copyright (C) 2013 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 +http://www.gnu.org/licenses/. */ + +#ifndef HSA_H +#define HSA_H + +#include "hsa-brig-format.h" +#include "is-a.h" +#include "predict.h" +#include "tree.h" +#include "vec.h" +#include "hash-table.h" +#include "basic-block.h" + +class hsa_insn_basic; +typedef hsa_insn_basic *hsa_insn_basic_p; + +/* Class representing an input argument, output argument (result) or a + variable, that will eventually end up being a symbol directive. */ + +struct hsa_symbol +{ + /* Pointer to the original tree, which is PARM_DECL for input parameters and + RESULT_DECL for the output parameters. */ + tree decl; + + /* Name of the symbol, that will be written into output and dumps. Can be + NULL, see name_number below.*/ + const char *name; + + /* If name is NULL, artificial name will be formed from the segment name and + this number. */ + int name_number; + + /* Once written, this is the offset of the associated symbol directive. Zero + means the symbol has not been written yet. */ + unsigned directive_offset; + + /* HSA type of the parameter. */ + BrigType16_t type; + + /* The HSA segment this will eventually end up in. */ + BrigSegment8_t segment; + + /* The HSA kind of linkage. */ + BrigLinkage8_t linkage; + + /* Array dimension, if non-zero. */ + unsigned HOST_WIDE_INT dim; +}; + +/* Abstract class for HSA instruction operands. */ + +class hsa_op_base +{ +public: + + /* Next operand scheduled to be written when writing BRIG operand + section. */ + hsa_op_base *next; + + /* Offset to which the associated operand structure will be written. Zero if + yet not scheduled for writing. */ + unsigned brig_op_offset; + + /* The type of a particular operand. */ + BrigKind16_t kind; + +protected: + hsa_op_base (BrigKind16_t k); +private: + /* Make the default constructor inaccessible. */ + hsa_op_base () {} +}; + +/* Common abstract ancestor for operands which have a type. */ + +class hsa_op_with_type : public hsa_op_base +{ +public: + /* The type. */ + BrigType16_t type; + +protected: + hsa_op_with_type (BrigKind16_t k, BrigType16_t t); +private: + /* Make the default constructor inaccessible. */ + hsa_op_with_type () : hsa_op_base (BRIG_KIND_NONE) {} +}; + +/* An immediate HSA operand. */ + +class hsa_op_immed : public hsa_op_with_type +{ +public: + hsa_op_immed (tree tree_val); + void *operator new (size_t); + + /* Value as represented by middle end. */ + tree value; + +private: + /* Make the default constructor inaccessible. */ + hsa_op_immed () : hsa_op_with_type (BRIG_KIND_NONE, BRIG_TYPE_NONE) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a an immediate operand. */ + +template <> +template <> +inline bool +is_a_helper <hsa_op_immed *>::test (hsa_op_base *p) +{ + return p->kind == BRIG_KIND_OPERAND_CONSTANT_BYTES; +} + +/* HSA register operand. */ + +class hsa_op_reg : public hsa_op_with_type +{ +public: + hsa_op_reg (BrigType16_t t); + void *operator new (size_t); + + /* Verify register operand. */ + void verify (); + + /* If NON-NULL, gimple SSA that we come from. NULL if none. */ + tree gimple_ssa; + + /* Defining instruction while still in the SSA. */ + hsa_insn_basic *def_insn; + /* Uses of the value while still in SSA. */ + auto_vec <hsa_insn_basic_p> uses; + + /* If the register allocator decides to spill the register, this is the + appropriate spill symbol. */ + hsa_symbol *spill_sym; + + /* Number of this register structure in the order in which they were + allocated. */ + int order; + int lr_begin, lr_end; + + /* Zero if the register is not yet allocated. After, allocation, this must + be 'c', 's', 'd' or 'q'. */ + char reg_class; + /* If allocated, the number of the HW register (within its HSA register + class). */ + char hard_num; + +private: + /* Make the default constructor inaccessible. */ + hsa_op_reg () : hsa_op_with_type (BRIG_KIND_NONE, BRIG_TYPE_NONE) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +typedef class hsa_op_reg *hsa_op_reg_p; + +/* Report whether or not P is a register operand. */ + +template <> +template <> +inline bool +is_a_helper <hsa_op_reg *>::test (hsa_op_base *p) +{ + return p->kind == BRIG_KIND_OPERAND_REGISTER; +} + +/* An address HSA operand. */ + +class hsa_op_address : public hsa_op_base +{ +public: + hsa_op_address (hsa_symbol *sym, hsa_op_reg *reg, HOST_WIDE_INT offset); + void *operator new (size_t); + + /* Symbol base of the address. Can be NULL if there is none. */ + hsa_symbol *symbol; + + /* Register offset. Can be NULL if there is none. */ + hsa_op_reg *reg; + + /* Immediate byte offset. */ + HOST_WIDE_INT imm_offset; +private: + /* Make the default constructor inaccessible. */ + hsa_op_address () : hsa_op_base (BRIG_KIND_NONE) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is an address operand. */ + +template <> +template <> +inline bool +is_a_helper <hsa_op_address *>::test (hsa_op_base *p) +{ + return p->kind == BRIG_KIND_OPERAND_ADDRESS; +} + +/* A reference to code HSA operand. It can be either reference + to a start of a BB or a start of a function. */ + +class hsa_op_code_ref : public hsa_op_base +{ +public: + hsa_op_code_ref (); + + /* Offset in the code section that this refers to. */ + unsigned directive_offset; +}; + +/* Report whether or not P is a code reference operand. */ + +template <> +template <> +inline bool +is_a_helper <hsa_op_code_ref *>::test (hsa_op_base *p) +{ + return p->kind == BRIG_KIND_OPERAND_CODE_REF; +} + +/* Code list HSA operand. */ + +class hsa_op_code_list: public hsa_op_base +{ +public: + hsa_op_code_list (unsigned elements); + void *operator new (size_t); + + /* Offset to variable-sized array in hsa_data section, where + are offsets to entries in the hsa_code section. */ + auto_vec<unsigned> offsets; +private: + /* Make the default constructor inaccessible. */ + hsa_op_code_list () : hsa_op_base (BRIG_KIND_NONE) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a code list operand. */ + +template <> +template <> +inline bool +is_a_helper <hsa_op_code_list *>::test (hsa_op_base *p) +{ + return p->kind == BRIG_KIND_OPERAND_CODE_LIST; +} + +/* Opcodes of instructions that are not part of HSA but that we use to + represent it nevertheless. */ + +#define HSA_OPCODE_PHI (-1) +#define HSA_OPCODE_ARG_BLOCK (-2) + +/* The number of operand pointers we can directly in an instruction. */ +#define HSA_BRIG_INT_STORAGE_OPERANDS 5 + +/* Class representing an HSA instruction. Unlike typical ancestors for + specialized classes, this one is also directly used for all instructions + that are then represented as BrigInstBasic. */ + +class hsa_insn_basic +{ +public: + hsa_insn_basic (unsigned nops, int opc); + hsa_insn_basic (unsigned nops, int opc, BrigType16_t t); + void *operator new (size_t); + + /* The previous and next instruction in the basic block. */ + hsa_insn_basic *prev, *next; + + /* Basic block this instruction belongs to. */ + basic_block bb; + + /* Operand code distinguishing different types of instructions. Eventually + these should only be BRIG_INST_* values from the BrigOpcode16_t range but + initially we use negative values for PHI nodes and such. */ + int opcode; + + int number; /* FIXME: What is this for? */ + + /* Type of the destination of the operations. */ + BrigType16_t type; + + /* The individual operands. All instructions but PHI nodes have five or + fewer instructions and so will fit the internal storage. */ + /* TODO: Vast majority of instructions have three or fewer operands, so we + may actually try reducing it. */ + auto_vec<hsa_op_base *, HSA_BRIG_INT_STORAGE_OPERANDS> operands; +private: + /* Make the default constructor inaccessible. */ + hsa_insn_basic () {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Class representing a PHI node of the SSA form of HSA virtual + registers. */ + +class hsa_insn_phi : public hsa_insn_basic +{ +public: + hsa_insn_phi (unsigned nops); + void *operator new (size_t); + + /* Destination. */ + hsa_op_reg *dest; + +private: + /* Make the default constructor inaccessible. */ + hsa_insn_phi () : hsa_insn_basic (1, HSA_OPCODE_PHI) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a PHI node. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_phi *>::test (hsa_insn_basic *p) +{ + return p->opcode == HSA_OPCODE_PHI; +} + +/* HSA instruction for branches. Currently we explicitely represent only + conditional branches. */ + +class hsa_insn_br : public hsa_insn_basic +{ +public: + hsa_insn_br (hsa_op_reg *ctrl); + void *operator new (size_t); + + /* Width as described in HSA documentation. */ + BrigWidth8_t width; +private: + /* Make the default constructor inaccessible. */ + hsa_insn_br () : hsa_insn_basic (1, BRIG_OPCODE_CBR) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether P is a branching instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_br *>::test (hsa_insn_basic *p) +{ + return p->opcode == BRIG_OPCODE_BR + || p->opcode == BRIG_OPCODE_CBR; +} + +/* HSA instruction for comparisons. */ + +class hsa_insn_cmp : public hsa_insn_basic +{ +public: + hsa_insn_cmp (BrigCompareOperation8_t cmp, BrigType16_t t); + void *operator new (size_t); + + /* Source type should be derived from operand types. */ + + /* The comparison operation. */ + BrigCompareOperation8_t compare; + + /* TODO: Modifiers and packing control are missing but so are everywhere + else. */ +private: + /* Make the default constructor inaccessible. */ + hsa_insn_cmp () : hsa_insn_basic (1, BRIG_OPCODE_CMP) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a comparison instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_cmp *>::test (hsa_insn_basic *p) +{ + return p->opcode == BRIG_OPCODE_CMP; +} + +/* HSA instruction for memory operations. */ + +class hsa_insn_mem : public hsa_insn_basic +{ +public: + hsa_insn_mem (int opc, BrigType16_t t); + void *operator new (size_t); + + /* The segment is of the memory access is either the segment of the symbol in + the address operand or flat address is there is no symbol there. */ + + /* HSA equiv class, basically an alias set number. */ + uint8_t equiv_class; + + /* Things like acquire/release/aligned. */ + enum BrigMemoryOrder memoryorder; + + /* Scope of the atomic operation. */ + enum BrigMemoryScope memoryscope; + + /* TODO: Add width modifier, perhaps also other things. */ +protected: + hsa_insn_mem (unsigned nops, int opc, BrigType16_t t); + +private: + /* Make the default constructor inaccessible. */ + hsa_insn_mem () : hsa_insn_basic (1, BRIG_OPCODE_LD) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a memory instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_mem *>::test (hsa_insn_basic *p) +{ + return (p->opcode == BRIG_OPCODE_LD + || p->opcode == BRIG_OPCODE_ST); +} + +/* HSA instruction for atomic operations. */ + +class hsa_insn_atomic : public hsa_insn_mem +{ +public: + hsa_insn_atomic (int opc, enum BrigAtomicOperation aop, BrigType16_t t); + void *operator new (size_t); + + /* The operation itself. */ + enum BrigAtomicOperation atomicop; +private: + /* Make the default constructor inaccessible. */ + hsa_insn_atomic () : hsa_insn_mem (1, BRIG_KIND_NONE, BRIG_TYPE_NONE) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a memory instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_atomic *>::test (hsa_insn_basic *p) +{ + return (p->opcode == BRIG_OPCODE_ATOMIC + || p->opcode == BRIG_OPCODE_ATOMICNORET); +} + +/* HSA instruction to convert between flat addressing and segments. */ + +class hsa_insn_seg : public hsa_insn_basic +{ +public: + hsa_insn_seg (int opc, BrigType16_t destt, BrigType16_t srct, + BrigSegment8_t seg); + void *operator new (size_t); + + /* Source type. Depends on the source addressing/segment. */ + BrigType16_t src_type; + /* The segment we are converting from or to. */ + BrigSegment8_t segment; +private: + /* Make the default constructor inaccessible. */ + hsa_insn_seg () : hsa_insn_basic (1, BRIG_OPCODE_STOF) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a segment conversion instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_seg *>::test (hsa_insn_basic *p) +{ + return (p->opcode == BRIG_OPCODE_STOF + || p->opcode == BRIG_OPCODE_FTOS); +} + +/* HSA instruction for function call. */ + +class hsa_insn_call : public hsa_insn_basic +{ +public: + hsa_insn_call (tree callee); + void *operator new (size_t); + + /* Called function */ + tree called_function; + + /* Input formal arguments. */ + auto_vec <hsa_symbol *> input_args; + + /* Input arguments store instructions. */ + auto_vec <hsa_insn_mem *> input_arg_insns; + + /* Output argument, can be NULL for void functions. */ + hsa_symbol *output_arg; + + /* Called function code reference. */ + hsa_op_code_ref func; + + /* Argument symbols. */ + auto_vec <hsa_symbol *> args_symbols; + + /* Code list for arguments of the function. */ + hsa_op_code_list *args_code_list; + + /* Result symbol. */ + hsa_symbol *result_symbol; + + /* Code list for result of the function. */ + hsa_op_code_list *result_code_list; +private: + /* Make the default constructor inaccessible. */ + hsa_insn_call () : hsa_insn_basic (0, BRIG_OPCODE_CALL) {} + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a call instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_call *>::test (hsa_insn_basic *p) +{ + return (p->opcode == BRIG_OPCODE_CALL); +} + +/* HSA call instruction block encapsulates definition of arguments, + result type, corresponding loads and a possible store. + Moreover, it contains a single call instruction. + Emission of the instruction will produce multiple + HSAIL instructions. */ + +class hsa_insn_arg_block : public hsa_insn_basic +{ +public: + hsa_insn_arg_block (BrigKind brig_kind, hsa_insn_call * call); + void *operator new (size_t); + + /* Kind of argument block. */ + BrigKind kind; + + /* Call instruction. */ + hsa_insn_call *call_insn; +private: + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Report whether or not P is a call block instruction. */ + +template <> +template <> +inline bool +is_a_helper <hsa_insn_arg_block *>::test (hsa_insn_basic *p) +{ + return (p->opcode == HSA_OPCODE_ARG_BLOCK); +} + +/* Basic block of HSA instructions. */ + +class hsa_bb +{ +public: + hsa_bb (basic_block cfg_bb); + hsa_bb (basic_block cfg_bb, int idx); + ~hsa_bb (); + void *operator new (size_t); + + /* The real CFG BB that this HBB belongs to. */ + basic_block bb; + + /* The operand that refers to the label to this BB. */ + hsa_op_code_ref label_ref; + + /* The first and last instruction. */ + hsa_insn_basic *first_insn, *last_insn; + /* The first and last phi node. */ + hsa_insn_phi *first_phi, *last_phi; + + /* Just a number to construct names from. */ + int index; + + bitmap liveout, livein; +private: + /* Make the default constructor inaccessible. */ + hsa_bb (); + /* All objects are deallocated by destroying their pool, so make delete + inaccessible too. */ + void operator delete (void *) {} +}; + +/* Return the corresponding HSA basic block structure for the given control + flow basic_block BB. */ + +static inline hsa_bb * +hsa_bb_for_bb (basic_block bb) +{ + return (struct hsa_bb *) bb->aux; +} + +/* Class for hashing local hsa_symbols. */ + - struct hsa_noop_symbol_hasher : typed_noop_remove <hsa_symbol> ++struct hsa_noop_symbol_hasher : nofree_ptr_hash <hsa_symbol> +{ - typedef hsa_symbol *value_type; - typedef hsa_symbol *compare_type; + static inline hashval_t hash (const value_type); + static inline bool equal (const value_type, const compare_type); +}; + +/* Hash hsa_symbol. */ + +inline hashval_t +hsa_noop_symbol_hasher::hash (const value_type item) +{ + return DECL_UID (item->decl); +} + +/* Return true if the DECL_UIDs of decls both symbols refer to are equal. */ + +inline bool +hsa_noop_symbol_hasher::equal (const value_type a, const compare_type b) +{ + return (DECL_UID (a->decl) == DECL_UID (b->decl)); +} + +/* Class for hashing global hsa_symbols. */ + - struct hsa_free_symbol_hasher : typed_free_remove <hsa_symbol> ++struct hsa_free_symbol_hasher : free_ptr_hash <hsa_symbol> +{ - typedef hsa_symbol *value_type; - typedef hsa_symbol *compare_type; + static inline hashval_t hash (const value_type); + static inline bool equal (const value_type, const compare_type); +}; + +/* Hash hsa_symbol. */ + +inline hashval_t +hsa_free_symbol_hasher::hash (const value_type item) +{ + return DECL_UID (item->decl); +} + +/* Return true if the DECL_UIDs of decls both symbols refer to are equal. */ + +inline bool +hsa_free_symbol_hasher::equal (const value_type a, const compare_type b) +{ + return (DECL_UID (a->decl) == DECL_UID (b->decl)); +} + +/* Structure that encapsulates intermediate representation of a HSA + function. */ + +class hsa_function_representation +{ +public: + hsa_function_representation (); + ~hsa_function_representation (); + + /* Name of the function. */ + char *name; + + /* Input arguments of the function. */ + /* FIXME: Normally we'd use a vector, however our C++ vectors seem to have + problems with derived classes, so for now we'll use a simple array. */ + unsigned input_args_count; + + /* Number of allocated register structures. */ + int reg_count; + + struct hsa_symbol *input_args; + /* Output argument or NULL if there is none. */ + struct hsa_symbol *output_arg; + /* Hash table of local variable symbols. */ + hash_table <hsa_noop_symbol_hasher> *local_symbols; + /* Vector of pointers to spill symbols. */ + vec <struct hsa_symbol *> spill_symbols; + + /* Vector of called function declarations. */ + vec <tree> called_functions; + + /* Instructions to be executed before the first BB from gimple. It's label + is zero and must not be referenced, of course there are no PHIs. */ + hsa_bb prologue; + + /* Number of HBB BBs. */ + int hbb_count; + + /* Whether or not we could check and enforce SSA properties. */ + bool in_ssa; + + /* True if the function is kernel function. */ + bool kern_p; + + /* True if the function representation is a declaration. */ + bool declaration_p; + + /* Function declaration tree. */ + tree decl; +}; + +/* in hsa.c */ +extern struct hsa_function_representation *hsa_cfun; +extern hash_table <hsa_free_symbol_hasher> *hsa_global_variable_symbols; +void hsa_init_compilation_unit_data (void); +void hsa_deinit_compilation_unit_data (void); +bool hsa_machine_large_p (void); +bool hsa_full_profile_p (void); +bool hsa_opcode_op_output_p (BrigOpcode16_t, int); +unsigned hsa_type_bit_size (BrigType16_t t); +BrigType16_t hsa_bittype_for_type (BrigType16_t t); +bool hsa_type_float_p (BrigType16_t type); +void hsa_destroy_insn (hsa_insn_basic *insn); +void hsa_add_kern_decl_mapping (tree decl, char *name); +unsigned hsa_get_number_decl_kernel_mappings (void); +tree hsa_get_decl_kernel_mapping_decl (unsigned i); +char *hsa_get_decl_kernel_mapping_name (unsigned i); +void hsa_free_decl_kernel_mapping (void); +void hsa_sanitize_name (char *p); +const char *get_declaration_name (tree decl); + +/* In hsa-gen.c. */ +void hsa_build_append_simple_mov (hsa_op_reg *, hsa_op_base *, hsa_bb *); +hsa_symbol *hsa_get_spill_symbol (BrigType16_t); +hsa_op_reg *hsa_spill_in (hsa_insn_basic *, hsa_op_reg *, hsa_op_reg **); +hsa_op_reg *hsa_spill_out (hsa_insn_basic *, hsa_op_reg *, hsa_op_reg **); +hsa_bb *hsa_init_new_bb (basic_block); +hsa_function_representation *hsa_generate_function_declaration (tree decl); + +/* In hsa-regalloc.c. */ +void hsa_regalloc (void); + +/* In hsa-brig.c. */ +void hsa_brig_emit_function (void); +void hsa_output_brig (void); +BrigType16_t bittype_for_type (BrigType16_t t); + +/* In hsa-dump.c. */ +const char *hsa_seg_name (BrigSegment8_t); +void dump_hsa_bb (FILE *, hsa_bb *); +void dump_hsa_cfun (FILE *); + +#endif /* HSA_H */

-----------------------------------------------------------------------

Summary of changes: ChangeLog | 15 + MAINTAINERS | 4 +- config/ChangeLog | 5 + config/dfp.m4 | 2 +- configure | 2 +- configure.ac | 2 +- gcc/ChangeLog | 2972 ++- gcc/DATESTAMP | 2 +- gcc/Makefile.in | 14 +- gcc/ada/ChangeLog | 146 + gcc/ada/gcc-interface/cuintp.c | 1 - gcc/ada/gcc-interface/decl.c | 158 +- gcc/ada/gcc-interface/gigi.h | 129 +- gcc/ada/gcc-interface/misc.c | 11 +- gcc/ada/gcc-interface/targtyps.c | 1 - gcc/ada/gcc-interface/trans.c | 210 +- gcc/ada/gcc-interface/utils.c | 345 +- gcc/ada/gcc-interface/utils2.c | 1 - gcc/ada/s-oscons-tmplt.c | 7 +- gcc/alias.c | 54 +- gcc/alias.h | 8 - gcc/asan.c | 10 +- gcc/attribs.c | 12 +- gcc/auto-inc-dec.c | 35 +- gcc/auto-profile.c | 5 - gcc/bb-reorder.c | 12 +- gcc/bitmap.c | 2 +- gcc/bt-load.c | 1 - gcc/builtins.c | 139 +- gcc/builtins.def | 4 +- gcc/c-family/ChangeLog | 135 + gcc/c-family/array-notation-common.c | 5 +- gcc/c-family/c-ada-spec.c | 21 +- gcc/c-family/c-ada-spec.h | 1 + gcc/c-family/c-cilkplus.c | 1 - gcc/c-family/c-common.c | 196 +- gcc/c-family/c-common.h | 14 +- gcc/c-family/c-cppbuiltin.c | 1 - gcc/c-family/c-dump.c | 1 - gcc/c-family/c-format.c | 5 +- gcc/c-family/c-gimplify.c | 9 +- gcc/c-family/c-indentation.c | 2 - gcc/c-family/c-lex.c | 8 +- gcc/c-family/c-omp.c | 9 +- gcc/c-family/c-opts.c | 7 +- gcc/c-family/c-pch.c | 1 - gcc/c-family/c-ppoutput.c | 1 - gcc/c-family/c-pragma.c | 9 +- gcc/c-family/c-pretty-print.c | 5 +- gcc/c-family/c-semantics.c | 1 - gcc/c-family/c-ubsan.c | 8 +- gcc/c-family/cilk.c | 15 +- gcc/c-family/stub-objc.c | 1 - gcc/c/ChangeLog | 63 + gcc/c/c-array-notation.c | 5 +- gcc/c/c-aux-info.c | 1 - gcc/c/c-convert.c | 1 - gcc/c/c-decl.c | 72 +- gcc/c/c-errors.c | 1 - gcc/c/c-lang.c | 1 - gcc/c/c-objc-common.c | 3 +- gcc/c/c-parser.c | 11 +- gcc/c/c-typeck.c | 91 +- gcc/caller-save.c | 1 - gcc/calls.c | 59 +- gcc/calls.h | 5 + gcc/ccmp.c | 2 - gcc/cfg.c | 6 +- gcc/cfganal.c | 1 - gcc/cfgbuild.c | 1 - gcc/cfgcleanup.c | 1 - gcc/cfgexpand.c | 136 +- gcc/cfghooks.c | 2 - gcc/cfgloop.c | 2 - gcc/cfgloop.h | 5 +- gcc/cfgloopanal.c | 1 - gcc/cfgloopmanip.c | 2 - gcc/cfgrtl.c | 21 +- gcc/cgraph.c | 34 +- gcc/cgraph.h | 81 +- gcc/cgraphbuild.c | 5 - gcc/cgraphclones.c | 5 - gcc/cgraphunit.c | 9 - gcc/cilk-common.c | 1 - gcc/collect-utils.c | 14 +- gcc/combine-stack-adj.c | 1 - gcc/combine.c | 19 +- gcc/common.opt | 11 +- gcc/common/common-target.h | 1 - gcc/common/common-targhooks.c | 1 - gcc/common/config/i386/i386-common.c | 16 +- gcc/compare-elim.c | 1 - gcc/config.gcc | 13 +- gcc/config.in | 6 + gcc/config/aarch64/aarch64-arches.def | 1 + gcc/config/aarch64/aarch64-builtins.c | 2 - gcc/config/aarch64/aarch64-cores.def | 10 +- gcc/config/aarch64/aarch64-fusion-pairs.def | 38 + gcc/config/aarch64/aarch64-option-extensions.def | 10 +- gcc/config/aarch64/aarch64-opts.h | 3 + gcc/config/aarch64/aarch64-protos.h | 93 +- ...aarch64-arches.def => aarch64-tuning-flags.def} | 21 +- gcc/config/aarch64/aarch64.c | 508 +- gcc/config/aarch64/aarch64.h | 19 +- gcc/config/aarch64/aarch64.md | 110 +- gcc/config/aarch64/aarch64.opt | 4 + gcc/config/aarch64/cortex-a57-fma-steering.c | 24 +- gcc/config/aarch64/iterators.md | 4 + gcc/config/aarch64/t-aarch64 | 3 +- gcc/config/alpha/alpha.c | 20 +- gcc/config/arc/arc.c | 1 - gcc/config/arm/aarch-common.c | 1 - gcc/config/arm/arm-builtins.c | 1 - gcc/config/arm/arm-c.c | 2 - gcc/config/arm/arm-protos.h | 7 +- gcc/config/arm/arm.c | 206 +- gcc/config/arm/arm.md | 36 + gcc/config/arm/arm.opt | 4 + gcc/config/arm/elf.h | 1 - gcc/config/arm/linux-elf.h | 2 +- gcc/config/avr/avr-c.c | 1 - gcc/config/avr/avr-log.c | 2 - gcc/config/avr/avr.c | 5 +- gcc/config/bfin/bfin.c | 28 +- gcc/config/c6x/c6x.c | 17 +- gcc/config/cr16/cr16.c | 5 +- gcc/config/cris/cris.c | 8 +- gcc/config/cris/cris.md | 6 +- gcc/config/darwin-c.c | 5 - gcc/config/darwin.c | 8 +- gcc/config/default-c.c | 1 - gcc/config/epiphany/epiphany.c | 1 - gcc/config/epiphany/mode-switch-use.c | 1 - gcc/config/epiphany/resolve-sw-modes.c | 1 - gcc/config/fr30/fr30.c | 5 +- gcc/config/frv/frv.c | 5 +- gcc/config/ft32/ft32.c | 10 +- gcc/config/ft32/ft32.h | 2 +- gcc/config/glibc-c.c | 1 - gcc/config/gnu-user.h | 9 + gcc/config/h8300/h8300.c | 11 +- gcc/config/i386/constraints.md | 5 + gcc/config/i386/i386-c.c | 14 +- gcc/config/i386/i386.c | 453 +- gcc/config/i386/i386.h | 6 +- gcc/config/i386/i386.md | 707 +- gcc/config/i386/i386.opt | 4 + gcc/config/i386/ia32intrin.h | 16 +- .../stdnoreturn.h => config/i386/iamcu.h} | 23 +- gcc/config/i386/msformat-c.c | 1 - gcc/config/i386/predicates.md | 99 +- gcc/config/i386/sse.md | 152 +- gcc/config/i386/winnt-cxx.c | 1 - gcc/config/i386/winnt-stubs.c | 1 - gcc/config/i386/winnt.c | 35 +- gcc/config/i386/x86-tune.def | 36 +- gcc/config/i386/x86intrin.h | 5 + gcc/config/ia64/ia64-c.c | 1 - gcc/config/ia64/ia64.c | 10 +- gcc/config/iq2000/iq2000.c | 8 +- gcc/config/lm32/lm32.c | 5 +- gcc/config/m32c/m32c-pragma.c | 1 - gcc/config/m32c/m32c.c | 25 +- gcc/config/m32r/m32r.c | 8 +- gcc/config/m68k/m68k.c | 5 +- gcc/config/mcore/mcore.c | 5 +- gcc/config/mep/mep-pragma.c | 2 - gcc/config/mep/mep.c | 22 +- gcc/config/microblaze/microblaze-c.c | 1 - gcc/config/microblaze/microblaze.c | 8 +- gcc/config/mips/mips.c | 128 +- gcc/config/mips/mips.h | 26 +- gcc/config/mips/mips.md | 272 +- gcc/config/mips/mips.opt | 4 - gcc/config/mips/mti-linux.h | 25 +- gcc/config/mips/t-img-linux | 18 +- gcc/config/mips/t-mti-linux | 156 +- gcc/config/mmix/mmix.c | 5 +- gcc/config/mn10300/mn10300.c | 5 +- gcc/config/moxie/moxie.c | 5 +- gcc/config/msp430/msp430-c.c | 1 - gcc/config/msp430/msp430.c | 5 +- gcc/config/msp430/msp430.md | 4 +- gcc/config/nds32/nds32-cost.c | 2 - gcc/config/nds32/nds32-fp-as-gp.c | 2 - gcc/config/nds32/nds32-intrinsic.c | 2 - gcc/config/nds32/nds32-isr.c | 2 - gcc/config/nds32/nds32-md-auxiliary.c | 2 - gcc/config/nds32/nds32-memory-manipulation.c | 2 - gcc/config/nds32/nds32-pipelines-auxiliary.c | 2 - gcc/config/nds32/nds32-predicates.c | 2 - gcc/config/nds32/nds32.c | 5 +- gcc/config/nios2/constraints.md | 3 +- gcc/config/nios2/nios2-protos.h | 4 +- gcc/config/nios2/nios2.c | 48 +- gcc/config/nvptx/nvptx.c | 52 +- gcc/config/nvptx/nvptx.md | 77 +- gcc/config/pa/pa.c | 5 +- gcc/config/pa/pa.md | 4 +- gcc/config/pdp11/pdp11.c | 5 +- gcc/config/rl78/rl78-c.c | 1 - gcc/config/rl78/rl78.c | 5 +- gcc/config/rs6000/altivec.md | 115 +- gcc/config/rs6000/predicates.md | 10 +- gcc/config/rs6000/rs6000-builtin.def | 18 + gcc/config/rs6000/rs6000-c.c | 41 +- gcc/config/rs6000/rs6000.c | 12 +- gcc/config/rs6000/rs6000.h | 4 - gcc/config/rs6000/rs6000.md | 26 +- gcc/config/rs6000/vector.md | 57 +- gcc/config/rx/rx.c | 8 +- gcc/config/s390/s390-builtin-types.def | 585 +- gcc/config/s390/s390-builtins.def | 1231 +- gcc/config/s390/s390-builtins.h | 37 +- gcc/config/s390/s390-c.c | 12 +- gcc/config/s390/s390.c | 251 +- gcc/config/s390/tpf.h | 9 +- gcc/config/s390/vecintrin.h | 35 - gcc/config/s390/vx-builtins.md | 4 +- gcc/config/sh/sh-c.c | 1 - gcc/config/sh/sh-mem.cc | 1 - gcc/config/sh/sh.c | 33 +- gcc/config/sh/sh.md | 68 +- gcc/config/sh/sh_optimize_sett_clrt.cc | 1 - gcc/config/sh/sh_treg_combine.cc | 1 - gcc/config/sol2-c.c | 1 - gcc/config/sol2-cxx.c | 1 - gcc/config/sol2-stubs.c | 1 - gcc/config/sol2.c | 5 +- gcc/config/sparc/leon.md | 8 +- gcc/config/sparc/sparc-c.c | 1 - gcc/config/sparc/sparc.c | 6 +- gcc/config/spu/spu-c.c | 1 - gcc/config/spu/spu.c | 6 +- gcc/config/stormy16/stormy16.c | 6 +- gcc/config/tilegx/mul-tables.c | 10 + gcc/config/tilegx/tilegx-c.c | 1 - gcc/config/tilegx/tilegx.c | 6 +- gcc/config/tilepro/mul-tables.c | 1 - gcc/config/tilepro/tilepro-c.c | 1 - gcc/config/tilepro/tilepro.c | 6 +- gcc/config/v850/v850-c.c | 1 - gcc/config/v850/v850.c | 5 +- gcc/config/vax/vax.c | 5 +- gcc/config/vax/vax.md | 6 +- gcc/config/visium/visium.c | 5 +- gcc/config/vms/vms-c.c | 1 - gcc/config/vms/vms.c | 1 - gcc/config/vxworks.c | 1 - gcc/config/winnt-c.c | 1 - gcc/config/xtensa/xtensa.c | 5 +- gcc/configure | 76 +- gcc/configure.ac | 18 +- gcc/convert.c | 1 - gcc/coretypes.h | 9 + gcc/coverage.c | 8 +- gcc/cp/ChangeLog | 426 + gcc/cp/call.c | 45 +- gcc/cp/class.c | 35 +- gcc/cp/constexpr.c | 40 +- gcc/cp/cp-array-notation.c | 5 +- gcc/cp/cp-gimplify.c | 11 +- gcc/cp/cp-lang.c | 3 +- gcc/cp/cp-objcp-common.c | 1 - gcc/cp/cp-tree.h | 36 +- gcc/cp/cp-ubsan.c | 5 +- gcc/cp/cvt.c | 3 +- gcc/cp/decl.c | 151 +- gcc/cp/decl2.c | 58 +- gcc/cp/dump.c | 1 - gcc/cp/error.c | 5 +- gcc/cp/except.c | 1 - gcc/cp/expr.c | 1 - gcc/cp/friend.c | 1 - gcc/cp/init.c | 53 +- gcc/cp/lambda.c | 5 - gcc/cp/lang-specs.h | 5 +- gcc/cp/lex.c | 7 +- gcc/cp/mangle.c | 19 +- gcc/cp/method.c | 7 +- gcc/cp/name-lookup.c | 3 +- gcc/cp/optimize.c | 5 - gcc/cp/parser.c | 106 +- gcc/cp/pt.c | 216 +- gcc/cp/ptree.c | 1 - gcc/cp/repo.c | 2 - gcc/cp/rtti.c | 1 - gcc/cp/search.c | 1 - gcc/cp/semantics.c | 56 +- gcc/cp/tree.c | 65 +- gcc/cp/typeck.c | 36 +- gcc/cp/typeck2.c | 13 +- gcc/cp/vtable-class-hierarchy.c | 10 +- gcc/cppbuiltin.c | 1 - gcc/cprop.c | 1 - gcc/cse.c | 4 +- gcc/cselib.c | 5 +- gcc/data-streamer-in.c | 5 - gcc/data-streamer-out.c | 5 - gcc/data-streamer.c | 5 - gcc/dbxout.c | 4 - gcc/dce.c | 1 - gcc/ddg.c | 1 - gcc/debug.c | 1 - gcc/defaults.h | 90 - gcc/df-core.c | 7 +- gcc/df-problems.c | 1 - gcc/df-scan.c | 28 +- gcc/df.h | 1 - gcc/dfp.c | 1 - gcc/diagnostic-core.h | 1 - gcc/diagnostic.c | 1 - gcc/doc/extend.texi | 78 + gcc/doc/fragments.texi | 2 +- gcc/doc/install.texi | 2 +- gcc/doc/invoke.texi | 137 +- gcc/doc/sourcebuild.texi | 19 + gcc/dojump.c | 10 +- gcc/dominance.c | 20 +- gcc/domwalk.c | 1 - gcc/double-int.c | 1 - gcc/dse.c | 6 +- gcc/dumpfile.c | 1 - gcc/dumpfile.h | 1 - gcc/dwarf2asm.c | 1 - gcc/dwarf2cfi.c | 10 +- gcc/dwarf2out.c | 53 +- gcc/emit-rtl.c | 21 +- gcc/emit-rtl.h | 288 + gcc/et-forest.c | 1 - gcc/except.c | 39 +- gcc/explow.c | 78 +- gcc/expmed.c | 15 +- gcc/expr.c | 88 +- gcc/expr.h | 1 - gcc/final.c | 16 +- gcc/fixed-value.c | 1 - gcc/fold-const.c | 934 +- gcc/fortran/ChangeLog | 200 +- gcc/fortran/arith.c | 24 +- gcc/fortran/convert.c | 1 - gcc/fortran/cpp.c | 1 - gcc/fortran/decl.c | 239 +- gcc/fortran/error.c | 7 +- gcc/fortran/f95-lang.c | 5 - gcc/fortran/gfortran.h | 44 +- gcc/fortran/interface.c | 24 +- gcc/fortran/invoke.texi | 9 +- gcc/fortran/io.c | 122 +- gcc/fortran/iresolve.c | 1 - gcc/fortran/lang.opt | 4 + gcc/fortran/match.c | 6 +- gcc/fortran/match.h | 2 + gcc/fortran/module.c | 76 +- gcc/fortran/options.c | 1 - gcc/fortran/parse.c | 200 +- gcc/fortran/parse.h | 6 +- gcc/fortran/primary.c | 10 +- gcc/fortran/resolve.c | 269 +- gcc/fortran/symbol.c | 53 +- gcc/fortran/target-memory.c | 1 - gcc/fortran/trans-array.c | 1 - gcc/fortran/trans-common.c | 5 +- gcc/fortran/trans-const.c | 1 - gcc/fortran/trans-decl.c | 65 +- gcc/fortran/trans-expr.c | 24 +- gcc/fortran/trans-intrinsic.c | 1 - gcc/fortran/trans-io.c | 1 - gcc/fortran/trans-openmp.c | 1 - gcc/fortran/trans-stmt.c | 1 - gcc/fortran/trans-types.c | 1 - gcc/fortran/trans.c | 1 - gcc/fortran/trans.h | 5 +- gcc/function.c | 164 +- gcc/function.h | 300 +- gcc/fwprop.c | 1 - gcc/gcc-plugin.h | 2 - gcc/gcc.c | 15 +- gcc/gcse.c | 4 +- gcc/genattrtab.c | 7 +- gcc/genconditions.c | 1 + gcc/genemit.c | 20 +- gcc/generic-match-head.c | 2 - gcc/gengtype-parse.c | 10 +- gcc/genmatch.c | 178 +- gcc/genpreds.c | 1 + gcc/genrecog.c | 5 +- gcc/gensupport.c | 6 +- gcc/gentarget-def.c | 272 + gcc/ggc-common.c | 3 +- gcc/ggc-page.c | 5 - gcc/gimple-builder.c | 3 - gcc/gimple-expr.c | 3 - gcc/gimple-fold.c | 4 - gcc/gimple-iterator.c | 5 - gcc/gimple-low.c | 3 - gcc/gimple-match-head.c | 20 +- gcc/gimple-pretty-print.c | 5 - gcc/gimple-ssa-isolate-paths.c | 3 - gcc/gimple-ssa-strength-reduction.c | 6 +- gcc/gimple-ssa.h | 4 +- gcc/gimple-streamer-in.c | 5 - gcc/gimple-streamer-out.c | 5 - gcc/gimple-streamer.h | 1 - gcc/gimple-walk.c | 2 - gcc/gimple.c | 4 - gcc/gimple.h | 4 +- gcc/gimplify-me.c | 3 - gcc/gimplify.c | 8 +- gcc/go/ChangeLog | 11 + gcc/go/go-backend.c | 1 - gcc/go/go-gcc.cc | 5 - gcc/go/go-lang.c | 2 - gcc/go/go-system.h | 1 - gcc/go/gofrontend/MERGE | 4 + gcc/go/gofrontend/ast-dump.cc | 8 +- gcc/go/gofrontend/escape.cc | 49 +- gcc/godump.c | 1 - gcc/graph.c | 1 - gcc/graphite-blocking.c | 6 +- gcc/graphite-dependences.c | 6 +- gcc/graphite-interchange.c | 6 +- gcc/graphite-isl-ast-to-gimple.c | 6 +- gcc/graphite-optimize-isl.c | 6 +- gcc/graphite-poly.c | 6 +- gcc/graphite-scop-detection.c | 6 +- gcc/graphite-sese-to-poly.c | 5 +- gcc/graphite.c | 6 +- gcc/haifa-sched.c | 12 +- gcc/hard-reg-set.h | 3 +- gcc/hash-map-traits.h | 191 +- gcc/hash-map.h | 9 +- gcc/hash-set.h | 172 +- gcc/hash-table.c | 3 + gcc/hash-table.h | 390 +- gcc/hash-traits.h | 286 + gcc/hsa-brig.c | 4 +- gcc/hsa.h | 8 +- gcc/hw-doloop.c | 4 - gcc/hwint.c | 2 +- gcc/ifcvt.c | 23 +- gcc/init-regs.c | 1 - gcc/input.c | 1 - gcc/internal-fn.c | 42 +- gcc/ipa-chkp.c | 27 +- gcc/ipa-comdats.c | 5 - gcc/ipa-cp.c | 5 - gcc/ipa-devirt.c | 34 +- gcc/ipa-icf-gimple.c | 4 - gcc/ipa-icf.c | 134 +- gcc/ipa-icf.h | 26 +- gcc/ipa-inline-analysis.c | 5 - gcc/ipa-inline-transform.c | 5 - gcc/ipa-inline.c | 5 - gcc/ipa-polymorphic-call.c | 24 +- gcc/ipa-profile.c | 9 +- gcc/ipa-prop.c | 4 - gcc/ipa-pure-const.c | 5 - gcc/ipa-ref.c | 5 - gcc/ipa-reference.c | 5 - gcc/ipa-split.c | 4 - gcc/ipa-utils.c | 5 - gcc/ipa-visibility.c | 5 - gcc/ipa.c | 5 - gcc/ira-build.c | 1 - gcc/ira-color.c | 30 +- gcc/ira-conflicts.c | 1 - gcc/ira-costs.c | 5 +- gcc/ira-emit.c | 1 - gcc/ira-lives.c | 1 - gcc/ira.c | 3 +- gcc/java/ChangeLog | 45 + gcc/java/boehm.c | 1 - gcc/java/builtins.c | 1 - gcc/java/class.c | 5 - gcc/java/constants.c | 1 - gcc/java/decl.c | 5 - gcc/java/except.c | 1 - gcc/java/expr.c | 1 - gcc/java/java-gimplify.c | 3 - gcc/java/java-tree.h | 6 +- gcc/java/jcf-dump.c | 1 - gcc/java/jcf-io.c | 31 +- gcc/java/jcf-parse.c | 5 - gcc/java/jvgenmain.c | 1 - gcc/java/lang.c | 2 - gcc/java/mangle.c | 1 - gcc/java/mangle_name.c | 1 - gcc/java/resource.c | 5 - gcc/java/typeck.c | 1 - gcc/java/verify-glue.c | 1 - gcc/java/verify-impl.c | 1 - gcc/jit/ChangeLog | 277 + gcc/jit/docs/_build/texinfo/libgccjit.texi | 1651 +- gcc/jit/docs/cp/topics/contexts.rst | 36 + gcc/jit/docs/cp/topics/expressions.rst | 2 +- gcc/jit/docs/cp/topics/functions.rst | 84 +- gcc/jit/docs/cp/topics/objects.rst | 1 + gcc/jit/docs/topics/compatibility.rst | 109 + gcc/jit/docs/topics/contexts.rst | 69 +- gcc/jit/docs/topics/expressions.rst | 7 + gcc/jit/docs/topics/functions.rst | 130 +- gcc/jit/docs/topics/index.rst | 1 + gcc/jit/docs/topics/locations.rst | 4 + gcc/jit/docs/topics/objects.rst | 1 + gcc/jit/docs/topics/types.rst | 31 + gcc/jit/dummy-frontend.c | 3 - gcc/jit/jit-common.h | 14 +- gcc/jit/jit-playback.c | 124 +- gcc/jit/jit-playback.h | 21 + gcc/jit/jit-recording.c | 574 +- gcc/jit/jit-recording.h | 155 +- gcc/jit/libgccjit++.h | 79 + gcc/jit/libgccjit.c | 435 + gcc/jit/libgccjit.h | 133 + gcc/jit/libgccjit.map | 25 +- gcc/jump.c | 1 - gcc/langhooks.c | 5 - gcc/lcm.c | 1 - gcc/libfuncs.h | 2 +- gcc/loop-doloop.c | 52 +- gcc/loop-init.c | 19 +- gcc/loop-invariant.c | 5 +- gcc/loop-iv.c | 14 +- gcc/loop-unroll.c | 9 +- gcc/lower-subreg.c | 1 - gcc/lra-assigns.c | 1 - gcc/lra-coalesce.c | 1 - gcc/lra-constraints.c | 18 +- gcc/lra-eliminations.c | 1 - gcc/lra-int.h | 4 +- gcc/lra-lives.c | 27 +- gcc/lra-remat.c | 1 - gcc/lra-spills.c | 1 - gcc/lra.c | 47 +- gcc/lto-cgraph.c | 4 - gcc/lto-compress.c | 5 - gcc/lto-opts.c | 5 - gcc/lto-section-in.c | 4 - gcc/lto-section-out.c | 4 - gcc/lto-streamer-in.c | 4 - gcc/lto-streamer-out.c | 133 +- gcc/lto-streamer.c | 9 +- gcc/lto-streamer.h | 8 +- gcc/lto/ChangeLog | 22 + gcc/lto/lto-lang.c | 5 - gcc/lto/lto-object.c | 5 - gcc/lto/lto-partition.c | 5 - gcc/lto/lto-symtab.c | 5 - gcc/lto/lto-tree.h | 2 - gcc/lto/lto.c | 9 +- gcc/match.pd | 648 +- gcc/mcf.c | 1 - gcc/mem-stats.h | 13 +- gcc/mode-switching.c | 1 - gcc/modulo-sched.c | 14 +- gcc/objc/ChangeLog | 25 + gcc/objc/objc-act.c | 11 +- gcc/objc/objc-encoding.c | 1 - gcc/objc/objc-gnu-runtime-abi-01.c | 1 - gcc/objc/objc-lang.c | 1 - gcc/objc/objc-map.c | 1 - gcc/objc/objc-next-runtime-abi-01.c | 1 - gcc/objc/objc-next-runtime-abi-02.c | 1 - gcc/objc/objc-runtime-shared-support.c | 1 - gcc/objcp/ChangeLog | 5 + gcc/objcp/objcp-decl.c | 1 - gcc/objcp/objcp-lang.c | 1 - gcc/omega.c | 7 +- gcc/omp-low.c | 113 +- gcc/optabs.c | 56 +- gcc/opts-global.c | 5 - gcc/opts.h | 1 - gcc/passes.c | 35 +- gcc/passes.def | 2 + gcc/plugin.c | 5 +- gcc/po/ChangeLog | 12 + gcc/po/gcc.pot | 20742 ++++++++++--------- gcc/po/sv.po | 2603 +-- gcc/postreload-gcse.c | 5 +- gcc/postreload.c | 1 - gcc/predict.c | 4 - gcc/pretty-print.h | 1 - gcc/print-rtl.c | 2 - gcc/print-tree.c | 6 +- gcc/profile.c | 4 - gcc/read-md.c | 4 +- gcc/real.c | 1 - gcc/realmpfr.c | 1 - gcc/recog.c | 18 +- gcc/ree.c | 4 - gcc/reg-stack.c | 2 - gcc/regcprop.c | 2 +- gcc/reginfo.c | 1 - gcc/regrename.c | 41 +- gcc/regrename.h | 2 +- gcc/regstat.c | 1 - gcc/reload.c | 7 +- gcc/reload1.c | 7 +- gcc/reorg.c | 12 +- gcc/resource.c | 2 +- gcc/rtl-chkp.c | 2 - gcc/rtl-error.c | 1 - gcc/rtl.c | 5 + gcc/rtl.h | 24 +- gcc/rtlanal.c | 257 +- gcc/rtlhooks.c | 1 - gcc/sanopt.c | 51 +- gcc/sched-deps.c | 2 - gcc/sched-ebb.c | 1 - gcc/sched-rgn.c | 2 +- gcc/sched-vis.c | 2 - gcc/sdbout.c | 1 - gcc/sel-sched-dump.c | 1 - gcc/sel-sched-ir.c | 49 +- gcc/sel-sched.c | 1 - gcc/sese.c | 22 +- gcc/shrink-wrap.c | 7 +- gcc/shrink-wrap.h | 3 +- gcc/simplify-rtx.c | 110 +- gcc/stack-ptr-mod.c | 1 - gcc/statistics.c | 5 +- gcc/stmt.c | 12 +- gcc/stor-layout.c | 4 - gcc/store-motion.c | 5 +- gcc/streamer-hooks.c | 1 - gcc/stringpool.c | 1 - gcc/symbol-summary.h | 44 +- gcc/symtab.c | 5 - gcc/target-def.h | 1 + gcc/target-globals.c | 1 - gcc/target-insns.def | 76 + gcc/target.def | 18 + gcc/targhooks.c | 8 +- gcc/testsuite/ChangeLog | 915 +- gcc/testsuite/c-c++-common/Wlogical-op-3.c | 22 + gcc/testsuite/c-c++-common/gomp/pr66429.c | 41 + gcc/testsuite/c-c++-common/pr60439.c | 96 +- gcc/testsuite/c-c++-common/pr66322.c | 144 + gcc/testsuite/c-c++-common/ubsan/overflow-add-5.c | 30 + gcc/testsuite/g++.dg/abi/anon2.C | 4 +- gcc/testsuite/g++.dg/abi/macro0.C | 2 +- gcc/testsuite/g++.dg/abi/mangle66.C | 10 + gcc/testsuite/g++.dg/abi/nullptr-align.C | 5 + gcc/testsuite/g++.dg/abi/nullptr-align2.C | 20 + gcc/testsuite/g++.dg/cpp/pr53690.C | 7 + gcc/testsuite/g++.dg/cpp0x/alias-decl-49.C | 54 + gcc/testsuite/g++.dg/cpp0x/alias-decl-50.C | 225 + gcc/testsuite/g++.dg/cpp0x/alias-decl-51.C | 9 + gcc/testsuite/g++.dg/cpp0x/constexpr-friend-2.C | 2 +- gcc/testsuite/g++.dg/cpp0x/constexpr-friend-3.C | 21 + gcc/testsuite/g++.dg/cpp0x/deleted12.C | 10 + gcc/testsuite/g++.dg/cpp0x/gen-attrs-60.C | 4 + gcc/testsuite/g++.dg/cpp0x/initlist96.C | 12 + gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi8.C | 15 + gcc/testsuite/g++.dg/cpp0x/lambda/lambda-rep1.C | 14 + gcc/testsuite/g++.dg/cpp0x/local-type1.C | 19 + gcc/testsuite/g++.dg/cpp0x/noexcept28.C | 20 + gcc/testsuite/g++.dg/cpp0x/nsdmi-list4.C | 9 + gcc/testsuite/g++.dg/cpp0x/nsdmi-template14.C | 22 + gcc/testsuite/g++.dg/cpp0x/nsdmi12.C | 16 + gcc/testsuite/g++.dg/cpp0x/rv-array1.C | 55 + gcc/testsuite/g++.dg/cpp0x/scoped_enum5.C | 37 + gcc/testsuite/g++.dg/cpp0x/static_assert12.C | 30 + gcc/testsuite/g++.dg/cpp0x/static_assert13.C | 28 + gcc/testsuite/g++.dg/cpp0x/static_assert8.C | 4 +- gcc/testsuite/g++.dg/cpp0x/trailing11.C | 12 + gcc/testsuite/g++.dg/cpp1y/attr-deprecated-2.C | 4 + gcc/testsuite/g++.dg/cpp1y/constexpr-empty1.C | 6 + gcc/testsuite/g++.dg/cpp1y/lambda-generic-ice2.C | 123 + gcc/testsuite/g++.dg/cpp1y/static_assert1.C | 30 + gcc/testsuite/g++.dg/cpp1y/static_assert2.C | 28 + gcc/testsuite/g++.dg/cpp1y/var-templ30.C | 19 + gcc/testsuite/g++.dg/cpp1y/var-templ31.C | 8 + gcc/testsuite/g++.dg/cpp1y/var-templ32.C | 7 + gcc/testsuite/g++.dg/cpp1z/static_assert-nomsg.C | 27 + gcc/testsuite/g++.dg/cpp1z/udlit-utf8char.C | 8 + gcc/testsuite/g++.dg/cpp1z/utf8-neg.C | 7 + gcc/testsuite/g++.dg/cpp1z/utf8.C | 15 + gcc/testsuite/g++.dg/debug/dwarf2/tls1.C | 7 + gcc/testsuite/g++.dg/debug/localclass1.C | 3 +- gcc/testsuite/g++.dg/debug/nullptr01.C | 3 +- gcc/testsuite/g++.dg/diagnostic/inhibit-warn-1.C | 32 + gcc/testsuite/g++.dg/diagnostic/inhibit-warn-2.C | 36 + gcc/testsuite/g++.dg/eh/scope1.C | 2 +- gcc/testsuite/g++.dg/ext/attrib52.C | 15 + gcc/testsuite/g++.dg/gomp/pr66571-1.C | 37 + gcc/testsuite/g++.dg/inherit/pure1.C | 4 +- gcc/testsuite/g++.dg/ipa/pr65908.C | 27 + gcc/testsuite/g++.dg/lto/pr65276_0.C | 2 + gcc/testsuite/g++.dg/opt/pr66119.C | 69 + gcc/testsuite/g++.dg/other/anon7.C | 10 + gcc/testsuite/g++.dg/other/const4.C | 10 + .../other/{dump-ada-spec-1.C => dump-ada-spec-5.C} | 9 +- gcc/testsuite/g++.dg/other/dump-ada-spec-6.C | 23 + gcc/testsuite/g++.dg/other/dump-ada-spec-7.C | 24 + gcc/testsuite/g++.dg/other/linkage2.C | 10 + gcc/testsuite/g++.dg/overload/defarg10.C | 28 + gcc/testsuite/g++.dg/overload/pmf3.C | 70 + gcc/testsuite/g++.dg/parse/new-placement1.C | 3 + gcc/testsuite/g++.dg/template/nontype27.C | 9 + gcc/testsuite/g++.dg/template/pr66686.C | 15 + gcc/testsuite/g++.dg/tls/tls_model1.C | 8 + gcc/testsuite/g++.dg/torture/pr40991.C | 2 +- gcc/testsuite/g++.dg/torture/pr47559.C | 4 +- gcc/testsuite/g++.dg/torture/pr49770.C | 4 +- gcc/testsuite/g++.dg/torture/pr51198.C | 2 +- gcc/testsuite/g++.dg/torture/pr53161.C | 2 +- gcc/testsuite/g++.dg/torture/pr53602.C | 3 +- gcc/testsuite/g++.dg/torture/pr55260-1.C | 4 +- gcc/testsuite/g++.dg/torture/pr56768.C | 3 +- gcc/testsuite/g++.dg/torture/pr59265.C | 4 +- gcc/testsuite/g++.dg/torture/pr65914.C | 70 + gcc/testsuite/g++.dg/torture/vshuf-main.inc | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v16hi.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v16qi.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v2df.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v2di.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v2sf.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v2si.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v4df.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v4di.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v4sf.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v4si.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v8hi.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v8qi.C | 3 +- gcc/testsuite/g++.dg/torture/vshuf-v8si.C | 3 +- gcc/testsuite/gcc.c-torture/compile/pr65803.c | 25 + gcc/testsuite/gcc.c-torture/execute/20150611-1.c | 18 + gcc/testsuite/gcc.c-torture/execute/pr65956.c | 67 + gcc/testsuite/gcc.c-torture/execute/pr66757.c | 15 + gcc/testsuite/gcc.dg/debug/dwarf2/pr66482.c | 9 + gcc/testsuite/gcc.dg/fold-and-1.c | 70 + gcc/testsuite/gcc.dg/fold-and-2.c | 70 + gcc/testsuite/gcc.dg/fold-ior-1.c | 69 + gcc/testsuite/gcc.dg/fold-ior-2.c | 47 + gcc/testsuite/gcc.dg/fold-ior-3.c | 35 + gcc/testsuite/gcc.dg/fold-minus-2.c | 37 + gcc/testsuite/gcc.dg/fold-minus-3.c | 37 + gcc/testsuite/gcc.dg/fold-minus-4.c | 37 + gcc/testsuite/gcc.dg/fold-minus-5.c | 37 + gcc/testsuite/gcc.dg/fold-minus-6.c | 42 + gcc/testsuite/gcc.dg/fold-plus-1.c | 70 + gcc/testsuite/gcc.dg/fold-plus-2.c | 69 + gcc/testsuite/gcc.dg/fold-xor-4.c | 69 + gcc/testsuite/gcc.dg/fold-xor-5.c | 69 + gcc/testsuite/gcc.dg/graphite/isl-ast-gen-if-1.c | 2 +- .../gcc.dg/parloops-exit-first-loop-alt-3.c | 2 +- ...op-alt-3.c => parloops-exit-first-loop-alt-5.c} | 20 +- ...op-alt-3.c => parloops-exit-first-loop-alt-6.c} | 20 +- ...op-alt-3.c => parloops-exit-first-loop-alt-7.c} | 18 +- .../gcc.dg/parloops-exit-first-loop-alt-pr66652.c | 31 + .../gcc.dg/parloops-exit-first-loop-alt.c | 21 +- gcc/testsuite/gcc.dg/plugin/wide-int_plugin.c | 4 +- gcc/testsuite/gcc.dg/stack-usage-1.c | 8 + gcc/testsuite/gcc.dg/torture/pr66345.c | 8 +- gcc/testsuite/gcc.dg/torture/pr66733-1.c | 28 + gcc/testsuite/gcc.dg/torture/pr66733-2.c | 46 + gcc/testsuite/gcc.dg/torture/pr66759.c | 11 + gcc/testsuite/gcc.dg/tree-ssa/forwprop-25.c | 7 +- gcc/testsuite/gcc.dg/tree-ssa/pr52631.c | 2 +- gcc/testsuite/gcc.dg/tree-ssa/pr64130.c | 18 + gcc/testsuite/gcc.dg/tree-ssa/pr66449.c | 18 + gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-cse-4.c | 20 + gcc/testsuite/gcc.dg/vect/bb-slp-32.c | 2 +- gcc/testsuite/gcc.dg/vect/pr48052.c | 6 +- gcc/testsuite/gcc.dg/vect/pr66253.c | 51 + gcc/testsuite/gcc.dg/vect/pr66636.c | 29 + gcc/testsuite/gcc.dg/vect/pr66677.c | 15 + gcc/testsuite/gcc.dg/vect/slp-perm-11.c | 35 + gcc/testsuite/gcc.dg/vect/slp-perm-12.c | 52 + gcc/testsuite/gcc.dg/vect/vect-ifcvt-11.c | 36 + gcc/testsuite/gcc.dg/vect/vect-strided-a-u16-i4.c | 2 +- .../advsimd-intrinsics/advsimd-intrinsics.exp | 2 + .../aarch64/advsimd-intrinsics/arm-neon-ref.h | 19 +- .../aarch64/advsimd-intrinsics/vget_lane.c | 125 + .../gcc.target/aarch64/advsimd-intrinsics/vrecpe.c | 154 + .../gcc.target/aarch64/advsimd-intrinsics/vrecps.c | 117 + .../aarch64/advsimd-intrinsics/vreinterpret.c | 741 + .../gcc.target/aarch64/advsimd-intrinsics/vrev.c | 200 + .../gcc.target/aarch64/advsimd-intrinsics/vrshl.c | 627 + .../aarch64/advsimd-intrinsics/vrshr_n.c | 504 + .../aarch64/advsimd-intrinsics/vrshrn_n.c | 143 + .../aarch64/advsimd-intrinsics/vrsqrte.c | 157 + .../aarch64/advsimd-intrinsics/vrsqrts.c | 118 + .../aarch64/advsimd-intrinsics/vrsra_n.c | 553 + .../aarch64/advsimd-intrinsics/vset_lane.c | 99 + .../gcc.target/aarch64/advsimd-intrinsics/vshl_n.c | 96 + .../aarch64/advsimd-intrinsics/vshll_n.c | 56 + .../gcc.target/aarch64/advsimd-intrinsics/vshr_n.c | 95 + .../aarch64/advsimd-intrinsics/vshrn_n.c | 70 + .../gcc.target/aarch64/advsimd-intrinsics/vsra_n.c | 117 + .../aarch64/advsimd-intrinsics/vst1_lane.c | 93 + .../aarch64/advsimd-intrinsics/vstX_lane.c | 578 + .../gcc.target/aarch64/advsimd-intrinsics/vtbX.c | 289 + .../gcc.target/aarch64/advsimd-intrinsics/vtst.c | 120 + .../gcc.target/aarch64/arm_align_max_pwr.c | 15 + .../gcc.target/aarch64/arm_align_max_stack_pwr.c | 15 + .../aarch64/{fmovd-zero.c => fmovd-zero-mem.c} | 2 +- gcc/testsuite/gcc.target/aarch64/fmovd-zero-reg.c | 11 + .../aarch64/{fmovf-zero.c => fmovf-zero-mem.c} | 2 +- .../gcc.target/aarch64/{clz.c => fmovf-zero-reg.c} | 8 +- gcc/testsuite/gcc.target/aarch64/fmovld-zero-mem.c | 10 + gcc/testsuite/gcc.target/aarch64/fmovld-zero-reg.c | 11 + gcc/testsuite/gcc.target/aarch64/fnmul-1.c | 16 + gcc/testsuite/gcc.target/aarch64/fnmul-2.c | 18 + gcc/testsuite/gcc.target/aarch64/fnmul-3.c | 16 + gcc/testsuite/gcc.target/aarch64/fnmul-4.c | 16 + gcc/testsuite/gcc.target/aarch64/mgeneral-regs_1.c | 10 + gcc/testsuite/gcc.target/aarch64/mgeneral-regs_2.c | 15 + gcc/testsuite/gcc.target/aarch64/mgeneral-regs_3.c | 11 + gcc/testsuite/gcc.target/aarch64/nofp_1.c | 19 + gcc/testsuite/gcc.target/aarch64/pic-small.c | 27 + gcc/testsuite/gcc.target/aarch64/pr62308.c | 6 + .../gcc.target/aarch64/vect-add-sub-cond.c | 94 + gcc/testsuite/gcc.target/arm/aapcs/align1.c | 29 + gcc/testsuite/gcc.target/arm/aapcs/align2.c | 30 + gcc/testsuite/gcc.target/arm/aapcs/align3.c | 42 + gcc/testsuite/gcc.target/arm/aapcs/align4.c | 29 + gcc/testsuite/gcc.target/arm/aapcs/align_rec1.c | 36 + gcc/testsuite/gcc.target/arm/aapcs/align_rec2.c | 41 + gcc/testsuite/gcc.target/arm/aapcs/align_rec3.c | 43 + gcc/testsuite/gcc.target/arm/aapcs/align_rec4.c | 33 + gcc/testsuite/gcc.target/arm/aapcs/align_vaarg1.c | 36 + gcc/testsuite/gcc.target/arm/aapcs/align_vaarg2.c | 30 + .../gcc.target/arm/armv8-sync-comp-swap.c | 10 + .../gcc.target/arm/armv8-sync-op-acquire.c | 10 + gcc/testsuite/gcc.target/arm/armv8-sync-op-full.c | 10 + .../gcc.target/arm/armv8-sync-op-release.c | 8 + gcc/testsuite/gcc.target/arm/attr_arm.c | 6 +- gcc/testsuite/gcc.target/arm/attr_thumb-static.c | 5 +- gcc/testsuite/gcc.target/arm/attr_thumb.c | 8 +- .../gcc.target/arm/fixed_float_conversion.c | 1 + gcc/testsuite/gcc.target/arm/flip-thumb.c | 24 + gcc/testsuite/gcc.target/arm/memset-inline-10.c | 2 + gcc/testsuite/gcc.target/arm/pr58784.c | 2 + gcc/testsuite/gcc.target/arm/pr59985.C | 1 + gcc/testsuite/gcc.target/arm/pr63408.c | 23 + gcc/testsuite/gcc.target/arm/pr65647.c | 2 + gcc/testsuite/gcc.target/arm/thumb-ifcvt.c | 2 +- gcc/testsuite/gcc.target/arm/vfp-1.c | 3 +- gcc/testsuite/gcc.target/i386/47698.c | 1 + gcc/testsuite/gcc.target/i386/asm-dialect-1.c | 1 + gcc/testsuite/gcc.target/i386/asm-flag-0.c | 15 + gcc/testsuite/gcc.target/i386/asm-flag-1.c | 18 + gcc/testsuite/gcc.target/i386/asm-flag-2.c | 16 + gcc/testsuite/gcc.target/i386/asm-flag-3.c | 22 + gcc/testsuite/gcc.target/i386/asm-flag-4.c | 20 + gcc/testsuite/gcc.target/i386/asm-flag-5.c | 29 + .../gcc.target/i386/avx2-vect-aggressive-1.c | 1 - .../gcc.target/i386/avx512vl-vpmuludq-1.c | 1 + gcc/testsuite/gcc.target/i386/cmov9.c | 8 + .../gcc.target/i386/extract-insert-combining.c | 1 - gcc/testsuite/gcc.target/i386/fma4-256-nmsubXX.c | 1 + .../abi-x86_64.exp => i386/iamcu/abi-iamcu.exp} | 24 +- gcc/testsuite/gcc.target/i386/iamcu/args.h | 77 + gcc/testsuite/gcc.target/i386/iamcu/asm-support.S | 302 + .../{x86_64/abi => i386/iamcu}/defines.h | 68 +- .../gcc.target/{x86_64/abi => i386/iamcu}/macros.h | 0 .../i386/iamcu/test_3_element_struct_and_unions.c | 521 + .../i386/iamcu/test_basic_64bit_returning.c | 57 + .../abi => i386/iamcu}/test_basic_alignment.c | 9 - .../iamcu}/test_basic_array_size_and_align.c | 11 +- .../gcc.target/i386/iamcu/test_basic_returning.c | 52 + .../{x86_64/abi => i386/iamcu}/test_basic_sizes.c | 6 - .../iamcu}/test_basic_struct_size_and_align.c | 9 - .../iamcu}/test_basic_union_size_and_align.c | 9 - .../{x86_64/abi => i386/iamcu}/test_bitfields.c | 2 +- .../abi => i386/iamcu}/test_complex_returning.c | 0 .../abi => i386/iamcu}/test_passing_floats.c | 192 +- .../abi => i386/iamcu}/test_passing_integers.c | 33 +- .../abi => i386/iamcu}/test_passing_structs.c | 184 +- .../iamcu}/test_passing_structs_and_unions.c | 22 +- .../abi => i386/iamcu}/test_passing_unions.c | 46 +- .../gcc.target/i386/iamcu/test_struct_returning.c | 362 + .../{x86_64/abi => i386/iamcu}/test_varargs.c | 22 +- gcc/testsuite/gcc.target/i386/mpx/pr66567.c | 16 + gcc/testsuite/gcc.target/i386/mpx/pr66568.c | 11 + gcc/testsuite/gcc.target/i386/mpx/pr66569.c | 14 + gcc/testsuite/gcc.target/i386/mpx/pr66581.c | 18 + gcc/testsuite/gcc.target/i386/noplt-1.c | 2 +- gcc/testsuite/gcc.target/i386/noplt-2.c | 2 +- gcc/testsuite/gcc.target/i386/noplt-3.c | 2 +- gcc/testsuite/gcc.target/i386/noplt-4.c | 2 +- gcc/testsuite/gcc.target/i386/pr37843-3.c | 1 - gcc/testsuite/gcc.target/i386/pr37843-4.c | 1 - gcc/testsuite/gcc.target/i386/pr39058.c | 1 + gcc/testsuite/gcc.target/i386/pr50038.c | 1 + gcc/testsuite/gcc.target/i386/pr50202.c | 1 - gcc/testsuite/gcc.target/i386/pr52252-atom.c | 1 - gcc/testsuite/gcc.target/i386/pr52252-core.c | 1 - gcc/testsuite/gcc.target/i386/pr53383-1.c | 8 + gcc/testsuite/gcc.target/i386/pr53383-2.c | 8 + gcc/testsuite/gcc.target/i386/pr53383-3.c | 8 + gcc/testsuite/gcc.target/i386/pr53397-1.c | 1 - gcc/testsuite/gcc.target/i386/pr53397-2.c | 1 - gcc/testsuite/gcc.target/i386/pr53416.c | 1 + gcc/testsuite/gcc.target/i386/pr53759.c | 1 - gcc/testsuite/gcc.target/i386/pr54592.c | 1 - gcc/testsuite/gcc.target/i386/pr55934.c | 1 - gcc/testsuite/gcc.target/i386/pr56766-1.c | 42 + gcc/testsuite/gcc.target/i386/pr56766-2.c | 40 + gcc/testsuite/gcc.target/i386/pr59794-2.c | 1 + gcc/testsuite/gcc.target/i386/pr59794-3.c | 1 + gcc/testsuite/gcc.target/i386/pr59794-7.c | 1 + gcc/testsuite/gcc.target/i386/pr60205-1.c | 1 + gcc/testsuite/gcc.target/i386/pr60205-2.c | 1 + gcc/testsuite/gcc.target/i386/pr60451.c | 1 - gcc/testsuite/gcc.target/i386/pr60901.c | 1 + gcc/testsuite/gcc.target/i386/pr61403.c | 1 - gcc/testsuite/gcc.target/i386/pr62208.c | 1 + gcc/testsuite/gcc.target/i386/pr66412.c | 17 + gcc/testsuite/gcc.target/i386/pr66560-1.c | 35 + gcc/testsuite/gcc.target/i386/pr66560-2.c | 35 + gcc/testsuite/gcc.target/i386/pr66560-3.c | 35 + gcc/testsuite/gcc.target/i386/pr66560-4.c | 35 + gcc/testsuite/gcc.target/i386/pr66691.c | 64 + gcc/testsuite/gcc.target/i386/pr66746.c | 10 + .../gcc.target/i386/{addr-sel-1.c => pr66749.c} | 5 +- .../gcc.target/i386/recip-vec-sqrtf-avx.c | 2 +- gcc/testsuite/gcc.target/i386/rotate-3.c | 1 - gcc/testsuite/gcc.target/i386/rotate-4.c | 1 - gcc/testsuite/gcc.target/i386/rotate-5.c | 1 - gcc/testsuite/gcc.target/i386/sse-20.c | 2 +- gcc/testsuite/gcc.target/i386/sse2-movq-2.c | 2 +- gcc/testsuite/gcc.target/i386/vararg-loc.c | 8 +- gcc/testsuite/gcc.target/i386/vect-div-1.c | 2 +- gcc/testsuite/gcc.target/i386/vectorize1.c | 2 +- .../mips/loongson-shift-count-truncated-1.c | 2 +- gcc/testsuite/gcc.target/mips/loongson-simd.c | 2 +- gcc/testsuite/gcc.target/mips/near-far-3.c | 2 +- gcc/testsuite/gcc.target/mips/pr65862-1.c | 16 + gcc/testsuite/gcc.target/mips/pr65862-2.c | 31 + gcc/testsuite/gcc.target/nios2/gprel-offset.c | 20 + .../gcc.target/{arc/arc.exp => nvptx/nvptx.exp} | 7 +- gcc/testsuite/gcc.target/nvptx/proto-1.c | 13 + gcc/testsuite/gcc.target/powerpc/shift-int.c | 23 + gcc/testsuite/gcc.target/powerpc/vec-cmp.c | 113 + gcc/testsuite/gcc.target/s390/pr66306.c | 26 + gcc/testsuite/gcc.target/s390/vector/vec-abi-1.c | 1 + .../gcc.target/s390/vector/vec-abi-attr-1.c | 18 + .../gcc.target/s390/vector/vec-abi-attr-2.c | 53 + .../gcc.target/s390/vector/vec-abi-attr-3.c | 18 + .../gcc.target/s390/vector/vec-abi-attr-4.c | 17 + .../gcc.target/s390/vector/vec-abi-attr-5.c | 19 + .../gcc.target/s390/vector/vec-abi-attr-6.c | 24 + gcc/testsuite/gcc.target/vax/bswapdi-1.c | 13 + gcc/testsuite/gfortran.dg/alloc_comp_class_3.f03 | 55 + gcc/testsuite/gfortran.dg/alloc_comp_class_4.f03 | 105 + gcc/testsuite/gfortran.dg/associate_18.f08 | 80 + gcc/testsuite/gfortran.dg/gomp/omp_parallel_1.f90 | 37 + gcc/testsuite/gfortran.dg/gomp/pr66633.f90 | 17 + gcc/testsuite/gfortran.dg/iomsg_2.f90 | 44 + gcc/testsuite/gfortran.dg/maxerrors.f90 | 12 + gcc/testsuite/gfortran.dg/pr56520.f90 | 13 + gcc/testsuite/gfortran.dg/pr66545_1.f90 | 17 + gcc/testsuite/gfortran.dg/pr66545_2.f90 | 23 + gcc/testsuite/gfortran.dg/pr66725.f90 | 31 + gcc/testsuite/gfortran.dg/reassoc_3.f90 | 3 +- gcc/testsuite/gfortran.dg/submodule_1.f90 | 172 + gcc/testsuite/gfortran.dg/submodule_2.f90 | 100 + gcc/testsuite/gfortran.dg/submodule_3.f90 | 37 + gcc/testsuite/gfortran.dg/submodule_4.f90 | 140 + gcc/testsuite/gfortran.dg/submodule_5.f90 | 51 + gcc/testsuite/gfortran.dg/submodule_6.f90 | 91 + gcc/testsuite/gfortran.dg/submodule_7.f90 | 147 + gcc/testsuite/gfortran.dg/vect/vect-9.f90 | 34 + gcc/testsuite/gfortran.dg/warn_conversion_8.f90 | 8 + gcc/testsuite/gfortran.dg/wunused-parameter.f90 | 15 + .../gfortran.fortran-torture/compile/pr66251-2.f90 | 23 + gcc/testsuite/gnat.dg/debug4.adb | 10 + gcc/testsuite/gnat.dg/debug4_pkg.adb | 23 + gcc/testsuite/gnat.dg/debug4_pkg.ads | 28 + gcc/testsuite/gnat.dg/lto17.adb | 12 + gcc/testsuite/gnat.dg/lto17.ads | 20 + gcc/testsuite/gnat.dg/specs/debug1.ads | 2 +- gcc/testsuite/gnat.dg/warn11.adb | 2 + gcc/testsuite/gnat.dg/warn12.adb | 48 + gcc/testsuite/gnat.dg/warn12_pkg.ads | 21 + gcc/testsuite/jit.dg/all-non-failing-tests.h | 47 + gcc/testsuite/jit.dg/test-accessing-union.c | 4 + gcc/testsuite/jit.dg/test-compound-assignment.c | 157 + gcc/testsuite/jit.dg/test-debug-strings.c | 190 + ...error-gcc_jit_block_end_with_switch-NULL-case.c | 66 + ...t_block_end_with_switch-mismatching-case-type.c | 83 + ..._jit_block_end_with_switch-overlapping-ranges.c | 95 + ...rror-gcc_jit_context_new_case-non-const-label.c | 80 + ...ror-gcc_jit_context_new_case-non-integer-type.c | 81 + ...r-gcc_jit_context_new_case-reversed-endpoints.c | 80 + ...ror-gcc_jit_lvalue_access_field-wrong-struct.c} | 63 +- ...ror-gcc_jit_rvalue_access_field-wrong-struct.c} | 64 +- ...cc_jit_rvalue_dereference_field-wrong-struct.c} | 0 .../{test-dot-product.c => test-extra-options.c} | 9 +- .../test-pr66700-observing-write-through-ptr.c | 109 + gcc/testsuite/jit.dg/test-quadratic.c | 28 +- gcc/testsuite/jit.dg/test-switch.c | 147 + gcc/testsuite/jit.dg/test-switch.cc | 118 + ...le-block.c => test-validly-unreachable-block.c} | 11 +- gcc/testsuite/lib/c-torture.exp | 64 +- gcc/testsuite/lib/gcc-dg.exp | 62 +- gcc/testsuite/lib/target-supports.exp | 22 +- gcc/toplev.c | 32 +- gcc/tracer.c | 3 - gcc/trans-mem.c | 35 +- gcc/tree-affine.c | 2 - gcc/tree-browser.c | 3 +- gcc/tree-call-cdce.c | 2 - gcc/tree-cfg.c | 24 +- gcc/tree-cfgcleanup.c | 2 - gcc/tree-chkp-opt.c | 2 - gcc/tree-chkp.c | 37 +- gcc/tree-chkp.h | 1 + gcc/tree-chrec.c | 2 - gcc/tree-complex.c | 2 - gcc/tree-core.h | 4 +- gcc/tree-data-ref.c | 2 - gcc/tree-dfa.c | 2 - gcc/tree-diagnostic.c | 1 - gcc/tree-dump.c | 1 - gcc/tree-eh.c | 8 +- gcc/tree-emutls.c | 5 - gcc/tree-hash-traits.h | 82 + gcc/tree-if-conv.c | 51 +- gcc/tree-inline.c | 7 +- gcc/tree-inline.h | 22 +- gcc/tree-into-ssa.c | 6 +- gcc/tree-iterator.c | 1 - gcc/tree-loop-distribution.c | 11 +- gcc/tree-nested.c | 12 +- gcc/tree-nrv.c | 3 - gcc/tree-object-size.c | 3 - gcc/tree-outof-ssa.c | 2 - gcc/tree-parloops.c | 92 +- gcc/tree-pass.h | 2 + gcc/tree-phinodes.c | 3 - gcc/tree-predcom.c | 8 +- gcc/tree-pretty-print.c | 4 - gcc/tree-profile.c | 5 - gcc/tree-scalar-evolution.c | 4 +- gcc/tree-sra.c | 27 +- gcc/tree-ssa-address.c | 2 - gcc/tree-ssa-alias.c | 27 +- gcc/tree-ssa-ccp.c | 22 +- gcc/tree-ssa-coalesce.c | 11 +- gcc/tree-ssa-copy.c | 3 - gcc/tree-ssa-copyrename.c | 2 - gcc/tree-ssa-dce.c | 2 - gcc/tree-ssa-dom.c | 14 +- gcc/tree-ssa-dse.c | 2 - gcc/tree-ssa-forwprop.c | 2 - gcc/tree-ssa-ifcombine.c | 9 +- gcc/tree-ssa-live.c | 7 +- gcc/tree-ssa-loop-ch.c | 157 +- gcc/tree-ssa-loop-im.c | 6 +- gcc/tree-ssa-loop-ivcanon.c | 5 - gcc/tree-ssa-loop-ivopts.c | 53 +- gcc/tree-ssa-loop-manip.c | 20 +- gcc/tree-ssa-loop-niter.c | 35 +- gcc/tree-ssa-loop-prefetch.c | 11 +- gcc/tree-ssa-loop-unswitch.c | 3 - gcc/tree-ssa-loop.c | 3 - gcc/tree-ssa-math-opts.c | 2 - gcc/tree-ssa-operands.c | 3 - gcc/tree-ssa-phiopt.c | 14 +- gcc/tree-ssa-phiprop.c | 3 - gcc/tree-ssa-pre.c | 14 +- gcc/tree-ssa-propagate.c | 73 +- gcc/tree-ssa-reassoc.c | 19 +- gcc/tree-ssa-sccvn.c | 25 +- gcc/tree-ssa-scopedtables.c | 1 - gcc/tree-ssa-sink.c | 3 - gcc/tree-ssa-strlen.c | 25 +- gcc/tree-ssa-structalias.c | 12 +- gcc/tree-ssa-tail-merge.c | 7 +- gcc/tree-ssa-ter.c | 3 - gcc/tree-ssa-threadedge.c | 3 - gcc/tree-ssa-threadupdate.c | 7 +- gcc/tree-ssa-uncprop.c | 20 +- gcc/tree-ssa-uninit.c | 3 - gcc/tree-ssa.c | 3 - gcc/tree-ssanames.c | 3 - gcc/tree-stdarg.c | 3 - gcc/tree-streamer-in.c | 5 - gcc/tree-streamer-out.c | 7 +- gcc/tree-streamer.c | 5 - gcc/tree-switch-conversion.c | 5 - gcc/tree-tailcall.c | 4 - gcc/tree-vect-data-refs.c | 84 +- gcc/tree-vect-generic.c | 2 - gcc/tree-vect-loop-manip.c | 7 +- gcc/tree-vect-loop.c | 199 +- gcc/tree-vect-patterns.c | 2 - gcc/tree-vect-slp.c | 82 +- gcc/tree-vect-stmts.c | 451 +- gcc/tree-vectorizer.c | 152 +- gcc/tree-vectorizer.h | 14 +- gcc/tree-vrp.c | 93 +- gcc/tree.c | 117 +- gcc/tree.h | 40 +- gcc/tsan.c | 4 - gcc/typed-splay-tree.h | 135 + gcc/ubsan.c | 18 +- gcc/valtrack.c | 1 - gcc/valtrack.h | 14 +- gcc/value-prof.c | 24 +- gcc/var-tracking.c | 4 +- gcc/varasm.c | 28 +- gcc/varpool.c | 5 - gcc/vec.c | 1 - gcc/vmsdbgout.c | 2 - gcc/vtable-verify.c | 7 +- gcc/vtable-verify.h | 4 +- gcc/web.c | 1 - gcc/wide-int.cc | 1 - gcc/xcoffout.c | 1 - libcc1/ChangeLog | 12 + libcc1/plugin.cc | 17 +- libcpp/ChangeLog | 30 + libcpp/charset.c | 38 +- libcpp/expr.c | 9 +- libcpp/include/cpplib.h | 5 + libcpp/init.c | 36 +- libcpp/internal.h | 7 +- libcpp/lex.c | 37 +- libcpp/macro.c | 2 +- libcpp/po/ChangeLog | 4 + libcpp/po/cpplib.pot | 342 +- libdecnumber/ChangeLog | 4 + libdecnumber/configure | 2 +- libgcc/ChangeLog | 19 + libgcc/config.host | 3 + libgcc/config/arm/lib1funcs.S | 11 +- libgcc/config/i386/32/t-iamcu | 1 + libgcc/config/pa/linux-atomic.c | 52 +- libgcc/config/t-softfp-sfdftf | 5 + libgcc/configure | 2 +- libgfortran/ChangeLog | 7 + libgfortran/Makefile.am | 6 - libgfortran/Makefile.in | 81 +- libgfortran/fmain.c | 24 - libgomp/ChangeLog | 169 + libgomp/config.h.in | 3 + libgomp/configure | 2 +- libgomp/configure.ac | 2 +- libgomp/libgomp.h | 3 + libgomp/testsuite/libgomp.c++/atomic-1.C | 1 - libgomp/testsuite/libgomp.c++/atomic-16.C | 1 - libgomp/testsuite/libgomp.c++/c++.exp | 7 +- libgomp/testsuite/libgomp.c++/for-7.C | 2 +- libgomp/testsuite/libgomp.c++/pr64824.C | 1 - libgomp/testsuite/libgomp.c++/pr64868.C | 1 - libgomp/testsuite/libgomp.c++/pr66199-1.C | 1 - libgomp/testsuite/libgomp.c++/pr66199-2.C | 1 - libgomp/testsuite/libgomp.c++/pr66702-1.C | 50 + libgomp/testsuite/libgomp.c++/pr66702-2.C | 35 + libgomp/testsuite/libgomp.c++/simd-1.C | 1 - libgomp/testsuite/libgomp.c++/simd-2.C | 1 - libgomp/testsuite/libgomp.c++/simd-3.C | 1 - libgomp/testsuite/libgomp.c++/simd-4.C | 1 - libgomp/testsuite/libgomp.c++/simd-5.C | 1 - libgomp/testsuite/libgomp.c++/simd-6.C | 1 - libgomp/testsuite/libgomp.c++/simd-7.C | 1 - libgomp/testsuite/libgomp.c++/simd-8.C | 1 - libgomp/testsuite/libgomp.c++/simd-9.C | 1 - libgomp/testsuite/libgomp.c++/simd10.C | 1 - libgomp/testsuite/libgomp.c++/simd11.C | 1 - libgomp/testsuite/libgomp.c++/simd12.C | 1 - libgomp/testsuite/libgomp.c++/simd13.C | 1 - libgomp/testsuite/libgomp.c++/target-2.C | 1 - libgomp/testsuite/libgomp.c++/udr-11.C | 2 +- libgomp/testsuite/libgomp.c++/udr-12.C | 2 +- libgomp/testsuite/libgomp.c++/udr-13.C | 2 +- libgomp/testsuite/libgomp.c++/udr-14.C | 2 +- libgomp/testsuite/libgomp.c++/udr-15.C | 2 +- libgomp/testsuite/libgomp.c++/udr-16.C | 2 +- libgomp/testsuite/libgomp.c++/udr-17.C | 2 +- libgomp/testsuite/libgomp.c++/udr-18.C | 2 +- libgomp/testsuite/libgomp.c++/udr-19.C | 2 +- libgomp/testsuite/libgomp.c/atomic-1.c | 2 +- libgomp/testsuite/libgomp.c/atomic-18.c | 1 - libgomp/testsuite/libgomp.c/atomic-2.c | 2 +- libgomp/testsuite/libgomp.c/atomic-3.c | 2 +- libgomp/testsuite/libgomp.c/atomic-4.c | 1 - libgomp/testsuite/libgomp.c/atomic-5.c | 3 +- libgomp/testsuite/libgomp.c/atomic-6.c | 5 +- libgomp/testsuite/libgomp.c/autopar-1.c | 2 +- libgomp/testsuite/libgomp.c/collapse-3.c | 2 +- libgomp/testsuite/libgomp.c/copyin-1.c | 1 - libgomp/testsuite/libgomp.c/copyin-2.c | 1 - libgomp/testsuite/libgomp.c/copyin-3.c | 1 - libgomp/testsuite/libgomp.c/debug-1.c | 2 +- libgomp/testsuite/libgomp.c/examples-4/e.53.5.c | 1 - libgomp/testsuite/libgomp.c/for-1.c | 2 +- libgomp/testsuite/libgomp.c/for-2.c | 2 +- libgomp/testsuite/libgomp.c/for-3.c | 2 +- libgomp/testsuite/libgomp.c/nestedfn-5.c | 1 - libgomp/testsuite/libgomp.c/nqueens-1.c | 1 - .../libgomp.c/parloops-exit-first-loop-alt-2.c | 2 +- .../libgomp.c/parloops-exit-first-loop-alt-3.c | 15 +- .../libgomp.c/parloops-exit-first-loop-alt-4.c | 8 +- ...loop-alt.c => parloops-exit-first-loop-alt-5.c} | 39 +- ...loop-alt.c => parloops-exit-first-loop-alt-6.c} | 39 +- ...loop-alt.c => parloops-exit-first-loop-alt-7.c} | 37 +- .../libgomp.c/parloops-exit-first-loop-alt.c | 9 +- libgomp/testsuite/libgomp.c/pr26171.c | 2 +- libgomp/testsuite/libgomp.c/pr32362-1.c | 1 - libgomp/testsuite/libgomp.c/pr32362-2.c | 1 - libgomp/testsuite/libgomp.c/pr32362-3.c | 1 - libgomp/testsuite/libgomp.c/pr35625.c | 2 +- libgomp/testsuite/libgomp.c/pr39154.c | 2 +- libgomp/testsuite/libgomp.c/pr39591-1.c | 1 - libgomp/testsuite/libgomp.c/pr39591-2.c | 1 - libgomp/testsuite/libgomp.c/pr39591-3.c | 1 - libgomp/testsuite/libgomp.c/pr48591.c | 2 +- libgomp/testsuite/libgomp.c/pr58392.c | 1 - libgomp/testsuite/libgomp.c/pr58756.c | 1 - libgomp/testsuite/libgomp.c/pr64824.c | 1 - libgomp/testsuite/libgomp.c/pr64868.c | 1 - libgomp/testsuite/libgomp.c/pr66133.c | 1 - libgomp/testsuite/libgomp.c/pr66199-1.c | 1 - libgomp/testsuite/libgomp.c/pr66199-2.c | 1 - libgomp/testsuite/libgomp.c/simd-1.c | 1 - libgomp/testsuite/libgomp.c/simd-10.c | 1 - libgomp/testsuite/libgomp.c/simd-11.c | 1 - libgomp/testsuite/libgomp.c/simd-12.c | 1 - libgomp/testsuite/libgomp.c/simd-13.c | 1 - libgomp/testsuite/libgomp.c/simd-14.c | 1 - libgomp/testsuite/libgomp.c/simd-15.c | 1 - libgomp/testsuite/libgomp.c/simd-16.c | 2 +- libgomp/testsuite/libgomp.c/simd-17.c | 2 +- libgomp/testsuite/libgomp.c/simd-2.c | 1 - libgomp/testsuite/libgomp.c/simd-3.c | 1 - libgomp/testsuite/libgomp.c/simd-4.c | 1 - libgomp/testsuite/libgomp.c/simd-5.c | 1 - libgomp/testsuite/libgomp.c/simd-6.c | 1 - libgomp/testsuite/libgomp.c/simd-7.c | 1 - libgomp/testsuite/libgomp.c/simd-8.c | 1 - libgomp/testsuite/libgomp.c/simd-9.c | 1 - libgomp/testsuite/libgomp.c/target-8.c | 1 - libgomp/testsuite/libgomp.oacc-c++/c++.exp | 7 +- .../libgomp.oacc-c-c++-common/collapse-3.c | 1 - .../testsuite/libgomp.oacc-c-c++-common/lib-3.c | 3 +- .../testsuite/libgomp.oacc-c-c++-common/lib-42.c | 4 +- .../testsuite/libgomp.oacc-c-c++-common/lib-62.c | 6 +- libitm/ChangeLog | 5 + libitm/config/powerpc/sjlj.S | 8 +- libstdc++-v3/ChangeLog | 423 + libstdc++-v3/acinclude.m4 | 18 +- libstdc++-v3/configure | 16 +- libstdc++-v3/doc/Makefile.am | 2 + libstdc++-v3/doc/Makefile.in | 2 + libstdc++-v3/doc/html/manual/bugs.html | 3 + libstdc++-v3/doc/html/manual/configure.html | 5 +- libstdc++-v3/doc/html/manual/status.html | 14 +- libstdc++-v3/doc/xml/manual/configure.xml | 5 +- libstdc++-v3/doc/xml/manual/intro.xml | 6 + libstdc++-v3/doc/xml/manual/status_cxx2017.xml | 11 +- libstdc++-v3/include/Makefile.am | 3 + libstdc++-v3/include/Makefile.in | 3 + libstdc++-v3/include/bits/alloc_traits.h | 261 +- libstdc++-v3/include/bits/allocated_ptr.h | 5 +- libstdc++-v3/include/bits/allocator.h | 2 + libstdc++-v3/include/bits/basic_string.h | 51 +- libstdc++-v3/include/bits/forward_list.h | 37 +- libstdc++-v3/include/bits/forward_list.tcc | 32 +- libstdc++-v3/include/bits/hashtable.h | 47 +- libstdc++-v3/include/bits/list.tcc | 49 +- libstdc++-v3/include/bits/locale_conv.h | 13 +- libstdc++-v3/include/bits/ptr_traits.h | 144 +- libstdc++-v3/include/bits/stl_bvector.h | 3 + libstdc++-v3/include/bits/stl_deque.h | 17 +- libstdc++-v3/include/bits/stl_iterator.h | 4 + .../include/bits/stl_iterator_base_types.h | 2 + libstdc++-v3/include/bits/stl_list.h | 232 +- libstdc++-v3/include/bits/stl_map.h | 9 +- libstdc++-v3/include/bits/stl_multimap.h | 9 +- libstdc++-v3/include/bits/stl_multiset.h | 9 +- libstdc++-v3/include/bits/stl_pair.h | 184 +- libstdc++-v3/include/bits/stl_set.h | 9 +- libstdc++-v3/include/bits/stl_tree.h | 9 +- libstdc++-v3/include/bits/stl_uninitialized.h | 2 +- libstdc++-v3/include/bits/stl_vector.h | 6 +- libstdc++-v3/include/bits/unordered_map.h | 2 + libstdc++-v3/include/bits/unordered_set.h | 2 + libstdc++-v3/include/debug/array | 13 +- libstdc++-v3/include/debug/deque | 38 +- libstdc++-v3/include/debug/formatter.h | 14 +- libstdc++-v3/include/debug/forward_list | 75 +- libstdc++-v3/include/debug/functions.h | 83 +- libstdc++-v3/include/debug/helper_functions.h | 210 + libstdc++-v3/include/debug/list | 89 +- libstdc++-v3/include/debug/macros.h | 25 +- libstdc++-v3/include/debug/map.h | 11 +- libstdc++-v3/include/debug/multimap.h | 11 +- libstdc++-v3/include/debug/multiset.h | 11 +- libstdc++-v3/include/debug/safe_iterator.h | 190 +- libstdc++-v3/include/debug/safe_iterator.tcc | 50 +- libstdc++-v3/include/debug/safe_local_iterator.h | 66 +- libstdc++-v3/include/debug/safe_local_iterator.tcc | 16 +- libstdc++-v3/include/debug/set.h | 11 +- libstdc++-v3/include/debug/stl_iterator.h | 113 + libstdc++-v3/include/debug/string | 54 +- libstdc++-v3/include/debug/unordered_map | 24 +- libstdc++-v3/include/debug/unordered_set | 24 +- libstdc++-v3/include/debug/vector | 35 +- libstdc++-v3/include/experimental/functional | 2 +- libstdc++-v3/include/experimental/propagate_const | 535 + libstdc++-v3/include/experimental/type_traits | 53 + libstdc++-v3/include/ext/alloc_traits.h | 52 +- libstdc++-v3/include/ext/array_allocator.h | 2 + libstdc++-v3/include/profile/array | 13 +- libstdc++-v3/include/profile/forward_list | 5 +- libstdc++-v3/include/profile/list | 10 +- libstdc++-v3/include/std/array | 5 + libstdc++-v3/include/std/scoped_allocator | 58 +- libstdc++-v3/include/std/tuple | 502 +- libstdc++-v3/include/std/type_traits | 35 + libstdc++-v3/include/std/utility | 12 +- libstdc++-v3/libsupc++/guard.cc | 2 + libstdc++-v3/python/libstdcxx/v6/printers.py | 24 +- libstdc++-v3/src/c++11/thread.cc | 11 +- .../allocator_traits/members/is_always_equal.cc | 66 + .../20_util/pair/cons/explicit_construct.cc | 108 + libstdc++-v3/testsuite/20_util/pair/piecewise.cc | 6 +- .../requirements/dr2367.cc} | 22 +- .../testsuite/20_util/pointer_traits/pointer_to.cc | 2 + .../requirements/explicit_instantiation.cc | 19 +- .../20_util/scoped_allocator/propagation.cc | 10 +- .../20_util/tuple/cons/explicit_construct.cc | 282 + .../requirements/dr2367.cc} | 28 +- .../array/tuple_interface/get_debug_neg.cc | 6 +- .../23_containers/array/tuple_interface/get_neg.cc | 6 +- .../tuple_interface/tuple_element_debug_neg.cc | 2 +- .../array/tuple_interface/tuple_element_neg.cc | 2 +- .../23_containers/deque/allocator/move_assign-2.cc | 9 +- .../deque/requirements/dr438/assign_neg.cc | 2 +- .../deque/requirements/dr438/constructor_1_neg.cc | 2 +- .../deque/requirements/dr438/constructor_2_neg.cc | 2 +- .../deque/requirements/dr438/insert_neg.cc | 2 +- .../forward_list/modifiers/addressof.cc} | 25 +- .../{forward_list => list}/allocator/copy.cc | 10 +- .../allocator/copy_assign.cc | 8 +- .../{forward_list => list}/allocator/minimal.cc | 8 +- .../{vector => list}/allocator/move.cc | 8 +- .../allocator/move_assign.cc | 8 +- .../{vector => list}/allocator/noexcept.cc | 16 +- .../{forward_list => list}/allocator/swap.cc | 8 +- .../list/modifiers/addressof.cc} | 25 +- .../list/requirements/dr438/assign_neg.cc | 2 +- .../list/requirements/dr438/constructor_1_neg.cc | 2 +- .../list/requirements/dr438/insert_neg.cc | 2 +- .../unordered_set/instantiation_neg.cc | 2 +- .../unordered_set/max_load_factor/robustness.cc | 34 +- .../testsuite/23_containers/vector/52591.cc | 8 +- .../vector/requirements/dr438/assign_neg.cc | 2 +- .../vector/requirements/dr438/constructor_1_neg.cc | 2 +- .../vector/requirements/dr438/constructor_2_neg.cc | 2 +- .../vector/requirements/dr438/insert_neg.cc | 2 +- .../26_numerics/complex/value_operations/1.cc | 2 +- .../propagate_const/assignment/copy.cc} | 20 +- .../swap.cc => propagate_const/assignment/move.cc} | 62 +- .../assignment/move_neg.cc} | 32 +- .../propagate_const/cons/copy.cc} | 18 +- .../propagate_const/cons/default.cc} | 23 +- .../swap/swap.cc => propagate_const/cons/move.cc} | 60 +- .../hash.cc => propagate_const/cons/move_neg.cc} | 36 +- .../make_observer.cc => propagate_const/hash/1.cc} | 17 +- .../experimental/propagate_const/observers/1.cc | 65 + .../experimental/propagate_const/relops/1.cc | 67 + .../4.cc => propagate_const/requirements1.cc} | 27 +- .../hash.cc => propagate_const/requirements2.cc} | 32 +- .../1.cc => propagate_const/requirements3.cc} | 17 +- .../requirements4.cc} | 21 +- .../1.cc => propagate_const/requirements5.cc} | 17 +- .../make_observer.cc => propagate_const/swap/1.cc} | 19 +- .../{any => propagate_const}/typedefs.cc | 16 +- .../experimental/type_traits/detection.cc | 85 + lto-plugin/ChangeLog | 6 + lto-plugin/config.h.in | 32 + lto-plugin/configure | 4082 ++-- lto-plugin/configure.ac | 1 + maintainer-scripts/ChangeLog | 4 + maintainer-scripts/update_version_svn | 2 +- 1383 files changed, 53727 insertions(+), 25290 deletions(-) create mode 100644 gcc/config/aarch64/aarch64-fusion-pairs.def copy gcc/config/aarch64/{aarch64-arches.def => aarch64-tuning-flags.def} (55%) copy gcc/{ginclude/stdnoreturn.h => config/i386/iamcu.h} (63%) create mode 100644 gcc/gentarget-def.c create mode 100644 gcc/go/gofrontend/MERGE create mode 100644 gcc/hash-traits.h create mode 100644 gcc/jit/docs/topics/compatibility.rst create mode 100644 gcc/target-insns.def create mode 100644 gcc/testsuite/c-c++-common/Wlogical-op-3.c create mode 100644 gcc/testsuite/c-c++-common/gomp/pr66429.c create mode 100644 gcc/testsuite/c-c++-common/pr66322.c create mode 100644 gcc/testsuite/c-c++-common/ubsan/overflow-add-5.c create mode 100644 gcc/testsuite/g++.dg/abi/mangle66.C create mode 100644 gcc/testsuite/g++.dg/abi/nullptr-align.C create mode 100644 gcc/testsuite/g++.dg/abi/nullptr-align2.C create mode 100644 gcc/testsuite/g++.dg/cpp/pr53690.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/alias-decl-49.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/alias-decl-50.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/alias-decl-51.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/constexpr-friend-3.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/deleted12.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/gen-attrs-60.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/initlist96.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/lambda/lambda-nsdmi8.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/lambda/lambda-rep1.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/local-type1.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/noexcept28.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/nsdmi-list4.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/nsdmi-template14.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/nsdmi12.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/rv-array1.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/scoped_enum5.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/static_assert12.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/static_assert13.C create mode 100644 gcc/testsuite/g++.dg/cpp0x/trailing11.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/attr-deprecated-2.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/constexpr-empty1.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/lambda-generic-ice2.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/static_assert1.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/static_assert2.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/var-templ30.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/var-templ31.C create mode 100644 gcc/testsuite/g++.dg/cpp1y/var-templ32.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/static_assert-nomsg.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/udlit-utf8char.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/utf8-neg.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/utf8.C create mode 100644 gcc/testsuite/g++.dg/debug/dwarf2/tls1.C create mode 100644 gcc/testsuite/g++.dg/diagnostic/inhibit-warn-1.C create mode 100644 gcc/testsuite/g++.dg/diagnostic/inhibit-warn-2.C create mode 100644 gcc/testsuite/g++.dg/ext/attrib52.C create mode 100644 gcc/testsuite/g++.dg/gomp/pr66571-1.C create mode 100644 gcc/testsuite/g++.dg/ipa/pr65908.C create mode 100644 gcc/testsuite/g++.dg/opt/pr66119.C create mode 100644 gcc/testsuite/g++.dg/other/anon7.C create mode 100644 gcc/testsuite/g++.dg/other/const4.C copy gcc/testsuite/g++.dg/other/{dump-ada-spec-1.C => dump-ada-spec-5.C} (58%) create mode 100644 gcc/testsuite/g++.dg/other/dump-ada-spec-6.C create mode 100644 gcc/testsuite/g++.dg/other/dump-ada-spec-7.C create mode 100644 gcc/testsuite/g++.dg/other/linkage2.C create mode 100644 gcc/testsuite/g++.dg/overload/defarg10.C create mode 100644 gcc/testsuite/g++.dg/overload/pmf3.C create mode 100644 gcc/testsuite/g++.dg/parse/new-placement1.C create mode 100644 gcc/testsuite/g++.dg/template/nontype27.C create mode 100644 gcc/testsuite/g++.dg/template/pr66686.C create mode 100644 gcc/testsuite/g++.dg/tls/tls_model1.C create mode 100644 gcc/testsuite/g++.dg/torture/pr65914.C create mode 100644 gcc/testsuite/gcc.c-torture/compile/pr65803.c create mode 100644 gcc/testsuite/gcc.c-torture/execute/20150611-1.c create mode 100644 gcc/testsuite/gcc.c-torture/execute/pr65956.c create mode 100644 gcc/testsuite/gcc.c-torture/execute/pr66757.c create mode 100644 gcc/testsuite/gcc.dg/debug/dwarf2/pr66482.c create mode 100644 gcc/testsuite/gcc.dg/fold-and-1.c create mode 100644 gcc/testsuite/gcc.dg/fold-and-2.c create mode 100644 gcc/testsuite/gcc.dg/fold-ior-1.c create mode 100644 gcc/testsuite/gcc.dg/fold-ior-2.c create mode 100644 gcc/testsuite/gcc.dg/fold-ior-3.c create mode 100644 gcc/testsuite/gcc.dg/fold-minus-2.c create mode 100644 gcc/testsuite/gcc.dg/fold-minus-3.c create mode 100644 gcc/testsuite/gcc.dg/fold-minus-4.c create mode 100644 gcc/testsuite/gcc.dg/fold-minus-5.c create mode 100644 gcc/testsuite/gcc.dg/fold-minus-6.c create mode 100644 gcc/testsuite/gcc.dg/fold-plus-1.c create mode 100644 gcc/testsuite/gcc.dg/fold-plus-2.c create mode 100644 gcc/testsuite/gcc.dg/fold-xor-4.c create mode 100644 gcc/testsuite/gcc.dg/fold-xor-5.c copy gcc/testsuite/gcc.dg/{parloops-exit-first-loop-alt-3.c => parloops-exit-first-loop-alt-5.c} (50%) copy gcc/testsuite/gcc.dg/{parloops-exit-first-loop-alt-3.c => parloops-exit-first-loop-alt-6.c} (51%) copy gcc/testsuite/gcc.dg/{parloops-exit-first-loop-alt-3.c => parloops-exit-first-loop-alt-7.c} (53%) create mode 100644 gcc/testsuite/gcc.dg/parloops-exit-first-loop-alt-pr66652.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr66733-1.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr66733-2.c create mode 100644 gcc/testsuite/gcc.dg/torture/pr66759.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr64130.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr66449.c create mode 100644 gcc/testsuite/gcc.dg/tree-ssa/ssa-dom-cse-4.c create mode 100644 gcc/testsuite/gcc.dg/vect/pr66253.c create mode 100644 gcc/testsuite/gcc.dg/vect/pr66636.c create mode 100644 gcc/testsuite/gcc.dg/vect/pr66677.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-perm-11.c create mode 100644 gcc/testsuite/gcc.dg/vect/slp-perm-12.c create mode 100644 gcc/testsuite/gcc.dg/vect/vect-ifcvt-11.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vget_lane.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrecpe.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrecps.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vreinterpret.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrev.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrshl.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrshr_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrshrn_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrsqrte.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrsqrts.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vrsra_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vset_lane.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vshl_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vshll_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vshr_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vshrn_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vsra_n.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vst1_lane.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vstX_lane.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vtbX.c create mode 100644 gcc/testsuite/gcc.target/aarch64/advsimd-intrinsics/vtst.c create mode 100644 gcc/testsuite/gcc.target/aarch64/arm_align_max_pwr.c create mode 100644 gcc/testsuite/gcc.target/aarch64/arm_align_max_stack_pwr.c rename gcc/testsuite/gcc.target/aarch64/{fmovd-zero.c => fmovd-zero-mem.c} (61%) create mode 100644 gcc/testsuite/gcc.target/aarch64/fmovd-zero-reg.c rename gcc/testsuite/gcc.target/aarch64/{fmovf-zero.c => fmovf-zero-mem.c} (61%) copy gcc/testsuite/gcc.target/aarch64/{clz.c => fmovf-zero-reg.c} (56%) create mode 100644 gcc/testsuite/gcc.target/aarch64/fmovld-zero-mem.c create mode 100644 gcc/testsuite/gcc.target/aarch64/fmovld-zero-reg.c create mode 100644 gcc/testsuite/gcc.target/aarch64/fnmul-1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/fnmul-2.c create mode 100644 gcc/testsuite/gcc.target/aarch64/fnmul-3.c create mode 100644 gcc/testsuite/gcc.target/aarch64/fnmul-4.c create mode 100644 gcc/testsuite/gcc.target/aarch64/mgeneral-regs_1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/mgeneral-regs_2.c create mode 100644 gcc/testsuite/gcc.target/aarch64/mgeneral-regs_3.c create mode 100644 gcc/testsuite/gcc.target/aarch64/nofp_1.c create mode 100644 gcc/testsuite/gcc.target/aarch64/pic-small.c create mode 100644 gcc/testsuite/gcc.target/aarch64/pr62308.c create mode 100644 gcc/testsuite/gcc.target/aarch64/vect-add-sub-cond.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align1.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align2.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align3.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align4.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align_rec1.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align_rec2.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align_rec3.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align_rec4.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align_vaarg1.c create mode 100644 gcc/testsuite/gcc.target/arm/aapcs/align_vaarg2.c create mode 100644 gcc/testsuite/gcc.target/arm/armv8-sync-comp-swap.c create mode 100644 gcc/testsuite/gcc.target/arm/armv8-sync-op-acquire.c create mode 100644 gcc/testsuite/gcc.target/arm/armv8-sync-op-full.c create mode 100644 gcc/testsuite/gcc.target/arm/armv8-sync-op-release.c create mode 100644 gcc/testsuite/gcc.target/arm/flip-thumb.c create mode 100644 gcc/testsuite/gcc.target/arm/pr63408.c create mode 100644 gcc/testsuite/gcc.target/i386/asm-flag-0.c create mode 100644 gcc/testsuite/gcc.target/i386/asm-flag-1.c create mode 100644 gcc/testsuite/gcc.target/i386/asm-flag-2.c create mode 100644 gcc/testsuite/gcc.target/i386/asm-flag-3.c create mode 100644 gcc/testsuite/gcc.target/i386/asm-flag-4.c create mode 100644 gcc/testsuite/gcc.target/i386/asm-flag-5.c create mode 100644 gcc/testsuite/gcc.target/i386/cmov9.c copy gcc/testsuite/gcc.target/{x86_64/abi/abi-x86_64.exp => i386/iamcu/abi-iamcu.exp} (60%) create mode 100644 gcc/testsuite/gcc.target/i386/iamcu/args.h create mode 100644 gcc/testsuite/gcc.target/i386/iamcu/asm-support.S copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/defines.h (63%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/macros.h (100%) create mode 100644 gcc/testsuite/gcc.target/i386/iamcu/test_3_element_struct_and_unions.c create mode 100644 gcc/testsuite/gcc.target/i386/iamcu/test_basic_64bit_returning.c copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_basic_alignment.c (77%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_basic_array_size_and_align.c (76%) create mode 100644 gcc/testsuite/gcc.target/i386/iamcu/test_basic_returning.c copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_basic_sizes.c (85%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_basic_struct_size_and_align.c (79%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_basic_union_size_and_align.c (78%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_bitfields.c (99%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_complex_returning.c (100%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_passing_floats.c (88%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_passing_integers.c (93%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_passing_structs.c (50%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_passing_structs_and_unions.c (77%) copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_passing_unions.c (87%) create mode 100644 gcc/testsuite/gcc.target/i386/iamcu/test_struct_returning.c copy gcc/testsuite/gcc.target/{x86_64/abi => i386/iamcu}/test_varargs.c (81%) create mode 100644 gcc/testsuite/gcc.target/i386/mpx/pr66567.c create mode 100644 gcc/testsuite/gcc.target/i386/mpx/pr66568.c create mode 100644 gcc/testsuite/gcc.target/i386/mpx/pr66569.c create mode 100644 gcc/testsuite/gcc.target/i386/mpx/pr66581.c create mode 100644 gcc/testsuite/gcc.target/i386/pr53383-1.c create mode 100644 gcc/testsuite/gcc.target/i386/pr53383-2.c create mode 100644 gcc/testsuite/gcc.target/i386/pr53383-3.c create mode 100644 gcc/testsuite/gcc.target/i386/pr56766-1.c create mode 100644 gcc/testsuite/gcc.target/i386/pr56766-2.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66412.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66560-1.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66560-2.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66560-3.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66560-4.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66691.c create mode 100644 gcc/testsuite/gcc.target/i386/pr66746.c copy gcc/testsuite/gcc.target/i386/{addr-sel-1.c => pr66749.c} (69%) create mode 100644 gcc/testsuite/gcc.target/mips/pr65862-1.c create mode 100644 gcc/testsuite/gcc.target/mips/pr65862-2.c create mode 100644 gcc/testsuite/gcc.target/nios2/gprel-offset.c copy gcc/testsuite/gcc.target/{arc/arc.exp => nvptx/nvptx.exp} (86%) create mode 100644 gcc/testsuite/gcc.target/nvptx/proto-1.c create mode 100644 gcc/testsuite/gcc.target/powerpc/shift-int.c create mode 100644 gcc/testsuite/gcc.target/powerpc/vec-cmp.c create mode 100644 gcc/testsuite/gcc.target/s390/pr66306.c create mode 100644 gcc/testsuite/gcc.target/s390/vector/vec-abi-attr-1.c create mode 100644 gcc/testsuite/gcc.target/s390/vector/vec-abi-attr-2.c create mode 100644 gcc/testsuite/gcc.target/s390/vector/vec-abi-attr-3.c create mode 100644 gcc/testsuite/gcc.target/s390/vector/vec-abi-attr-4.c create mode 100644 gcc/testsuite/gcc.target/s390/vector/vec-abi-attr-5.c create mode 100644 gcc/testsuite/gcc.target/s390/vector/vec-abi-attr-6.c create mode 100644 gcc/testsuite/gcc.target/vax/bswapdi-1.c create mode 100644 gcc/testsuite/gfortran.dg/alloc_comp_class_3.f03 create mode 100644 gcc/testsuite/gfortran.dg/alloc_comp_class_4.f03 create mode 100644 gcc/testsuite/gfortran.dg/associate_18.f08 create mode 100644 gcc/testsuite/gfortran.dg/gomp/omp_parallel_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/gomp/pr66633.f90 create mode 100644 gcc/testsuite/gfortran.dg/iomsg_2.f90 create mode 100644 gcc/testsuite/gfortran.dg/maxerrors.f90 create mode 100644 gcc/testsuite/gfortran.dg/pr56520.f90 create mode 100644 gcc/testsuite/gfortran.dg/pr66545_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/pr66545_2.f90 create mode 100644 gcc/testsuite/gfortran.dg/pr66725.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_1.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_2.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_3.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_4.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_5.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_6.f90 create mode 100644 gcc/testsuite/gfortran.dg/submodule_7.f90 create mode 100644 gcc/testsuite/gfortran.dg/vect/vect-9.f90 create mode 100644 gcc/testsuite/gfortran.dg/warn_conversion_8.f90 create mode 100644 gcc/testsuite/gfortran.dg/wunused-parameter.f90 create mode 100644 gcc/testsuite/gfortran.fortran-torture/compile/pr66251-2.f90 create mode 100644 gcc/testsuite/gnat.dg/debug4.adb create mode 100644 gcc/testsuite/gnat.dg/debug4_pkg.adb create mode 100644 gcc/testsuite/gnat.dg/debug4_pkg.ads create mode 100644 gcc/testsuite/gnat.dg/lto17.adb create mode 100644 gcc/testsuite/gnat.dg/lto17.ads create mode 100644 gcc/testsuite/gnat.dg/warn12.adb create mode 100644 gcc/testsuite/gnat.dg/warn12_pkg.ads create mode 100644 gcc/testsuite/jit.dg/test-compound-assignment.c create mode 100644 gcc/testsuite/jit.dg/test-debug-strings.c create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-NULL-case.c create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-mismatching-case-type.c create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_block_end_with_switch-overlapping-ranges.c create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-const-label.c create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-non-integer-type.c create mode 100644 gcc/testsuite/jit.dg/test-error-gcc_jit_context_new_case-reversed-endpoints.c copy gcc/testsuite/jit.dg/{test-error-accessing-field-in-other-struct.c => test-error-gcc_jit_lvalue_access_field-wrong-struct.c} (59%) copy gcc/testsuite/jit.dg/{test-error-accessing-field-in-other-struct.c => test-error-gcc_jit_rvalue_access_field-wrong-struct.c} (59%) rename gcc/testsuite/jit.dg/{test-error-accessing-field-in-other-struct.c => test-error-gcc_jit_rvalue_dereference_field-wrong-struct.c} (100%) copy gcc/testsuite/jit.dg/{test-dot-product.c => test-extra-options.c} (91%) create mode 100644 gcc/testsuite/jit.dg/test-pr66700-observing-write-through-ptr.c create mode 100644 gcc/testsuite/jit.dg/test-switch.c create mode 100644 gcc/testsuite/jit.dg/test-switch.cc copy gcc/testsuite/jit.dg/{test-error-unreachable-block.c => test-validly-unreachable-block.c} (80%) create mode 100644 gcc/tree-hash-traits.h create mode 100644 gcc/typed-splay-tree.h create mode 100644 libgcc/config/i386/32/t-iamcu create mode 100644 libgcc/config/t-softfp-sfdftf delete mode 100644 libgfortran/fmain.c create mode 100644 libgomp/testsuite/libgomp.c++/pr66702-1.C create mode 100644 libgomp/testsuite/libgomp.c++/pr66702-2.C copy libgomp/testsuite/libgomp.c/{parloops-exit-first-loop-alt.c => parloops-exit-first-loop-alt-5.c} (50%) copy libgomp/testsuite/libgomp.c/{parloops-exit-first-loop-alt.c => parloops-exit-first-loop-alt-6.c} (50%) copy libgomp/testsuite/libgomp.c/{parloops-exit-first-loop-alt.c => parloops-exit-first-loop-alt-7.c} (50%) create mode 100644 libstdc++-v3/include/debug/helper_functions.h create mode 100644 libstdc++-v3/include/debug/stl_iterator.h create mode 100644 libstdc++-v3/include/experimental/propagate_const create mode 100644 libstdc++-v3/testsuite/20_util/allocator_traits/members/is_always_equal.cc create mode 100644 libstdc++-v3/testsuite/20_util/pair/cons/explicit_construct.cc copy libstdc++-v3/testsuite/20_util/{is_nothrow_swappable/requirements/explicit_instantiation.cc => pair/requirements/dr2367.cc} (68%) create mode 100644 libstdc++-v3/testsuite/20_util/tuple/cons/explicit_construct.cc copy libstdc++-v3/testsuite/20_util/{is_nothrow_swappable/requirements/explicit_instantiation.cc => tuple/requirements/dr2367.cc} (60%) copy libstdc++-v3/testsuite/{27_io/rvalue_streams-2.cc => 23_containers/forward_list/modifiers/addressof.cc} (75%) copy libstdc++-v3/testsuite/23_containers/{forward_list => list}/allocator/copy.cc (88%) copy libstdc++-v3/testsuite/23_containers/{forward_list => list}/allocator/copy_assign.cc (89%) copy libstdc++-v3/testsuite/23_containers/{forward_list => list}/allocator/minimal.cc (87%) copy libstdc++-v3/testsuite/23_containers/{vector => list}/allocator/move.cc (90%) copy libstdc++-v3/testsuite/23_containers/{forward_list => list}/allocator/move_assign.cc (89%) copy libstdc++-v3/testsuite/23_containers/{vector => list}/allocator/noexcept.cc (89%) copy libstdc++-v3/testsuite/23_containers/{forward_list => list}/allocator/swap.cc (91%) copy libstdc++-v3/testsuite/{27_io/rvalue_streams-2.cc => 23_containers/list/modifiers/addressof.cc} (76%) copy libstdc++-v3/testsuite/{20_util/duration/literals/65499.cc => experimental/propagate_const/assignment/copy.cc} (77%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/swap/swap.cc => propagate_const/assignment/move.cc} (56%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/hash/hash.cc => propagate_const/assignment/move_neg.cc} (65%) copy libstdc++-v3/testsuite/{20_util/duration/literals/65499.cc => experimental/propagate_const/cons/copy.cc} (76%) copy libstdc++-v3/testsuite/{25_algorithms/is_permutation/64646.cc => experimental/propagate_const/cons/default.cc} (77%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/swap/swap.cc => propagate_const/cons/move.cc} (53%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/hash/hash.cc => propagate_const/cons/move_neg.cc} (52%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/make_observer.cc => propagate_const/hash/1.cc} (72%) create mode 100644 libstdc++-v3/testsuite/experimental/propagate_const/observers/1.cc create mode 100644 libstdc++-v3/testsuite/experimental/propagate_const/relops/1.cc copy libstdc++-v3/testsuite/experimental/{optional/constexpr/observers/4.cc => propagate_const/requirements1.cc} (58%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/hash/hash.cc => propagate_const/requirements2.cc} (64%) copy libstdc++-v3/testsuite/experimental/{optional/constexpr/observers/1.cc => propagate_const/requirements3.cc} (74%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/make_observer.cc => propagate_const/requirements4.cc} (67%) copy libstdc++-v3/testsuite/experimental/{optional/constexpr/observers/1.cc => propagate_const/requirements5.cc} (74%) copy libstdc++-v3/testsuite/experimental/{memory/observer_ptr/make_observer.cc => propagate_const/swap/1.cc} (75%) copy libstdc++-v3/testsuite/experimental/{any => propagate_const}/typedefs.cc (68%) create mode 100644 libstdc++-v3/testsuite/experimental/type_traits/detection.cc

hooks/post-receive