From patchwork Fri Jan 26 15:12:14 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Alan Hayward X-Patchwork-Id: 25586 Received: (qmail 110185 invoked by alias); 26 Jan 2018 15:14:05 -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 110042 invoked by uid 89); 26 Jan 2018 15:14:04 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-26.0 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: EUR01-HE1-obe.outbound.protection.outlook.com Received: from mail-he1eur01on0057.outbound.protection.outlook.com (HELO EUR01-HE1-obe.outbound.protection.outlook.com) (104.47.0.57) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 26 Jan 2018 15:12:22 +0000 Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Alan.Hayward@arm.com; Received: from c02tf0u7hf1t.manchester.arm.com (217.140.96.140) by DB3PR08MB0107.eurprd08.prod.outlook.com (2a01:111:e400:5045::21) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P256) id 15.20.428.17; Fri, 26 Jan 2018 15:12:17 +0000 To: gdb-patches@sourceware.org Cc: nd@arm.com From: Alan Hayward Subject: [PATCH] Use visitors for make_gdb_type Message-ID: Date: Fri, 26 Jan 2018 15:12:14 +0000 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:52.0) Gecko/20100101 Thunderbird/52.5.2 MIME-Version: 1.0 X-ClientProxiedBy: LNXP265CA0040.GBRP265.PROD.OUTLOOK.COM (2603:10a6:600:5c::28) To DB3PR08MB0107.eurprd08.prod.outlook.com (2a01:111:e400:5045::21) X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 7d10d9ff-f76e-4a1d-4410-08d564cf3088 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(7020095)(4652020)(48565401081)(5600026)(4604075)(2017052603307)(7153060)(7193020); SRVR:DB3PR08MB0107; X-Microsoft-Exchange-Diagnostics: 1; DB3PR08MB0107; 3:KGE2nJ06E5WeQBW10zrUxurqXCDMYzdRuaMaHFZXQ+ZWD+Uaya0s5BLBJC6/9uqK2zB6wRJ+iiu0iyRd1uw1O5rIsyKG/SJsco0stwImZ6/Ro46cybW0hokhDMMGB6ySyS76rf8jSnaHtD/gAN+t/Iebsyg2bTs+qPDSEIfqQ8FfyrLDd3bGsB7ufm5QFlGGsomYDMqY5ozosQ/lCCQkT+M0WvEehK1dXe7pQQCxy+NkI0hnGvqO+KX41ELrefod; 25:s1l4P9+TpUXJA3fPyyfos3eBPRpU+H4sFD3M//6W0WVcF1jijBnQqhtPYEGU6cfGpZ0BjB0yEaTFIq52YajsA4/9ZF79x4vm9kDaKoMpxwuDovoeTi44mtZQ6PfOrrp+sQiPM6gi7iPbHkL5nbaYP8ky2U2XlTy2PoA/ngEn2fXh4QUSS9yQN/JEQc86Xnqb6Mr5Z3caJaza3KQejTxmdggXxCxJ4T2EQIunVlGcfPaHK3QRbffJj6Qnp0SEhGU1hzSIdK9g2rH5hIMHW3bc0a/6U6oX0SDsPHrBqeiwNLnXsKAIo4YNVUA5JCfwDUJQai9ecQ5m+H1QdP9QWJ8jQw==; 31:EHx+lVLvmz5SmCANjgzCxAEGmYWN0MwT+O2DEORQu+Rz4HneTRmQeKeqw4pJSaBb4d2koyAqupymYZDF3XE9HU1G8iY4nrZjlE6mR8VckEyezJ8aSo8ZPmVKg0jxjpQ3uAy+eloqWnjdiGxbvsz3U2DGBXjgfhHUTyXA0p1kLtOa6m3dEC/b39mpo1fHiRiq90+AuvfMG6ufM8e/Mk4axQmSNyqiQ3ukH7Mzt9QLRsY= X-MS-TrafficTypeDiagnostic: DB3PR08MB0107: NoDisclaimer: True X-Microsoft-Exchange-Diagnostics: 1; DB3PR08MB0107; 20:/WjPtfzyteGHfwxyw/LGHItu2R9rRRHzt16dqlmNpBqGVynB8SpeTN7nX8LdHpxjSJKmOKvY5MfX35MuacL984qKy7iIf6cA21X4u0lX1jjUo1jQ1n3gnL09DgfG69qOnTmOqlzTUNgEx+lZVY4Ywh1myd51glD8tnCu/Gma01s=; 4:xjByCdYBjuGlYMs6O+REsFtAjmjmsLZeEu/3fcsLTkcpdNcpH3hyN+N9Ec8pl1siJqpZmEVrXw7z0XQGaUCiBz0EswVAMaCtkTJTwgY6fxWglwTALswNt+Ih+TPvYaiD1LPhaRDNRSjp3PfsHPeG6lRD4j/JYLTbJP0ho7Ztvmbu5zJEP1V7smzGYK8h9vtQ5su823qHUsJTteqY3ei4XxxdfbgDxsn+IAtPr0QurxGG18TcKoQ0dZZB6PeIe6xoQ64uanlbZBwt6jSUled76i0NJSFy/KnNydjeZ2k3oFhkx0tzaeyunqYunfgAEPRbRhzNPs4965+HI57C2vxTpyR47WR80WRKWbLFZPHGQxznZc4BGfQlWdOrEEfmYBR+coZkl0p94ZglvAT29VqXLZGCHQuxgk5MuJh3h3ZzGLY= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:(180628864354917)(131327999870524)(788757137089)(17755550239193); X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6040501)(2401047)(5005006)(8121501046)(3231023)(2400081)(944501161)(3002001)(10201501046)(93006095)(93001095)(6055026)(6041288)(201703131423095)(201702281528075)(20161123555045)(201703061421075)(201703061406153)(20161123558120)(20161123560045)(20161123564045)(20161123562045)(6072148)(201708071742011); SRVR:DB3PR08MB0107; BCL:0; PCL:0; RULEID:; SRVR:DB3PR08MB0107; X-Forefront-PRVS: 05641FD966 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(346002)(39380400002)(39850400004)(396003)(366004)(376002)(377424004)(199004)(189003)(2351001)(83506002)(68736007)(97736004)(52116002)(8936002)(8676002)(81156014)(81166006)(23676004)(2486003)(52146003)(2361001)(7696005)(305945005)(16526019)(7736002)(31696002)(59450400001)(86362001)(31686004)(106356001)(58126008)(386003)(6666003)(105586002)(67846002)(2870700001)(6916009)(2906002)(36756003)(316002)(50466002)(6486002)(65826007)(5660300001)(25786009)(478600001)(72206003)(66066001)(47776003)(65806001)(6116002)(53936002)(65956001)(4326008)(26005)(3846002)(64126003); DIR:OUT; SFP:1101; SCL:1; SRVR:DB3PR08MB0107; H:c02tf0u7hf1t.manchester.arm.com; FPR:; SPF:None; PTR:InfoNoRecords; A:1; MX:1; LANG:en; Received-SPF: None (protection.outlook.com: arm.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?utf-8?B?MTtEQjNQUjA4TUIwMTA3OzIzOmZUVDc3K2xMQmVtbC9Yc2VBNGpSdWdaa000?= =?utf-8?B?K2Z4SWpKd0FWOXpReGJhVlNFWUJ4ZGNuTVBxQ0h6TXA5RHN6Nlg5SHZHdkt6?= =?utf-8?B?aTc2YytCdXlZOXVLZ0N5MXpic09OcUtBVjV3NzVuZXdLVU8xU0pNeHEydlQv?= =?utf-8?B?dmNaZk9TSlI0NUR5MnJ4RGI5N2hSQWxhanZnOG0xOEVNdDQvZGRBQmxZcG5W?= =?utf-8?B?b1B2dWZFcHA1Yll6UzllSkY1YzduUE9hTFVLb3U2RXRIL3NNZ2lwUzVrVTBp?= =?utf-8?B?U2xCRHBrUDdHWTIrQW9ZcVE3bnhyMTJiVUpOdUVSbEN1am93RTFyL2gydk01?= =?utf-8?B?Nm81N043cm13cUEvbTFNMWxCbFQ3TFBYWGtiR01COUtKS3ZIeWY3dVdLRGM3?= =?utf-8?B?dFRrSG9nVkVVL3FHT0E3OEM1QnVTZ3V2OTB2MTJVYmVBQmxib3U2amZwc1Bj?= =?utf-8?B?ZmtiY0RVemVSNkR0Yy9jZ09zQUdaVlQrcjNZS0xFTC82YWhYTXFFVjdEalRs?= =?utf-8?B?Rkx5dHhYcTZGek55UEpMR2ttWlJmdS9Pc0xpTGRqL1FibkVmRUx0UlV1VkRS?= =?utf-8?B?NWxTc3FZZXhpK3JzaVdoOXZhQUZ4ckJJTUZoaTh3TlhxUkpscjliWkhPNDIy?= =?utf-8?B?eEdSb2hDMkJkVVJWZTFNTU5ERmIwbVhHSkZNUjB0QjhxUFMzY012REpXZngr?= =?utf-8?B?d3pwRTk0b3N3cjlSY1VvZHlSNlNEd2FhT0dXYWJMQ1FOcGxUVVExOGgzRFl6?= =?utf-8?B?TVRJSzRac2V5eUlxY1Q4SFJHZmNXcGVTZUF5dTVFbXc4SUMwc2J0RmdnaVoz?= =?utf-8?B?VnVlNlJvWGJnQzUxUkg3UFlFS3VNWkxBSXQ5emdTalpGSVh4bGMwYWUzSzJk?= =?utf-8?B?a3c0Vmc3RXhJQkpjTTJ6TlM2WGltZXE4ZUdpRTAzUkM0RDkrUlNhU1BOZ3dp?= =?utf-8?B?WktOdGpGVzY1N1Z3cWJWeTV0N0F4NU0rM0VudXZZRWwzc29WZS9yZ01lSWhq?= =?utf-8?B?Z2dmSmIrNjE1VUo1alV2TGxTcUVFSklMa2VnOURqY05TZ0pzM29KNTludVVY?= =?utf-8?B?QUw1RTdTYjl5dHN2VzdVWHNFQjRaVXYzL1d1a0did1BqMDZ0ajVvZ2JtWjJ4?= =?utf-8?B?Um83MSswa0pNbHVmalZGUlpUdnVwUytmS2hmL1JKdDdoRktsZitXZmN1WmVP?= =?utf-8?B?VkNRdWdXdVdYSVBwSzFLSCswa1pVajBwVWF5NFhyT1h3cFYrU3g1bXlqYXNk?= =?utf-8?B?UHQxQnorWXVPejBsTjVhUmJPSFBwRHJlUGJGb2lMcDRqZjVNb0w2S0cyMGo5?= =?utf-8?B?TEVFcXdmR2hwY2x5M1FDMEpLcUFZVitVSEF3T2k2UzNrSnJObjNPU1dDN2ZW?= =?utf-8?B?dEpDeTlHRFlCU3FBVGI3RTFXRTFXdnduaFl2bjBCWlFWelpUV1JoYUdRV3dl?= =?utf-8?B?YllwNDFtRytpYjVWNjdMWXd4MHpvNS9QYUlUY1g1VXR6aWU2OEpybHp3Yzl4?= =?utf-8?B?bHRPMmtEK2RsRm5JOTU4VDJlWWxIdlJGTzdtWi84N01zNHBXUzcvNGUzYTJn?= =?utf-8?B?a1BIUTQ5TlJxa3QzUms4eGFuQndBbWFEZkN4bGpPTlNJVmh1eTRIV3NRVXJo?= =?utf-8?B?dC82N3Bqc0djbllLT3lWeUJJRmpmNTIwbks0RXJybk91aHRGU2kvUm1PaFVu?= =?utf-8?B?RzVNMnhrTjRNUU9jT0sxSGl5UUZEQkdYWU1IRVg0S2ZJUzh5RGlPR3NMZlMy?= =?utf-8?B?ajFMUWdmQ2FvVnZ6S2NuS0RCVEM2R291ZnVUbmZxaThmZWN2S0l2MlcxNnZ2?= =?utf-8?Q?3RDxCn8JUnKw5?= X-Microsoft-Exchange-Diagnostics: 1; DB3PR08MB0107; 6:DDc37wb9DDRgxhr5Wvv+2shnjUC3u7PVtJvZg17d6oY87sF6AvEZtR3/8bIyjegFFNgM8jAo27y+gq3Yo5ucPnOvWAzzMTnVSQpL+FTgNtinNF/2zRbjiFTS6Mr2DERqVThPYRT3joKB414pAGNDNCPUx4z+RXDwUPPa7/M+c1Da9Jc9Iy6BbhMO4aS0NoNPUJW2t2sevdDPqdmIUnMuDrfPqZqyS5Q6k8AKNe9Q2+oFXrUaI3xheFAHwqKIoNzewkAtXm+pSdGuUiKl8Tssn9H3RmYE5f+covY5H1/Avm5b4Oc4dzhcqXFoO3YiqdX5qewz6GAMTu6q15i/BFox8QqneYwz56frizqIFKIgWA0=; 5:Wha/jW4izYAgojiWJge7RyUZohaHQGUCke3M3syQYAqvOgxzxDlCjyEBAPGcepofsV4aOH56eSBHp1P85r+4/XhibSN9gAklPuph4+mS+XC540rh4jFThJ5vRSwVnOf2tGYuDcVUu4K+mSFCZFZHWvZrq73ZLkIfF6a5bReoPVw=; 24:g95FV6glee9NdhizlLs7kL3e+CldOPpFuW4X+yPOxtA4s44RK/WkrrQJy/cpsnIiYwrXeRGz2MN+pi9pXPkHCYP+K4umxaxP9wYhmenMp/w=; 7:abs7EoW9SAxIxDdiaGhSlefAiS3DP9Ui6pPEWc5uPCDtY4agpDNLgRsPGb+VnhtbQCqzvANVu0fda0XYnikUBjrTkDfMFLDdkUqjM9vBwldDzsqYOa2aC7lHIfk/I6pUfpAcb6qtvlmJ1Soff3No/GhrDTXIcVzFtkbChjrP2sREFgO3W3oGBQ5swlkCB8LzIxnaC+g/cJ9t4o+8DrFSFgTXNQOmLh/4w5aW5QlEhxUvrY7CUlLExha3fK4eYNz7 SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-OriginatorOrg: arm.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 26 Jan 2018 15:12:17.5850 (UTC) X-MS-Exchange-CrossTenant-Network-Message-Id: 7d10d9ff-f76e-4a1d-4410-08d564cf3088 X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: f34e5979-57d9-4aaa-ad4d-b122a662184d X-MS-Exchange-Transport-CrossTenantHeadersStamped: DB3PR08MB0107 X-IsSubscribed: yes This patch implements the suggestion in the review for [PATCH v2 6/8] Create xml from target descriptions. Remove the make_gdb_type functions from the tdesc_type_ classes. Replace with a static make_gdb_type function that uses a element visitor called gdb_type_creator. I've defined gdb_type_creator inside make_gdb_type because it shouldn't be needed outside the function. The method of creating the types has not changed. This patch will allow a future patch to commonise the tdesc_types with gdbserver without having to move any gdb_type functionality. Alan. 2018-01-26  Alan Hayward      * target-descriptions.c (tdesc_type): Move make_gdb_type from here.     (tdesc_type_builtin): Likewise.     (tdesc_type_vector): Likewise.     (tdesc_type_with_fields): Move make_gdb_type_ functions from here.     (make_gdb_type_struct): Move from tdesc_type_with_fields.     (make_gdb_type_union): Likewise.     (make_gdb_type_flags): Likewise.     (make_gdb_type_enum): Likewise.     (make_gdb_type): New function.     (tdesc_register_type): Use static make_gdb_type. ---  gdb/target-descriptions.c | 460 +++++++++++++++++++++++++---------------------  1 file changed, 254 insertions(+), 206 deletions(-)  class tdesc_element_visitor @@ -223,11 +225,6 @@ struct tdesc_type : tdesc_element    {      return !(*this == other);    } - -  /* Construct, if necessary, and return the GDB type implementing this -     target type for architecture GDBARCH.  */ - -  virtual type *make_gdb_type (struct gdbarch *gdbarch) const = 0;  };  typedef std::unique_ptr tdesc_type_up; @@ -242,81 +239,6 @@ struct tdesc_type_builtin : tdesc_type    {      v.visit (this);    } - -  type *make_gdb_type (struct gdbarch *gdbarch) const override -  { -    switch (this->kind) -      { -      /* Predefined types.  */ -      case TDESC_TYPE_BOOL: -        return builtin_type (gdbarch)->builtin_bool; - -      case TDESC_TYPE_INT8: -        return builtin_type (gdbarch)->builtin_int8; - -      case TDESC_TYPE_INT16: -        return builtin_type (gdbarch)->builtin_int16; - -      case TDESC_TYPE_INT32: -        return builtin_type (gdbarch)->builtin_int32; - -      case TDESC_TYPE_INT64: -        return builtin_type (gdbarch)->builtin_int64; - -      case TDESC_TYPE_INT128: -        return builtin_type (gdbarch)->builtin_int128; - -      case TDESC_TYPE_UINT8: -        return builtin_type (gdbarch)->builtin_uint8; - -      case TDESC_TYPE_UINT16: -        return builtin_type (gdbarch)->builtin_uint16; - -      case TDESC_TYPE_UINT32: -        return builtin_type (gdbarch)->builtin_uint32; - -      case TDESC_TYPE_UINT64: -        return builtin_type (gdbarch)->builtin_uint64; - -      case TDESC_TYPE_UINT128: -        return builtin_type (gdbarch)->builtin_uint128; - -      case TDESC_TYPE_CODE_PTR: -        return builtin_type (gdbarch)->builtin_func_ptr; - -      case TDESC_TYPE_DATA_PTR: -        return builtin_type (gdbarch)->builtin_data_ptr; -      } - -    type *gdb_type = tdesc_find_type (gdbarch, this->name.c_str ()); -    if (gdb_type != NULL) -      return gdb_type; - -    switch (this->kind) -      { -      case TDESC_TYPE_IEEE_SINGLE: -        return arch_float_type (gdbarch, -1, "builtin_type_ieee_single", -                floatformats_ieee_single); - -      case TDESC_TYPE_IEEE_DOUBLE: -        return arch_float_type (gdbarch, -1, "builtin_type_ieee_double", -                floatformats_ieee_double); - -      case TDESC_TYPE_ARM_FPA_EXT: -        return arch_float_type (gdbarch, -1, "builtin_type_arm_ext", -                floatformats_arm_ext); - -      case TDESC_TYPE_I387_EXT: -        return arch_float_type (gdbarch, -1, "builtin_type_i387_ext", -                floatformats_i387_ext); -      } - -    internal_error (__FILE__, __LINE__, -            "Type \"%s\" has an unknown kind %d", -            this->name.c_str (), this->kind); - -    return NULL; -  }  };  /* tdesc_type for vector types.  */ @@ -333,19 +255,6 @@ struct tdesc_type_vector : tdesc_type      v.visit (this);    } -  type *make_gdb_type (struct gdbarch *gdbarch) const override -  { -    type *vector_gdb_type = tdesc_find_type (gdbarch, this->name.c_str ()); -    if (vector_gdb_type != NULL) -      return vector_gdb_type; - -    type *element_gdb_type = this->element_type->make_gdb_type (gdbarch); -    vector_gdb_type = init_vector_type (element_gdb_type, this->count); -    TYPE_NAME (vector_gdb_type) = xstrdup (this->name.c_str ()); - -    return vector_gdb_type; -  } -    struct tdesc_type *element_type;    int count;  }; @@ -364,151 +273,290 @@ struct tdesc_type_with_fields : tdesc_type      v.visit (this);    } -  type *make_gdb_type_struct (struct gdbarch *gdbarch) const -  { -    type *struct_gdb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); -    TYPE_NAME (struct_gdb_type) = xstrdup (this->name.c_str ()); -    TYPE_TAG_NAME (struct_gdb_type) = TYPE_NAME (struct_gdb_type); +  std::vector fields; +  int size; +}; -    for (const tdesc_type_field &f : this->fields) -      { -    if (f.start != -1 && f.end != -1) -      { -        /* Bitfield.  */ -        struct field *fld; -        struct type *field_gdb_type; -        int bitsize, total_size; - -        /* This invariant should be preserved while creating types.  */ -        gdb_assert (this->size != 0); -        if (f.type != NULL) -          field_gdb_type = f.type->make_gdb_type (gdbarch); -        else if (this->size > 4) -          field_gdb_type = builtin_type (gdbarch)->builtin_uint64; -        else -          field_gdb_type = builtin_type (gdbarch)->builtin_uint32; - -        fld = append_composite_type_field_raw -          (struct_gdb_type, xstrdup (f.name.c_str ()), field_gdb_type); - -        /* For little-endian, BITPOS counts from the LSB of -           the structure and marks the LSB of the field.  For -           big-endian, BITPOS counts from the MSB of the -           structure and marks the MSB of the field.  Either -           way, it is the number of bits to the "left" of the -           field.  To calculate this in big-endian, we need -           the total size of the structure.  */ -        bitsize = f.end - f.start + 1; -        total_size = this->size * TARGET_CHAR_BIT; -        if (gdbarch_bits_big_endian (gdbarch)) -          SET_FIELD_BITPOS (fld[0], total_size - f.start - bitsize); -        else -          SET_FIELD_BITPOS (fld[0], f.start); -        FIELD_BITSIZE (fld[0]) = bitsize; -      } -    else -      { -        gdb_assert (f.start == -1 && f.end == -1); -        type *field_gdb_type = f.type->make_gdb_type (gdbarch); -        append_composite_type_field (struct_gdb_type, -                     xstrdup (f.name.c_str ()), -                     field_gdb_type); -      } -      } +static type * +make_gdb_type_struct (struct gdbarch *gdbarch, const tdesc_type_with_fields *e) +{ +  type *struct_gdb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_STRUCT); +  TYPE_NAME (struct_gdb_type) = xstrdup (e->name.c_str ()); +  TYPE_TAG_NAME (struct_gdb_type) = TYPE_NAME (struct_gdb_type); -    if (this->size != 0) -      TYPE_LENGTH (struct_gdb_type) = this->size; +  for (const tdesc_type_field &f : e->fields) +    { +      if (f.start != -1 && f.end != -1) +    { +      /* Bitfield.  */ +      struct field *fld; +      struct type *field_gdb_type; +      int bitsize, total_size; + +      /* This invariant should be preserved while creating types.  */ +      gdb_assert (e->size != 0); +      if (f.type != NULL) +        field_gdb_type = make_gdb_type (gdbarch, f.type); +      else if (e->size > 4) +        field_gdb_type = builtin_type (gdbarch)->builtin_uint64; +      else +        field_gdb_type = builtin_type (gdbarch)->builtin_uint32; + +      fld = append_composite_type_field_raw +        (struct_gdb_type, xstrdup (f.name.c_str ()), field_gdb_type); + +      /* For little-endian, BITPOS counts from the LSB of +         the structure and marks the LSB of the field.  For +         big-endian, BITPOS counts from the MSB of the +         structure and marks the MSB of the field.  Either +         way, it is the number of bits to the "left" of the +         field.  To calculate this in big-endian, we need +         the total size of the structure.  */ +      bitsize = f.end - f.start + 1; +      total_size = e->size * TARGET_CHAR_BIT; +      if (gdbarch_bits_big_endian (gdbarch)) +        SET_FIELD_BITPOS (fld[0], total_size - f.start - bitsize); +      else +        SET_FIELD_BITPOS (fld[0], f.start); +      FIELD_BITSIZE (fld[0]) = bitsize; +    } +      else +    { +      gdb_assert (f.start == -1 && f.end == -1); +      type *field_gdb_type = make_gdb_type (gdbarch, f.type); +      append_composite_type_field (struct_gdb_type, +                       xstrdup (f.name.c_str ()), +                       field_gdb_type); +    } +    } -    return struct_gdb_type; -  } +  if (e->size != 0) +    TYPE_LENGTH (struct_gdb_type) = e->size; -  type *make_gdb_type_union (struct gdbarch *gdbarch) const -  { -    type *union_gdb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); -    TYPE_NAME (union_gdb_type) = xstrdup (this->name.c_str ()); +  return struct_gdb_type; +} -    for (const tdesc_type_field &f : this->fields) -      { -    type* field_gdb_type = f.type->make_gdb_type (gdbarch); -    append_composite_type_field (union_gdb_type, xstrdup (f.name.c_str ()), +static type * +make_gdb_type_union (struct gdbarch *gdbarch, const tdesc_type_with_fields *e) +{ +  type *union_gdb_type = arch_composite_type (gdbarch, NULL, TYPE_CODE_UNION); +  TYPE_NAME (union_gdb_type) = xstrdup (e->name.c_str ()); + +  for (const tdesc_type_field &f : e->fields) +    { +      type* field_gdb_type = make_gdb_type (gdbarch, f.type); +      append_composite_type_field (union_gdb_type, xstrdup (f.name.c_str ()),                       field_gdb_type); -    /* If any of the children of a union are vectors, flag the -       union as a vector also.  This allows e.g. a union of two -       vector types to show up automatically in "info vector". */ -    if (TYPE_VECTOR (field_gdb_type)) -      TYPE_VECTOR (union_gdb_type) = 1; -      } +      /* If any of the children of a union are vectors, flag the +     union as a vector also.  This allows e.g. a union of two +     vector types to show up automatically in "info vector".  */ +      if (TYPE_VECTOR (field_gdb_type)) +    TYPE_VECTOR (union_gdb_type) = 1; +    } -    return union_gdb_type; -  } +  return union_gdb_type; +} -  type *make_gdb_type_flags (struct gdbarch *gdbarch) const -  { -    type *flags_gdb_type = arch_flags_type (gdbarch, this->name.c_str (), -                      this->size * TARGET_CHAR_BIT); +static type * +make_gdb_type_flags (struct gdbarch *gdbarch, const tdesc_type_with_fields *e) +{ +  type *flags_gdb_type = arch_flags_type (gdbarch, e->name.c_str (), +                      e->size * TARGET_CHAR_BIT); -    for (const tdesc_type_field &f : this->fields) -      { +  for (const tdesc_type_field &f : e->fields) +    {        int bitsize = f.end - f.start + 1;        gdb_assert (f.type != NULL); -      type *field_gdb_type = f.type->make_gdb_type (gdbarch); +      type *field_gdb_type = make_gdb_type (gdbarch, f.type);        append_flags_type_field (flags_gdb_type, f.start, bitsize,                     field_gdb_type, f.name.c_str ()); -      } +    } -    return flags_gdb_type; -  } +  return flags_gdb_type; +} -  type *make_gdb_type_enum (struct gdbarch *gdbarch) const -  { -    type *enum_gdb_type = arch_type (gdbarch, TYPE_CODE_ENUM, -                   this->size * TARGET_CHAR_BIT, -                   this->name.c_str ()); +static type * +make_gdb_type_enum (struct gdbarch *gdbarch, const tdesc_type_with_fields *e) +{ +  type *enum_gdb_type = arch_type (gdbarch, TYPE_CODE_ENUM, +                   e->size * TARGET_CHAR_BIT, +                   e->name.c_str ()); -    TYPE_UNSIGNED (enum_gdb_type) = 1; -    for (const tdesc_type_field &f : this->fields) -      { +  TYPE_UNSIGNED (enum_gdb_type) = 1; +  for (const tdesc_type_field &f : e->fields) +    {        struct field *fld      = append_composite_type_field_raw (enum_gdb_type,                         xstrdup (f.name.c_str ()),                         NULL);        SET_FIELD_BITPOS (fld[0], f.start); -      } +    } -    return enum_gdb_type; -  } +  return enum_gdb_type; +} -  type *make_gdb_type (struct gdbarch *gdbarch) const override +static type * +make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype) +{ +  class gdb_type_creator : public tdesc_element_visitor    { -    type *gdb_type = tdesc_find_type (gdbarch, this->name.c_str ()); -    if (gdb_type != NULL) -      return gdb_type; +  public: +    gdb_type_creator (struct gdbarch *gdbarch) +      : m_gdbarch (gdbarch) +    {} -    switch (this->kind) +    type *get_type ()      { -      case TDESC_TYPE_STRUCT: -    return make_gdb_type_struct (gdbarch); -      case TDESC_TYPE_UNION: -    return make_gdb_type_union (gdbarch); -      case TDESC_TYPE_FLAGS: -    return make_gdb_type_flags (gdbarch); -      case TDESC_TYPE_ENUM: -    return make_gdb_type_enum (gdbarch); +      return m_type;      } -    internal_error (__FILE__, __LINE__, -            "Type \"%s\" has an unknown kind %d", -            this->name.c_str (), this->kind); +    void visit_pre (const target_desc *e) +    {} -    return NULL; -  } +    void visit_post (const target_desc *e) +    {} -  std::vector fields; -  int size; -}; +    void visit_pre (const tdesc_feature *e) +    {} + +    void visit_post (const tdesc_feature *e) +    {} + +    void visit (const tdesc_type_builtin *e) override +    { +      switch (e->kind) +    { +      /* Predefined types.  */ +    case TDESC_TYPE_BOOL: +      m_type = builtin_type (m_gdbarch)->builtin_bool; +      return; +    case TDESC_TYPE_INT8: +      m_type = builtin_type (m_gdbarch)->builtin_int8; +      return; +    case TDESC_TYPE_INT16: +      m_type = builtin_type (m_gdbarch)->builtin_int16; +      return; +    case TDESC_TYPE_INT32: +      m_type = builtin_type (m_gdbarch)->builtin_int32; +      return; +    case TDESC_TYPE_INT64: +      m_type = builtin_type (m_gdbarch)->builtin_int64; +      return; +    case TDESC_TYPE_INT128: +      m_type = builtin_type (m_gdbarch)->builtin_int128; +      return; +    case TDESC_TYPE_UINT8: +      m_type = builtin_type (m_gdbarch)->builtin_uint8; +      return; +    case TDESC_TYPE_UINT16: +      m_type = builtin_type (m_gdbarch)->builtin_uint16; +      return; +    case TDESC_TYPE_UINT32: +      m_type = builtin_type (m_gdbarch)->builtin_uint32; +      return; +    case TDESC_TYPE_UINT64: +      m_type = builtin_type (m_gdbarch)->builtin_uint64; +      return; +    case TDESC_TYPE_UINT128: +      m_type = builtin_type (m_gdbarch)->builtin_uint128; +      return; +    case TDESC_TYPE_CODE_PTR: +      m_type = builtin_type (m_gdbarch)->builtin_func_ptr; +      return; +    case TDESC_TYPE_DATA_PTR: +      m_type = builtin_type (m_gdbarch)->builtin_data_ptr; +      return; +    } + +      m_type = tdesc_find_type (m_gdbarch, e->name.c_str ()); +      if (m_type != NULL) +    return; + +      switch (e->kind) +    { +    case TDESC_TYPE_IEEE_SINGLE: +      m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_single", +                    floatformats_ieee_single); +      return; + +    case TDESC_TYPE_IEEE_DOUBLE: +      m_type = arch_float_type (m_gdbarch, -1, "builtin_type_ieee_double", +                    floatformats_ieee_double); +      return; +    case TDESC_TYPE_ARM_FPA_EXT: +      m_type = arch_float_type (m_gdbarch, -1, "builtin_type_arm_ext", +                    floatformats_arm_ext); +      return; + +    case TDESC_TYPE_I387_EXT: +      m_type = arch_float_type (m_gdbarch, -1, "builtin_type_i387_ext", +                    floatformats_i387_ext); +      return; +    } + +      internal_error (__FILE__, __LINE__, +              "Type \"%s\" has an unknown kind %d", +              e->name.c_str (), e->kind); +    } + +    void visit (const tdesc_type_vector *e) override +    { +      m_type = tdesc_find_type (m_gdbarch, e->name.c_str ()); +      if (m_type != NULL) +    return; + +      type *element_gdb_type = make_gdb_type (m_gdbarch, e->element_type); +      m_type = init_vector_type (element_gdb_type, e->count); +      TYPE_NAME (m_type) = xstrdup (e->name.c_str ()); +      return; +    } + +    void visit (const tdesc_type_with_fields *e) override +    { +      m_type = tdesc_find_type (m_gdbarch, e->name.c_str ()); +      if (m_type != NULL) +    return; + +      switch (e->kind) +    { +    case TDESC_TYPE_STRUCT: +      m_type = make_gdb_type_struct (m_gdbarch, e); +      return; +    case TDESC_TYPE_UNION: +      m_type = make_gdb_type_union (m_gdbarch, e); +      return; +    case TDESC_TYPE_FLAGS: +      m_type = make_gdb_type_flags (m_gdbarch, e); +      return; +    case TDESC_TYPE_ENUM: +      m_type = make_gdb_type_enum (m_gdbarch, e); +      return; +    } + +      internal_error (__FILE__, __LINE__, +              "Type \"%s\" has an unknown kind %d", +              e->name.c_str (), e->kind); +    } + +    void visit (const tdesc_reg *reg) +    {} + +  private: + +    /* The gdbarch used.  */ +    struct gdbarch *m_gdbarch; + +    /* The type created.  */ +    type *m_type; +  }; + +  gdb_type_creator gdb_type (gdbarch); +  ttype->accept (gdb_type); +  return gdb_type.get_type (); +}  /* A feature from a target description.  Each feature is a collection     of other elements, e.g. registers and types.  */ @@ -1216,7 +1264,7 @@ tdesc_register_type (struct gdbarch *gdbarch, int regno)      {        /* First check for a predefined or target defined type.  */        if (reg->tdesc_type) -        arch_reg->type = reg->tdesc_type->make_gdb_type (gdbarch); +    arch_reg->type = make_gdb_type (gdbarch, reg->tdesc_type);        /* Next try size-sensitive type shortcuts.  */        else if (reg->type == "float") diff --git a/gdb/target-descriptions.c b/gdb/target-descriptions.c index 1b20a12d76..55ac1d7a80 100644 --- a/gdb/target-descriptions.c +++ b/gdb/target-descriptions.c @@ -38,6 +38,8 @@  #include "completer.h"  #include "readline/tilde.h" /* tilde_expand */ +static type *make_gdb_type (struct gdbarch *gdbarch, struct tdesc_type *ttype); +  /* The interface to visit different elements of target description.  */