From patchwork Wed Jul 5 09:19:10 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 21428 Received: (qmail 31628 invoked by alias); 5 Jul 2017 09:19:57 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 31251 invoked by uid 89); 5 Jul 2017 09:19:56 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.3 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, SPF_PASS autolearn=ham version=3.3.2 spammy=promotes, interior, represented X-HELO: sesbmg22.ericsson.net Received: from sesbmg22.ericsson.net (HELO sesbmg22.ericsson.net) (193.180.251.48) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 05 Jul 2017 09:19:49 +0000 Received: from ESESSHC020.ericsson.se (Unknown_Domain [153.88.183.78]) by sesbmg22.ericsson.net (Symantec Mail Security) with SMTP id 1B.CA.05732.23FAC595; Wed, 5 Jul 2017 11:19:47 +0200 (CEST) Received: from EUR01-VE1-obe.outbound.protection.outlook.com (153.88.183.145) by oa.msg.ericsson.com (153.88.183.78) with Microsoft SMTP Server (TLS) id 14.3.352.0; Wed, 5 Jul 2017 11:19:25 +0200 Authentication-Results: sourceware.org; dkim=none (message not signed) header.d=none; sourceware.org; dmarc=none action=none header.from=ericsson.com; Received: from elxacz23q12.ki.sw.ericsson.se (192.176.1.81) by DB4PR07MB316.eurprd07.prod.outlook.com (2a01:111:e400:982f::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256_P256) id 15.1.1240.6; Wed, 5 Jul 2017 09:19:24 +0000 From: Simon Marchi To: CC: Simon Marchi Subject: [PATCH 1/4] ax-gdb: Use ax->gdbarch instead of exp->gdbarch, remove unused parameters Date: Wed, 5 Jul 2017 11:19:10 +0200 Message-ID: <1499246353-18486-2-git-send-email-simon.marchi@ericsson.com> In-Reply-To: <1499246353-18486-1-git-send-email-simon.marchi@ericsson.com> References: <1499246353-18486-1-git-send-email-simon.marchi@ericsson.com> MIME-Version: 1.0 X-ClientProxiedBy: AM4PR07CA0005.eurprd07.prod.outlook.com (2603:10a6:205:1::18) To DB4PR07MB316.eurprd07.prod.outlook.com (2a01:111:e400:982f::24) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 5fa20a49-afb1-4cf5-1da3-08d4c386edbc X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(300000500095)(300135000095)(300000501095)(300135300095)(22001)(300000502095)(300135100095)(300000503095)(300135400095)(201703131423075)(201703031133081)(300000504095)(300135200095)(300000505095)(300135600095)(300000506095)(300135500095); SRVR:DB4PR07MB316; X-Microsoft-Exchange-Diagnostics: 1; DB4PR07MB316; 3:8UkaZKjg9zRsqmzTmgEcF7EFWvO3poWgiqKcMsezlSjA/5kkS0rNfzOzQfVewE4OWbV140ky8Buy5ktG5kzEZ+OEIcacYDtguFNSaNa1nJxxCBQz3sb9/U3WLtyA1gBH/J80ARA9CX1HpxNaQslN7VJsEvDktjHOvZqttVjIB5316NAjxwOPsiJ26Zl+t1w/sIXscClL3vzZkkbE5qXsapFPm7SU05dnWMd7JzbqSOveXQDOWSK/1wDZM62qFsJjcBmWgSQTkV+cJcJ3F0rxaYla2kI+E0VpdNnbdCokRMr7TcBRdyyiunKyM7U9dU8nGmHauK57nnBgQepB8WCxvdxEGT/ZQ3hmdpVzO2aiIuHcz9oqL4Gq8I5Y5Ybqz0h5skNhcc8bp71aHDKjoCSBBkyRF8wQdO521hfUTLeACyoFC5jvh7i5TxIVr3LwhLeC8xuv08StMZ3587whhTg/Qvwezs/QxSxVoXKOu+i1U+6Ayqou/2MjSqtfneF/WdyVhgZWVvCLKaN2AfbDtuDnM2tj4eebMy22rRjf+JZjV4pwUdf6I9PJ4WXS/EKi9vS0U0ajN13Z8b888UEqSSdxBEyI49XIfhtg8L3YztqiLOcp4UlPdb5ewZPsHvaKlfheLLiYpMPOvoGG1CsJmk9LyyZnuqCoHl7f4yWDw/NwHNVOe5oX5dc8pGhQcrh8oVxlyudQnI7vgWmjG+IM65e/xHHU941dpGHi7bhUlkT6fBY/p6cIWdpSSqik42hp5zWo X-MS-TrafficTypeDiagnostic: DB4PR07MB316: X-Microsoft-Exchange-Diagnostics: 1; DB4PR07MB316; 25:p912qqcm9oiA5vG9y0jlUfJGYAoRJGVYhAW6h68rI49GLDbnsIhON1V+lQXVLXOVHLbb965OGo3GjyiS7+d1h9wSC7tAOzYt7DYtRTtlieSEpNHNaE6s7fZVgaXpM//kbTXgvUs7LU7OCDDJrRjyVtUbOLEHKs4V5hDLO/BcnIicWXsw5Hu+1qCafBFIR2UzxjcBh8ff82e/Y3ruaSoF9QbMN3VOV+w/Xm0WnGBhNfNQxCysBYRDhtGXL8WjfmJjUAYMAa7xX0gDuxqgSWXDQQEkRrH4y6akb9sH5Ye1P+4hqH3TgppAEu4HFSTtI+apgbdfWplhBKRSfOzyK4Ulm/xQ7jhNBqAzHxngdGCPSAK9a/i5hAovkUW4c38ryB4KJVgFSteW+7UhQFv4SblSYNRtV5gGFnhfAi9IqkmfqxyGsd163m5IgQE1S5n7Qo8R5l0acq0P4ly12ag+3w8xkTPVj2wQFSZfRrruLXQuwf4W/9lUzOzYo3BbuQ67djuCuIQ3cq3Q1RaT1oeDekLO5zrmk8WQSFVe2zj7HhJal0aASqbxj27/XB7xcG0gbStOzXAYdlJYNZqCFb80NX+CmeqdoyTCfKNeI0Os/1qddyPp9+W8cZOMw0PaLH3BSSFZ0nIZOEJqMiWnmhqr6Bf0s5+VIGDqbDwAGxtSnrPA4PkoxaUCAx66xU0wD3fggN3/sM2tzmpaiZzSh2wrGd+84RgIwzN40jELfVv83J2v9oSNPZnrwu713OqBVWsCADwOSnI/8U8QwKsntcKwu0KfFelyZOLbWO1i5Uv5Jz52RweaIDk5FoPGpJlw6Rorollt0TacmbbERUBHWdeYIHgcEAs5LzqhR98UPwadPkW3pnL9nkZ4z+uqyF/qG2m3jBrSZL5v5MtovX8mVJFjbKIyUKh7Ryw9CRsmyowGU6bHpec= X-Microsoft-Exchange-Diagnostics: 1; DB4PR07MB316; 31:LjDpWYto8GxN2vkfiseBw98cFt0hwuy8IGSdJaPzyISgShShoCTXjM1ENXEEUfDO7lPdjm4aEUmAfq9tBZn9oaocoafQFOP+A1gOaGxrpNihYBDjGy3vGXFpJZy2IDlga5Cd52bnEFUCP9NvBaaH8fHOP+0KE71CS7HrY+3fulUwAn5SNERjdbsGliNWMtAH3hhEu17w5K2iiZjqQr3ZK67PbOZNrDlrYMKU6JzjlfeAqrFh8SdwVwPO5rg2cXIXi3NPsEzeVF7AOCL9Ijn/D1GM0xHhnQqQ7vpdi6mYoD+bgDOJvVZXQ8B2kKv+JLHBwIkQtuQWmMhYmnouI+JtklXFMkVAq821iEaS6jFr0RzpUdB3gGqaYi7T1PgH4uy8R3D/IYgvwHFqiOMCcO8knz57Sm/nFuUv20qlAevMS4obJo1bmbyw3PXnNKKHp18phlFfjrR9gqZp1uvOjTzBwktXCnzh7QRtTLs8l8nmJys/cVl+nCOBKufjqniWxc8ZkHTwoDFBaPmvgLQzjy6fT2KHkneExxVOwwPuqfCoxVsXv4MxTK9o+kId6zJ8/mm2iR9Oz45WGDEl2zaRqDbXzPUzjOIp5BruHyyrgORUUZ7vgwLnmUfnc/CHOfcDU9y8a32df+MqB/f/n8H/S5dSnjzTPh5xbzMuFGdsAuQr04A= X-Microsoft-Exchange-Diagnostics: 1; DB4PR07MB316; 20:RZLL1aG3ZiLEu69X3ljA7gktmbclf01BzNsIV+XDEOM2misa3fcczslJn9zez8H9BU0cHvHTj/DOMKSw9HZVwwFGO4Bhr81ivT8CsGw1xAi4wUD1UhDlw7qWlLrzs/t64Bv9G82seOJ8yUTM5/ZaC8Mr8cTqIp8uE3qtg8An0upYKAICywt811pY6r66TkIXgM3eC1NxjlWBxisjfEqf8G2xOPqW4VLIOR4OMhgNIPEDmaIaM1nXans4JolFgZAlI/mJrnPLl9vtLu5TCGxJhP2HFjVJJLqZ93/+H3f6lQLDGyO5xAaarZlmghr+RvytCW31i7GC0nGDYdPpmfhmFuARUrdT/hcRagy/n0iEw2e+tdmC6rtdZzeT7aWhUuESeZdikYwQgtDOZ5nmQT303f/UwOKkyIqxeADLoFC/f6P34iDVoDuK1eAnqienWweKweTuFQfHSMS01vBtF2aE0uzIiZJ2RQM0n+KiX/lx8mqL97AkT6i6YXxpPSIFK1dP X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(133145235818549)(236129657087228)(167848164394848); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(100000700101)(100105000095)(100000701101)(100105300095)(100000702101)(100105100095)(6040450)(601004)(2401047)(8121501046)(5005006)(10201501046)(3002001)(93006095)(93001095)(100000703101)(100105400095)(6041248)(20161123562025)(20161123555025)(201703131423075)(201702281528075)(201703061421075)(201703061406153)(20161123564025)(20161123558100)(20161123560025)(6072148)(100000704101)(100105200095)(100000705101)(100105500095); SRVR:DB4PR07MB316; BCL:0; PCL:0; RULEID:(100000800101)(100110000095)(100000801101)(100110300095)(100000802101)(100110100095)(100000803101)(100110400095)(100000804101)(100110200095)(100000805101)(100110500095); SRVR:DB4PR07MB316; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DB4PR07MB316; 4:oZDTJfG+tPJOoip30CPB3kVWoK4ge1NLwWnE3SIvUaN?= =?us-ascii?Q?1G/Enn7wTVsXShh5plzuI6AgSDWybasUQdTcKZm+xv0fg03T6kUaRHgJ4BmT?= =?us-ascii?Q?oSTdVoqoiPvUuF9NsXcpYpFvH7GIWWj9ZDLCHMBKquJK0XunOQifu4nWaE8N?= =?us-ascii?Q?ZpfvGCLriZTmgza8oI+pfDLWdx0u9A4G6+TIOJSiQKHvhOkvwUMZwiNle9GG?= =?us-ascii?Q?tYg3ilSAAjt8GNttdlMh7Xaf9noH4UnlrNAD3gefl6it+iowF7bBIEzLiymw?= =?us-ascii?Q?HsjHrQnawzXWk2dthRN+FuTtGg4yHmUHHo1vBXH5jUR81YFZKeniG7Fh2JGJ?= =?us-ascii?Q?chaXI6TG/38lfGmfrIYb+FsPZkGUlfwy6w9Wxvyod3np3QkTqQUA3hi5w+Nk?= =?us-ascii?Q?VOryLNd6DCUI0CW4UcnmQVOaHnMklxGVWM6F5dNTozbgoxT27H6dqizRqY9y?= =?us-ascii?Q?kvjQrf281O2t1FXQZB9+V/6Wv+QW/KKTFrMQXVUX0dDh7OJ2QavoYOsyaWNY?= =?us-ascii?Q?AbhxXgB4J6vHa86yLPn98nk7+StLhgKsBkklTOzm29rOUOhaNvV5jlX6RXjX?= =?us-ascii?Q?S1WxxidUiBaRWUZEqrOCLl51vMBny/duJqKwNKOAiJiQ2K9w9Ghj9jhfbrkX?= =?us-ascii?Q?Ae3yEZG5KmNz7M7VymhfyUrSHoXooAaf6wFX6+8ytDzX4UNtMywGFgJl9M9T?= =?us-ascii?Q?bqPIaRXl+bcXL7GeKBIGlZCORTRqNYcgNuZ6LxbwCQ3pbTga4Q9JUQXI8ly5?= =?us-ascii?Q?xlfvhWYu9ygRh8Sfdm+D0Boklhbvz2uSh6CVu7sNrrrlajS/86jG/iYPYuxQ?= =?us-ascii?Q?cLzsH6+zXWSjpmBNBtWnA9pNlMohEDi6vxP89mB6cHAbIAWli1MrSHM+LybI?= =?us-ascii?Q?/LigC0hCQLD0ja4JIYygBLh6pPV8dzG0t20+GG11ByF866ugt/Mq/j/9JKcL?= =?us-ascii?Q?4elW+g5NqY/C1wbh8Fw9lOxYvTgDS/HzHcKZtEGOuFZy1QDIB/iX8BStjoFe?= =?us-ascii?Q?g8ZrUL479mSKp2MAvb7PuQgZo2X+6RVnYmiV6kVEKt3Q9gi6gjUTz6DTFP4k?= =?us-ascii?Q?Sypu5A1j5Z58xw6nJxdx+EZzxf3GBZdN5QCIYsOKci3N/pwoG57d3Jv5tBoE?= =?us-ascii?Q?HdzHnBV0Z831hKilaBTJaHyL80NHKs4b0bBPRR0ZupXoFeN9DOjyBPWA5O4A?= =?us-ascii?Q?DFLFpQ7FV9MdTHUZBc7adCS/l1OPro3V3AKhD1AW6a4+hVvr2ov9I6MF7ppZ?= =?us-ascii?Q?P0BWA7qOwaPyaeRI=3D?= X-Forefront-PRVS: 0359162B6D X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(6009001)(39840400002)(39850400002)(39400400002)(39860400002)(39410400002)(39450400003)(110136004)(42186005)(38730400002)(478600001)(107886003)(6486002)(53936002)(2950100002)(6512007)(6916009)(7736002)(5003940100001)(33646002)(48376002)(5660300001)(50466002)(36756003)(47776003)(25786009)(189998001)(6116002)(76176999)(305945005)(3846002)(2351001)(50986999)(4326008)(2906002)(50226002)(8676002)(6666003)(6506006)(81166006)(86362001)(2361001)(66066001); DIR:OUT; SFP:1101; SCL:1; SRVR:DB4PR07MB316; H:elxacz23q12.ki.sw.ericsson.se; FPR:; SPF:None; MLV:sfv; LANG:en; X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DB4PR07MB316; 23:TrV7N5UJHiWmot1L62qB6wKQVo5coia9XtoegaRXKR?= =?us-ascii?Q?+5fMg3J/76vWTBsoXRHHHEve4GLFoj+skBEXfVB2yWPW1k5pzDPLEZiQWMgz?= =?us-ascii?Q?OR10OwJNngShJkr5jC5fw+jk2juVCh2oL8/WWhfsQXqcm2lP7h/JQ2JwdgSy?= =?us-ascii?Q?z7y0eg4SbQdBNGhJLf770r4bzcYhpHZk0DJrd8lYer7z/yDv8lxPAQHvQt2S?= =?us-ascii?Q?tyUCSiuNh35I6df+F2V+lWHgCbxE30voETiABCScFFiiRmBh9FYKCEGMX2cP?= =?us-ascii?Q?Cc6mXkYNLSeZjtMMstjZC2s/Au9z714iJwSrFeurcA1nqeJoFSxnxfciLbot?= =?us-ascii?Q?oMLLi5Gw0AcDrkrg+vkKcLnVFWu++sRfJiLEabw8L/A4brk64frRi6xgqeEU?= =?us-ascii?Q?fbfBjkgWriT6ArbsS763g8gT0UlP8sTTf78Vt+zUFnhwRvizZOK7uhHZhyem?= =?us-ascii?Q?tB6HerRSVnVRZZbSFm5DGHEtNpb9RSsQ16TixpEhQ7dWrdDRToVO/yeGGP6+?= =?us-ascii?Q?NBNBxokURzrq0hfIgJOYrYkWBdceN8AZQ4mjcsrjw4EP4ghx8zFXuE8xkj9O?= =?us-ascii?Q?DNiwEyhmcDTuWzfwLZ0qx1TCD+Qmx7gQDBDccsGRQIjwZ5z/bIYoDamjjyP2?= =?us-ascii?Q?CaunD+2rqkFCJMR/rPGXJHd7W40AW+itHQuK+PVTYZNiRWcoiy4oJuXfpVLM?= =?us-ascii?Q?Yxn2DYg7e3NpQ/pwbx5UwHMoO38H71Sf3UtUCDAIEe8Cl9++vRuc5X/o8f4y?= =?us-ascii?Q?MoDMiJmtOzFSSipyFyqi7/nFbu97e3xyCuaWN3+BJLFZayOTCWDn0gU5mKp4?= =?us-ascii?Q?zoSlPYYN2fQQVyjtr3fElI1QAhXKEWuTX8tfFYLRkfBTmSoR3rAgFqAjB76c?= =?us-ascii?Q?0Bd+0zBsrJlyp6jKyrZ27tXGtqqi9pZd2eYiMpECy79OqpH6q/22DJaSz8gq?= =?us-ascii?Q?da9ksQGU7Zmg5nvpI1o2OakJmZh/RqECWarYgTWPNOdXTIgU4ywrnArKoIt5?= =?us-ascii?Q?bWMIUAc6nl6J/ZoKFK+/PUbc3tF1RU2kjDwDZ/kFWGE61elgU68jOu7UWQGJ?= =?us-ascii?Q?8eUwb+jstks5if9hUq8GUsnFAMb6eUPiAzQMMf2hZLrpvVXm6S09JIXe/nGG?= =?us-ascii?Q?RMl6e9CgU=3D?= X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; DB4PR07MB316; 6:Py7aWs3pm6f+MDmUv0+TJcdl21I0GiLMoqlTC1Jfv9c?= =?us-ascii?Q?60CnAb78jy1seWq+q1YFR9mAoNyiw9cwdLc+sMtUTDvGrqIIQys/q7kilasc?= =?us-ascii?Q?kYA9iX0qA2L1igughEL2Qx3QOGdQzwIhtJ71H6GGJnI7sxWPRAcs6XYzKDhn?= =?us-ascii?Q?kVZUQFeQ0QQFFnv/YIW/UfIWr1l7O2jmzDaHs8TzODlyAyWR4QmyIqFm/Xpt?= =?us-ascii?Q?g/rx9nYSBTIS74RnGlu45Qx0VAfO/znRlu89tX+xH1zvbNBKZgZeJ11pLQB8?= =?us-ascii?Q?VDzKGTaAGpRz2RsxJJWRjVK/9DSgM22OrnDg+1ivoO1j6LBrO3fjxGbkIsmx?= =?us-ascii?Q?dRVDCOsL+hw1TIMlEJYDEXfyxPbiU5Ub3lO/ZS1jmclol42KRLMgjJ5MZnss?= =?us-ascii?Q?/duxO7k0rKakD9swjo6RwDnl+RGPrTe/aZAL3PlCAVezJBRngr3xHSfHFexn?= =?us-ascii?Q?RO3z4xrexqpKdLYHHCbGFeSHO9Rd+IVdUDa7MwtwCXSODi7iv6uZnHA/HV0t?= =?us-ascii?Q?7ik5glq8D6Ld+Pv3KBkDk7HkeKJTxxqJASzl1JbOQJa4evNUSJ3smtNl7jvM?= =?us-ascii?Q?00vG1ilzXHrx2tpMi+IEMD8hHuLrL+OulCtA7yXSlW5DunzEwgv/22amdvc6?= =?us-ascii?Q?vHp9OpQMd25RY/0LNSjPq3U2yiJsX5dglZx9Yn1FNK863Vhm2dRhdbItxjh+?= =?us-ascii?Q?hqHkk8oPKBMZPQpHEjLbG1Z9Aq0CISwAfAIZ3iYhGfpsQO0FjSrzEyCOAix5?= =?us-ascii?Q?lnJohWupNv15V/V09v35Psd6vQKgBqUg6H8pXD4PxHA5jC9IIKNomZK1wFb0?= =?us-ascii?Q?QfFYooqMkfcOuZ6LqqdccV30TQrNkuBx45WZKd96n72aLxRatOgIV0pJd38U?= =?us-ascii?Q?JJ8ES6/vmxh/xlLjoSZIAx+5xbIkJ9ZhQRj90JZZ05InXLzNEPcNO3Er7Fz8?= =?us-ascii?Q?JmNe9uO8TvidA0bt/ARwVts24RvYMGlY5g+MC7mIu72FqXhBD9/0Nu4wCfl4?= =?us-ascii?Q?=3D?= X-Microsoft-Exchange-Diagnostics: 1; DB4PR07MB316; 5:M+3hNMFl967uD27MITraYyCCQMN1S8vpy0+KBkYB+j6T+UViIO/SS0ZA6VoNICccjDYKv4ehZP7aGD0jv7tOpdYoBBi8t03dzGctIDU4Zw66bnXzDvJEOSJzG/sUlQSLe+xnF2M0voZj/z6DybeRWXgzOFOtb8rU/XNQv8qxunCB46jhoEpwDnNcSpOfyQRHnnEh/uY0b6WdXfnGjmOYk5khAWx8IC9mM560K1hoGo3K9R5AZQlnHEEqGvxJfP82dOgieQy21NkQO62iAYWFdpYlNJxF5SwnARhzOLXh8HFpsIfTuqPWWBd//O46jadD5tgyhJZvJHnlDFOr8YYc0Vahn5MzsgeSrUoj1u7D/C1NoVFoNk4zZrWwTxROzkXVpygBcc9N9CoS5iwFDuDKvNVl4k0l8pzIMXdRmduraOYnl12Jys+Fri3cTVcHlaoNINpMUNlkgILM52v2NSi31Uulw49LswVoP7BwaurVG207daQ/kS3rT3OuIov+WegH; 24:QxkVKcapPbPLS5B4uZdeJJ8mq3E9hBjCayx6yEYKq5UqLfxxNZ9TyQjQi5SuSvVVfbcVdJKHuBPT0Dk4QRdqGxRQIpz05EPv66MZWXmQyms= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; DB4PR07MB316; 7:7fHmN3do1AJt87EUnPmbWkhDmG8/WZ8jnNiYKydFmaN8g43Kbh9oTEBifAigs7SDA86r1INAYDmmvXw5RQxdAMr6MjKj5z2QguyFFiLQVLqji5qI2ixM1ZgWlnkE4nMHBveH52txcrOyfSnZLLiPAzO0ZK+p4RmX8PfCTx1SSJ4yPusud6S7o9JvJl1klWEccGlVbd4bOfLldtHEyeZtLguQ0h49/u5URdlqViG6qpgpcO49cnssDJscCeUhm0C6A/JFUZcA1/N4VSH+zqFWlOfhUQt95/pws7c0aYI7MqvcZJK4lC/FIwzjGDWXVt4aKZD8/9w6WhmxtRuazKer+jgE0TIR6Es2C9sG6Y8jC/xHrXvCXaS8uMDd2/5yb4W+gXK0CEvSNSBxv9k1HfapxrDhP5z6hXz+6C7hbzI8WLv08T5x9hyUxglo7bOOq2e0PIU52gO2/xLgSPLv4CXmiqLQalCWNI159FMo/xV6G+yx4AO3wSIS8UdcPlJG2W6Ougnfg2tM0Onn0OxvCIL9ynmUEbh4TAZ3Upv/JW9rWlC4iobaTzCSJSAiFNXmH9OaMcl+swY3IU9rGJ4aU1NltnxPhxaXU2u1DrTmi5MgvgtmHIWb4OwX/HOA88gQVzHeJYSij47exdFjGMNjlyRkJ5nxmhNaYjFQX1BYnhBPHePYMOlmO6ITcGMLMb7punJkFYhkIAbjWUUEImLJoSGWOdpoAPn78GUrpbBuVt6zKykxuM/u+iR9/sWMrcwYU8ePUbioKQDhZj1GffwpGcMh0d+k6/KvQfAnGwHiLUw6/j4= X-MS-Exchange-CrossTenant-OriginalArrivalTime: 05 Jul 2017 09:19:24.5613 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB4PR07MB316 X-OriginatorOrg: ericsson.com X-IsSubscribed: yes In many ax generation functions, the "expression *exp" parameter is only used to access the gdbarch. The same value can be found in the "agent_expr *ax" parameter, which needs to be passed in any case. By using ax->gdbarch instead of exp->gdbarch, we can avoid passing exp in many of these functions. gdb/ChangeLog: * ax-gdb.c (gen_usual_unary): Remove exp parameter, get gdbarch from ax, update calls. (gen_usual_arithmetic): Likewise. (gen_integral_promotions): Likewise. (gen_bitfield_ref): Likewise. (gen_primitive_field): Likewise. (gen_struct_ref_recursive): Likewise. (gen_struct_ref): Likewise. (gen_maybe_namespace_elt): Likewise. (gen_struct_elt_for_reference): Likewise. (gen_namespace_elt): Likewise. (gen_aggregate_elt_ref): Likewise. (gen_expr): Get gdbarch from ax, update calls. (gen_expr_binop_rest): Likewise. --- gdb/ax-gdb.c | 164 ++++++++++++++++++++++++++--------------------------------- 1 file changed, 73 insertions(+), 91 deletions(-) diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c index fae2e2d..3ec87af 100644 --- a/gdb/ax-gdb.c +++ b/gdb/ax-gdb.c @@ -98,19 +98,16 @@ static void gen_int_literal (struct agent_expr *ax, struct axs_value *value, LONGEST k, struct type *type); -static void gen_usual_unary (struct expression *exp, struct agent_expr *ax, - struct axs_value *value); +static void gen_usual_unary (struct agent_expr *ax, struct axs_value *value); static int type_wider_than (struct type *type1, struct type *type2); static struct type *max_type (struct type *type1, struct type *type2); static void gen_conversion (struct agent_expr *ax, struct type *from, struct type *to); static int is_nontrivial_conversion (struct type *from, struct type *to); -static void gen_usual_arithmetic (struct expression *exp, - struct agent_expr *ax, +static void gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, struct axs_value *value2); -static void gen_integral_promotions (struct expression *exp, - struct agent_expr *ax, +static void gen_integral_promotions (struct agent_expr *ax, struct axs_value *value); static void gen_cast (struct agent_expr *ax, struct axs_value *value, struct type *type); @@ -135,19 +132,16 @@ static void gen_logical_not (struct agent_expr *ax, struct axs_value *value, static void gen_complement (struct agent_expr *ax, struct axs_value *value); static void gen_deref (struct agent_expr *, struct axs_value *); static void gen_address_of (struct agent_expr *, struct axs_value *); -static void gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, - struct axs_value *value, +static void gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, struct type *type, int start, int end); -static void gen_primitive_field (struct expression *exp, - struct agent_expr *ax, +static void gen_primitive_field (struct agent_expr *ax, struct axs_value *value, int offset, int fieldno, struct type *type); -static int gen_struct_ref_recursive (struct expression *exp, - struct agent_expr *ax, +static int gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value, const char *field, int offset, struct type *type); -static void gen_struct_ref (struct expression *exp, struct agent_expr *ax, +static void gen_struct_ref (struct agent_expr *ax, struct axs_value *value, const char *field, const char *operator_name, @@ -818,8 +812,7 @@ require_rvalue (struct agent_expr *ax, struct axs_value *value) lvalue through unchanged, and let `+' raise an error. */ static void -gen_usual_unary (struct expression *exp, struct agent_expr *ax, - struct axs_value *value) +gen_usual_unary (struct agent_expr *ax, struct axs_value *value) { /* We don't have to generate any code for the usual integral conversions, since values are always represented as full-width on @@ -934,8 +927,8 @@ is_nontrivial_conversion (struct type *from, struct type *to) and promotes each argument to that type. *VALUE1 and *VALUE2 describe the values as they are passed in, and as they are left. */ static void -gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax, - struct axs_value *value1, struct axs_value *value2) +gen_usual_arithmetic (struct agent_expr *ax, struct axs_value *value1, + struct axs_value *value2) { /* Do the usual binary conversions. */ if (TYPE_CODE (value1->type) == TYPE_CODE_INT @@ -946,7 +939,7 @@ gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax, unsigned type is considered "wider" than an n-bit signed type. Promote to the "wider" of the two types, and always promote at least to int. */ - struct type *target = max_type (builtin_type (exp->gdbarch)->builtin_int, + struct type *target = max_type (builtin_type (ax->gdbarch)->builtin_int, max_type (value1->type, value2->type)); /* Deal with value2, on the top of the stack. */ @@ -971,10 +964,9 @@ gen_usual_arithmetic (struct expression *exp, struct agent_expr *ax, the value on the top of the stack, as described by VALUE. Assume the value has integral type. */ static void -gen_integral_promotions (struct expression *exp, struct agent_expr *ax, - struct axs_value *value) +gen_integral_promotions (struct agent_expr *ax, struct axs_value *value) { - const struct builtin_type *builtin = builtin_type (exp->gdbarch); + const struct builtin_type *builtin = builtin_type (ax->gdbarch); if (!type_wider_than (value->type, builtin->builtin_int)) { @@ -1249,9 +1241,8 @@ gen_address_of (struct agent_expr *ax, struct axs_value *value) starting and one-past-ending *bit* numbers of the field within the structure. */ static void -gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, - struct axs_value *value, struct type *type, - int start, int end) +gen_bitfield_ref (struct agent_expr *ax, struct axs_value *value, + struct type *type, int start, int end) { /* Note that ops[i] fetches 8 << i bits. */ static enum agent_op ops[] @@ -1376,7 +1367,7 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, the sign/zero extension will wipe them out. - If we're in the interior of the word, then there is no garbage on either end, because the ref operators zero-extend. */ - if (gdbarch_byte_order (exp->gdbarch) == BFD_ENDIAN_BIG) + if (gdbarch_byte_order (ax->gdbarch) == BFD_ENDIAN_BIG) gen_left_shift (ax, end - (offset + op_size)); else gen_left_shift (ax, offset - start); @@ -1409,13 +1400,12 @@ gen_bitfield_ref (struct expression *exp, struct agent_expr *ax, generally follow value_primitive_field. */ static void -gen_primitive_field (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_primitive_field (struct agent_expr *ax, struct axs_value *value, int offset, int fieldno, struct type *type) { /* Is this a bitfield? */ if (TYPE_FIELD_PACKED (type, fieldno)) - gen_bitfield_ref (exp, ax, value, TYPE_FIELD_TYPE (type, fieldno), + gen_bitfield_ref (ax, value, TYPE_FIELD_TYPE (type, fieldno), (offset * TARGET_CHAR_BIT + TYPE_FIELD_BITPOS (type, fieldno)), (offset * TARGET_CHAR_BIT @@ -1434,8 +1424,7 @@ gen_primitive_field (struct expression *exp, base classes. Return 1 if found, 0 if not. */ static int -gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax, - struct axs_value *value, +gen_struct_ref_recursive (struct agent_expr *ax, struct axs_value *value, const char *field, int offset, struct type *type) { int i, rslt; @@ -1457,7 +1446,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax, being handled as a global. */ if (field_is_static (&TYPE_FIELD (type, i))) { - gen_static_field (exp->gdbarch, ax, value, type, i); + gen_static_field (ax->gdbarch, ax, value, type, i); if (value->optimized_out) error (_("static field `%s' has been " "optimized out, cannot use"), @@ -1465,7 +1454,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax, return 1; } - gen_primitive_field (exp, ax, value, offset, i, type); + gen_primitive_field (ax, value, offset, i, type); return 1; } #if 0 /* is this right? */ @@ -1481,7 +1470,7 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax, { struct type *basetype = check_typedef (TYPE_BASECLASS (type, i)); - rslt = gen_struct_ref_recursive (exp, ax, value, field, + rslt = gen_struct_ref_recursive (ax, value, field, offset + TYPE_BASECLASS_BITPOS (type, i) / TARGET_CHAR_BIT, basetype); @@ -1499,9 +1488,9 @@ gen_struct_ref_recursive (struct expression *exp, struct agent_expr *ax, the operator being compiled, and OPERAND_NAME is the kind of thing it operates on; we use them in error messages. */ static void -gen_struct_ref (struct expression *exp, struct agent_expr *ax, - struct axs_value *value, const char *field, - const char *operator_name, const char *operand_name) +gen_struct_ref (struct agent_expr *ax, struct axs_value *value, + const char *field, const char *operator_name, + const char *operand_name) { struct type *type; int found; @@ -1528,7 +1517,7 @@ gen_struct_ref (struct expression *exp, struct agent_expr *ax, error (_("Structure does not live in memory.")); /* Search through fields and base classes recursively. */ - found = gen_struct_ref_recursive (exp, ax, value, field, 0, type); + found = gen_struct_ref_recursive (ax, value, field, 0, type); if (!found) error (_("Couldn't find member named `%s' in struct/union/class `%s'"), @@ -1536,12 +1525,10 @@ gen_struct_ref (struct expression *exp, struct agent_expr *ax, } static int -gen_namespace_elt (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_namespace_elt (struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name); static int -gen_maybe_namespace_elt (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name); static void @@ -1579,8 +1566,7 @@ gen_static_field (struct gdbarch *gdbarch, } static int -gen_struct_elt_for_reference (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_struct_elt_for_reference (struct agent_expr *ax, struct axs_value *value, struct type *type, char *fieldname) { struct type *t = type; @@ -1599,7 +1585,7 @@ gen_struct_elt_for_reference (struct expression *exp, { if (field_is_static (&TYPE_FIELD (t, i))) { - gen_static_field (exp->gdbarch, ax, value, t, i); + gen_static_field (ax->gdbarch, ax, value, t, i); if (value->optimized_out) error (_("static field `%s' has been " "optimized out, cannot use"), @@ -1618,18 +1604,17 @@ gen_struct_elt_for_reference (struct expression *exp, /* FIXME add other scoped-reference cases here */ /* Do a last-ditch lookup. */ - return gen_maybe_namespace_elt (exp, ax, value, type, fieldname); + return gen_maybe_namespace_elt (ax, value, type, fieldname); } /* C++: Return the member NAME of the namespace given by the type CURTYPE. */ static int -gen_namespace_elt (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_namespace_elt (struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name) { - int found = gen_maybe_namespace_elt (exp, ax, value, curtype, name); + int found = gen_maybe_namespace_elt (ax, value, curtype, name); if (!found) error (_("No symbol \"%s\" in namespace \"%s\"."), @@ -1645,8 +1630,7 @@ gen_namespace_elt (struct expression *exp, to, say, some base class of CURTYPE). */ static int -gen_maybe_namespace_elt (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_maybe_namespace_elt (struct agent_expr *ax, struct axs_value *value, const struct type *curtype, char *name) { const char *namespace_name = TYPE_TAG_NAME (curtype); @@ -1659,7 +1643,7 @@ gen_maybe_namespace_elt (struct expression *exp, if (sym.symbol == NULL) return 0; - gen_var_ref (exp->gdbarch, ax, value, sym.symbol); + gen_var_ref (ax->gdbarch, ax, value, sym.symbol); if (value->optimized_out) error (_("`%s' has been optimized out, cannot use"), @@ -1670,8 +1654,7 @@ gen_maybe_namespace_elt (struct expression *exp, static int -gen_aggregate_elt_ref (struct expression *exp, - struct agent_expr *ax, struct axs_value *value, +gen_aggregate_elt_ref (struct agent_expr *ax, struct axs_value *value, struct type *type, char *field, const char *operator_name, const char *operand_name) @@ -1680,10 +1663,10 @@ gen_aggregate_elt_ref (struct expression *exp, { case TYPE_CODE_STRUCT: case TYPE_CODE_UNION: - return gen_struct_elt_for_reference (exp, ax, value, type, field); + return gen_struct_elt_for_reference (ax, value, type, field); break; case TYPE_CODE_NAMESPACE: - return gen_namespace_elt (exp, ax, value, type, field); + return gen_namespace_elt (ax, value, type, field); break; default: internal_error (__FILE__, __LINE__, @@ -1784,7 +1767,7 @@ gen_expr (struct expression *exp, union exp_element **pc, struct axs_value value1, value2, value3; enum exp_opcode op = (*pc)[0].opcode, op2; int if1, go1, if2, go2, end; - struct type *int_type = builtin_type (exp->gdbarch)->builtin_int; + struct type *int_type = builtin_type (ax->gdbarch)->builtin_int; /* If we're looking at a constant expression, just push its value. */ { @@ -1822,7 +1805,7 @@ gen_expr (struct expression *exp, union exp_element **pc, case BINOP_GEQ: (*pc)++; gen_expr (exp, pc, ax, &value1); - gen_usual_unary (exp, ax, &value1); + gen_usual_unary (ax, &value1); gen_expr_binop_rest (exp, op, pc, ax, value, &value1, &value2); break; @@ -1830,12 +1813,12 @@ gen_expr (struct expression *exp, union exp_element **pc, (*pc)++; /* Generate the obvious sequence of tests and jumps. */ gen_expr (exp, pc, ax, &value1); - gen_usual_unary (exp, ax, &value1); + gen_usual_unary (ax, &value1); if1 = ax_goto (ax, aop_if_goto); go1 = ax_goto (ax, aop_goto); ax_label (ax, if1, ax->len); gen_expr (exp, pc, ax, &value2); - gen_usual_unary (exp, ax, &value2); + gen_usual_unary (ax, &value2); if2 = ax_goto (ax, aop_if_goto); go2 = ax_goto (ax, aop_goto); ax_label (ax, if2, ax->len); @@ -1853,10 +1836,10 @@ gen_expr (struct expression *exp, union exp_element **pc, (*pc)++; /* Generate the obvious sequence of tests and jumps. */ gen_expr (exp, pc, ax, &value1); - gen_usual_unary (exp, ax, &value1); + gen_usual_unary (ax, &value1); if1 = ax_goto (ax, aop_if_goto); gen_expr (exp, pc, ax, &value2); - gen_usual_unary (exp, ax, &value2); + gen_usual_unary (ax, &value2); if2 = ax_goto (ax, aop_if_goto); ax_const_l (ax, 0); end = ax_goto (ax, aop_goto); @@ -1871,7 +1854,7 @@ gen_expr (struct expression *exp, union exp_element **pc, case TERNOP_COND: (*pc)++; gen_expr (exp, pc, ax, &value1); - gen_usual_unary (exp, ax, &value1); + gen_usual_unary (ax, &value1); /* For (A ? B : C), it's easiest to generate subexpression bytecodes in order, but if_goto jumps on true, so we invert the sense of A. Then we can do B by dropping through, and @@ -1879,11 +1862,11 @@ gen_expr (struct expression *exp, union exp_element **pc, gen_logical_not (ax, &value1, int_type); if1 = ax_goto (ax, aop_if_goto); gen_expr (exp, pc, ax, &value2); - gen_usual_unary (exp, ax, &value2); + gen_usual_unary (ax, &value2); end = ax_goto (ax, aop_goto); ax_label (ax, if1, ax->len); gen_expr (exp, pc, ax, &value3); - gen_usual_unary (exp, ax, &value3); + gen_usual_unary (ax, &value3); ax_label (ax, end, ax->len); /* This is arbitary - what if B and C are incompatible types? */ value->type = value2.type; @@ -1934,7 +1917,7 @@ gen_expr (struct expression *exp, union exp_element **pc, ax_tsv (ax, aop_tracev, tsv->number); /* Trace state variables are always 64-bit integers. */ value1.kind = axs_rvalue; - value1.type = builtin_type (exp->gdbarch)->builtin_long_long; + value1.type = builtin_type (ax->gdbarch)->builtin_long_long; /* Now do right half of expression. */ gen_expr_binop_rest (exp, op2, pc, ax, value, &value1, &value2); /* We have a result of the binary op, set the tsv. */ @@ -1962,7 +1945,7 @@ gen_expr (struct expression *exp, union exp_element **pc, /* Don't just dispose of the left operand. We might be tracing, in which case we want to emit code to trace it if it's an lvalue. */ - gen_traced_pop (exp->gdbarch, ax, &value1); + gen_traced_pop (ax->gdbarch, ax, &value1); gen_expr (exp, pc, ax, value); /* It's the consumer's responsibility to trace the right operand. */ break; @@ -1978,7 +1961,7 @@ gen_expr (struct expression *exp, union exp_element **pc, break; case OP_VAR_VALUE: - gen_var_ref (exp->gdbarch, ax, value, (*pc)[2].symbol); + gen_var_ref (ax->gdbarch, ax, value, (*pc)[2].symbol); if (value->optimized_out) error (_("`%s' has been optimized out, cannot use"), @@ -1993,19 +1976,19 @@ gen_expr (struct expression *exp, union exp_element **pc, int reg; (*pc) += 4 + BYTES_TO_EXP_ELEM ((*pc)[1].longconst + 1); - reg = user_reg_map_name_to_regnum (exp->gdbarch, name, strlen (name)); + reg = user_reg_map_name_to_regnum (ax->gdbarch, name, strlen (name)); if (reg == -1) internal_error (__FILE__, __LINE__, _("Register $%s not available"), name); /* No support for tracing user registers yet. */ - if (reg >= gdbarch_num_regs (exp->gdbarch) - + gdbarch_num_pseudo_regs (exp->gdbarch)) + if (reg >= gdbarch_num_regs (ax->gdbarch) + + gdbarch_num_pseudo_regs (ax->gdbarch)) error (_("'%s' is a user-register; " "GDB cannot yet trace user-register contents."), name); value->kind = axs_lvalue_register; value->u.reg = reg; - value->type = register_type (exp->gdbarch, reg); + value->type = register_type (ax->gdbarch, reg); } break; @@ -2024,7 +2007,7 @@ gen_expr (struct expression *exp, union exp_element **pc, ax_tsv (ax, aop_tracev, tsv->number); /* Trace state variables are always 64-bit integers. */ value->kind = axs_rvalue; - value->type = builtin_type (exp->gdbarch)->builtin_long_long; + value->type = builtin_type (ax->gdbarch)->builtin_long_long; } else if (! compile_internalvar_to_ax (var, ax, value)) error (_("$%s is not a trace state variable; GDB agent " @@ -2113,40 +2096,40 @@ gen_expr (struct expression *exp, union exp_element **pc, (*pc)++; /* + FOO is equivalent to 0 + FOO, which can be optimized. */ gen_expr (exp, pc, ax, value); - gen_usual_unary (exp, ax, value); + gen_usual_unary (ax, value); break; case UNOP_NEG: (*pc)++; /* -FOO is equivalent to 0 - FOO. */ gen_int_literal (ax, &value1, 0, - builtin_type (exp->gdbarch)->builtin_int); - gen_usual_unary (exp, ax, &value1); /* shouldn't do much */ + builtin_type (ax->gdbarch)->builtin_int); + gen_usual_unary (ax, &value1); /* shouldn't do much */ gen_expr (exp, pc, ax, &value2); - gen_usual_unary (exp, ax, &value2); - gen_usual_arithmetic (exp, ax, &value1, &value2); + gen_usual_unary (ax, &value2); + gen_usual_arithmetic (ax, &value1, &value2); gen_binop (ax, value, &value1, &value2, aop_sub, aop_sub, 1, "negation"); break; case UNOP_LOGICAL_NOT: (*pc)++; gen_expr (exp, pc, ax, value); - gen_usual_unary (exp, ax, value); + gen_usual_unary (ax, value); gen_logical_not (ax, value, int_type); break; case UNOP_COMPLEMENT: (*pc)++; gen_expr (exp, pc, ax, value); - gen_usual_unary (exp, ax, value); - gen_integral_promotions (exp, ax, value); + gen_usual_unary (ax, value); + gen_integral_promotions (ax, value); gen_complement (ax, value); break; case UNOP_IND: (*pc)++; gen_expr (exp, pc, ax, value); - gen_usual_unary (exp, ax, value); + gen_usual_unary (ax, value); if (!pointer_type (value->type)) error (_("Argument of unary `*' is not a pointer.")); gen_deref (ax, value); @@ -2164,7 +2147,7 @@ gen_expr (struct expression *exp, union exp_element **pc, of the other unary operator functions. This is because we have to throw away the code we generate. */ gen_sizeof (exp, pc, ax, value, - builtin_type (exp->gdbarch)->builtin_int); + builtin_type (ax->gdbarch)->builtin_int); break; case STRUCTOP_STRUCT: @@ -2176,9 +2159,9 @@ gen_expr (struct expression *exp, union exp_element **pc, (*pc) += 4 + BYTES_TO_EXP_ELEM (length + 1); gen_expr (exp, pc, ax, value); if (op == STRUCTOP_STRUCT) - gen_struct_ref (exp, ax, value, name, ".", "structure or union"); + gen_struct_ref (ax, value, name, ".", "structure or union"); else if (op == STRUCTOP_PTR) - gen_struct_ref (exp, ax, value, name, "->", + gen_struct_ref (ax, value, name, "->", "pointer to a structure or union"); else /* If this `if' chain doesn't handle it, then the case list @@ -2202,7 +2185,7 @@ gen_expr (struct expression *exp, union exp_element **pc, if (!sym) error (_("no `%s' found"), lang->la_name_of_this); - gen_var_ref (exp->gdbarch, ax, value, sym); + gen_var_ref (ax->gdbarch, ax, value, sym); if (value->optimized_out) error (_("`%s' has been optimized out, cannot use"), @@ -2219,8 +2202,7 @@ gen_expr (struct expression *exp, union exp_element **pc, char *name = &(*pc)[3].string; int found; - found = gen_aggregate_elt_ref (exp, ax, value, type, name, - "?", "??"); + found = gen_aggregate_elt_ref (ax, value, type, name, "?", "??"); if (!found) error (_("There is no field named %s"), name); (*pc) += 5 + BYTES_TO_EXP_ELEM (length + 1); @@ -2248,11 +2230,11 @@ gen_expr_binop_rest (struct expression *exp, struct agent_expr *ax, struct axs_value *value, struct axs_value *value1, struct axs_value *value2) { - struct type *int_type = builtin_type (exp->gdbarch)->builtin_int; + struct type *int_type = builtin_type (ax->gdbarch)->builtin_int; gen_expr (exp, pc, ax, value2); - gen_usual_unary (exp, ax, value2); - gen_usual_arithmetic (exp, ax, value1, value2); + gen_usual_unary (ax, value2); + gen_usual_arithmetic (ax, value1, value2); switch (op) { case BINOP_ADD: @@ -2278,7 +2260,7 @@ gen_expr_binop_rest (struct expression *exp, && pointer_type (value2->type)) /* FIXME --- result type should be ptrdiff_t */ gen_ptrdiff (ax, value, value1, value2, - builtin_type (exp->gdbarch)->builtin_long); + builtin_type (ax->gdbarch)->builtin_long); else gen_binop (ax, value, value1, value2, aop_sub, aop_sub, 1, "subtraction");