From patchwork Tue Oct 10 04:13:02 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kito Cheng X-Patchwork-Id: 150474 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:a888:0:b0:403:3b70:6f57 with SMTP id x8csp2266962vqo; Mon, 9 Oct 2023 21:14:33 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGgHZQ4MmTVSb1WmHRBCIe6/koqXs2SY9JHI0s5PRX9S+HYKHd1jRgo0im9zRjP4Tr81aYK X-Received: by 2002:a17:907:1dd8:b0:9ad:f143:e554 with SMTP id og24-20020a1709071dd800b009adf143e554mr13485910ejc.30.1696911272912; Mon, 09 Oct 2023 21:14:32 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696911272; cv=none; d=google.com; s=arc-20160816; b=DV/J5kZayIywWq0OrEf8s3sHUcZF1mY39RM8HWO/xLhUO737Z/yg44+oKMV1ygqhbT zNARwVeShIYVCPZZLagXCjGwvD1Jf9tEnRNLIoFhka4DegsmnZtT+o0lJbMV5og38k+Z yA56eytOhysKG9nl7eOttcWmTivelaUduQvkgQPkk/F8BB6bGo0Gtp3LtMsqpCnP91sD AUZyBgG8GroaNpuN005VWbfV3fCV3G0F9V+A0fbieVCv480V2ag8Lviqk6fFufPzSSsJ uiIqjCQkzfXN7D1xzEqgtDIWNJre4CpKi1gKakxf65wQPRiOWLUdAVH9r1QIyADHDekb 2Qww== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature:dmarc-filter:delivered-to; bh=I+r2OOd09JbCXZKD13x8DNc/mixN3aexjhHoxIM1Zmk=; fh=kbV0NOqiTuorklH6HBA9bfclLeeDA0ay8K7s4dUrk/A=; b=sdS9aL/CLgSmCIMIFdy4WAP9kHakyzS/mVNB3mUjxXNUe4bzgy5hJvp9u65yHD4Fga abgwGTsavumGjXU4UkugPc4UbarJkrgS6uOy+yHYbALk3y0DM+lpRMAb1rMIDZBpadfg cuqnPy/ajy9RXX41qQqYkjY8vgRwjt5YptsS+JaeOW7N290b0rhmMUGA7zagB/KqSlpM 3lNU/gNh8618zPovtdwfokUvc/nvI0Ab3fFW2KXPHWjuxXx7B6PKzUgCTX481ng8yMgO xTrXDPinLAZp0wT2pipxCFgCQOn9sXIj5QTZ8XXpWOCO1RV0ptaG8+EwhGKq9PlMmXSM nbRQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=LMW7ZfSk; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id kq3-20020a170906abc300b0098cf3eaee4esi4992112ejb.57.2023.10.09.21.14.32 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:14:32 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=LMW7ZfSk; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 351BF3861900 for ; Tue, 10 Oct 2023 04:13:41 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-pf1-x434.google.com (mail-pf1-x434.google.com [IPv6:2607:f8b0:4864:20::434]) by sourceware.org (Postfix) with ESMTPS id EC3793858404 for ; Tue, 10 Oct 2023 04:13:14 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org EC3793858404 Authentication-Results: sourceware.org; dmarc=pass (p=reject dis=none) header.from=sifive.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=sifive.com Received: by mail-pf1-x434.google.com with SMTP id d2e1a72fcca58-690f7d73a3aso4635104b3a.0 for ; Mon, 09 Oct 2023 21:13:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1696911193; x=1697515993; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=I+r2OOd09JbCXZKD13x8DNc/mixN3aexjhHoxIM1Zmk=; b=LMW7ZfSkRysOTOjuZ5GVzG/afRQzKW6xiYzN4rORSdUkcj7mRKnta8nbtYJ212vtOb DXW6M3/TbuLUa7QtMgw0fV6Rac3WC+9q/dMWFkzuzl92LcZGIaZGU6Q6l3/qkOy/Le6h B5R2+vAIFOaahouJl8YDsz1BDRLW71aYj2yANrdlMoXzEy7vvLGmI2AM9J41hdyAwdcc 7A9N66IlicCuxKJq8tr4Ad7kGfLEaCPmW+uj73l12FncD09NJ+4XYPV1oFuLx1cNA5Me uSRx96ZBDGbIgsZps+rYLWLhkQx138uDyJ4CzchcrUt7upd6mtU3OHWCm1AYh0dALrVc VPPA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696911193; x=1697515993; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=I+r2OOd09JbCXZKD13x8DNc/mixN3aexjhHoxIM1Zmk=; b=w0TzK6yHkBEr6NEXfxYtivm0rxfTkuGAib2nYbHczNjxnxHLA61qIC5NruL/d/4NSV 524Fb3vf8pNvqk6EjYAJ+MXn5UTi9ctrZMrM+RVgB/Oh87Z9kYKTyfHqdqvL2JRRfvRL dA2lG5kKJ7UuSdeQknNjs04mqphvRZlTGK5ndyf3uOdGSiQFaX6wDbN1D6zzNoDnCFQM p5BG+m74jJHCd3+i4XD8XxjDimI9gwFYwieGyRcXQWuZp6abv2Xed8PULIjMpn1VNIMp Kl2/U1lKFKFeH0nZnLqbC0DsujDUHxDsz052I73Llql93dfaCxTylgAc3xINV9i7xeKV tw3Q== X-Gm-Message-State: AOJu0YwURBnhmRc7QO8mgNqcldTaWcyUyPtToNeQFxmULNimD2p1t4gz lDLyvNY7bVLDgoPuVXnhKEu6Cz/frQEQYRVDq6seZVEA+iSBuiFAo/fjlk+YOSNbkkNkB1hQW9Y iVU8t5oFwC69mdfndN+BsRYR6utqM35mGhqXtZa+1vJH8+A6PE44CdIjxxyfA4zHNN28ivdM+6T iKehnMLg== X-Received: by 2002:a05:6a20:7343:b0:14c:3218:c1bd with SMTP id v3-20020a056a20734300b0014c3218c1bdmr19948200pzc.11.1696911193174; Mon, 09 Oct 2023 21:13:13 -0700 (PDT) Received: from SiX1E.. ([12.44.202.61]) by smtp.gmail.com with ESMTPSA id f12-20020a170902ab8c00b001c444106bcasm10501093plr.46.2023.10.09.21.13.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:13:12 -0700 (PDT) From: Kito Cheng To: gcc-patches@gcc.gnu.org, kito.cheng@gmail.com, palmer@dabbelt.com, jeffreyalaw@gmail.com, rdapp@ventanamicro.com, juzhe.zhong@rivai.ai Cc: Kito Cheng Subject: [PATCH v2 1/4] options: Define TARGET__P and TARGET__OPTS_P macro for Mask and InverseMask Date: Mon, 9 Oct 2023 21:13:02 -0700 Message-Id: <20231010041305.9111-2-kito.cheng@sifive.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231010041305.9111-1-kito.cheng@sifive.com> References: <20231010041305.9111-1-kito.cheng@sifive.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.2 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1779340434929050747 X-GMAIL-MSGID: 1779340434929050747 We TARGET__P marcro to test a Mask and InverseMask with user specified target_variable, however we may want to test with specific gcc_options variable rather than target_variable. Like RISC-V has defined lots of Mask with TargetVariable, which is not easy to use, because that means we need to known which Mask are associate with which TargetVariable, so take a gcc_options variable is a better interface for such use case. gcc/ChangeLog: * doc/options.texi (Mask): Document TARGET__P and TARGET__OPTS_P. (InverseMask): Ditto. * opth-gen.awk (Mask): Generate TARGET__P and TARGET__OPTS_P macro. (InverseMask): Ditto. --- gcc/doc/options.texi | 23 ++++++++++++++++------- gcc/opth-gen.awk | 13 ++++++++++++- 2 files changed, 28 insertions(+), 8 deletions(-) diff --git a/gcc/doc/options.texi b/gcc/doc/options.texi index 1f7c15b8eb4..715f0a1479c 100644 --- a/gcc/doc/options.texi +++ b/gcc/doc/options.texi @@ -404,18 +404,27 @@ You may also specify @code{Var} to select a variable other than The options-processing script will automatically allocate a unique bit for the option. If the option is attached to @samp{target_flags} or @code{Var} which is defined by @code{TargetVariable}, the script will set the macro -@code{MASK_@var{name}} to the appropriate bitmask. It will also declare a -@code{TARGET_@var{name}} macro that has the value 1 when the option is active -and 0 otherwise. If you use @code{Var} to attach the option to a different variable -which is not defined by @code{TargetVariable}, the bitmask macro with be -called @code{OPTION_MASK_@var{name}}. +@code{MASK_@var{name}} to the appropriate bitmask. It will also declare a +@code{TARGET_@var{name}}, @code{TARGET_@var{name}_P} and +@code{TARGET_@var{name}_OPTS_P}: @code{TARGET_@var{name}} macros that has the +value 1 when the option is active and 0 otherwise, @code{TARGET_@var{name}_P} is +similar to @code{TARGET_@var{name}} but take an argument as @samp{target_flags} +or @code{TargetVariable}, and @code{TARGET_@var{name}_OPTS_P} also similar to +@code{TARGET_@var{name}} but take an argument as @code{gcc_options}. +If you use @code{Var} to attach the option to a different variable which is not +defined by @code{TargetVariable}, the bitmask macro with be called +@code{OPTION_MASK_@var{name}}. @item InverseMask(@var{othername}) @itemx InverseMask(@var{othername}, @var{thisname}) The option is the inverse of another option that has the @code{Mask(@var{othername})} property. If @var{thisname} is given, -the options-processing script will declare a @code{TARGET_@var{thisname}} -macro that is 1 when the option is active and 0 otherwise. +the options-processing script will declare @code{TARGET_@var{thisname}}, +@code{TARGET_@var{name}_P} and @code{TARGET_@var{name}_OPTS_P} macros: +@code{TARGET_@var{thisname}} is 1 when the option is active and 0 otherwise, +@code{TARGET_@var{name}_P} is similar to @code{TARGET_@var{name}} but take an +argument as @samp{target_flags}, and and @code{TARGET_@var{name}_OPTS_P} also +similar to @code{TARGET_@var{name}} but take an argument as @code{gcc_options}. @item Enum(@var{name}) The option's argument is a string from the set of strings associated diff --git a/gcc/opth-gen.awk b/gcc/opth-gen.awk index c4398be2f3a..26551575d55 100644 --- a/gcc/opth-gen.awk +++ b/gcc/opth-gen.awk @@ -439,6 +439,10 @@ for (i = 0; i < n_target_vars; i++) { print "#define TARGET_" other_masks[i "," j] \ " ((" target_vars[i] " & MASK_" other_masks[i "," j] ") != 0)" + print "#define TARGET_" other_masks[i "," j] "_P(" target_vars[i] ")" \ + " (((" target_vars[i] ") & MASK_" other_masks[i "," j] ") != 0)" + print "#define TARGET_" other_masks[i "," j] "_OPTS_P(opts)" \ + " (((opts->x_" target_vars[i] ") & MASK_" other_masks[i "," j] ") != 0)" } } print "" @@ -469,15 +473,22 @@ for (i = 0; i < n_opts; i++) { " ((" vname " & " mask original_name ") != 0)" print "#define TARGET_" name "_P(" vname ")" \ " (((" vname ") & " mask original_name ") != 0)" + print "#define TARGET_" name "_OPTS_P(opts)" \ + " (((opts->x_" vname ") & " mask original_name ") != 0)" print "#define TARGET_EXPLICIT_" name "_P(opts)" \ " ((opts->x_" vname "_explicit & " mask original_name ") != 0)" print "#define SET_TARGET_" name "(opts) opts->x_" vname " |= " mask original_name } } for (i = 0; i < n_extra_masks; i++) { - if (extra_mask_macros[extra_masks[i]] == 0) + if (extra_mask_macros[extra_masks[i]] == 0) { print "#define TARGET_" extra_masks[i] \ " ((target_flags & MASK_" extra_masks[i] ") != 0)" + print "#define TARGET_" extra_masks[i] "_P(target_flags)" \ + " (((target_flags) & " extra_masks[i] ") != 0)" + print "#define TARGET_" extra_masks[i] "_OPTS_P(opts)" \ + " (((opts->x_target_flags) & MASK_" extra_masks[i] ") != 0)" + } } print "" From patchwork Tue Oct 10 04:13:03 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kito Cheng X-Patchwork-Id: 150475 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:a888:0:b0:403:3b70:6f57 with SMTP id x8csp2267110vqo; Mon, 9 Oct 2023 21:15:02 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFyCCIaM7ifusxudt1qzmT9B0UK/1bvrrwZoAlXQaOgmf5bSH4zJpdD6ilgtw3lkmYQlZaQ X-Received: by 2002:ac2:43cf:0:b0:503:655:12e0 with SMTP id u15-20020ac243cf000000b00503065512e0mr14138861lfl.50.1696911302402; Mon, 09 Oct 2023 21:15:02 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696911302; cv=none; d=google.com; s=arc-20160816; b=wi+3Vij2u0zM0lGGTis2iamzVJe+5eVdjHnbuveUR44N3dLQq45lYWmBlLUjzOHJ80 hLmtqJxmfHBplc1vwgd3LF9/l+8NVmwbh/3+hYMVYF7lklTO8GEz9Y7q5PdReVaM3bFC UqCt8gvDLpNtj7WG6IvTi04oPjnKPiLfRfjagvEV7y0+V8mbCsSDBqefJCp+0ATFdbx3 8pD3Mmf8FOf+aq0mcATIkT1i2tgN7UIVKmRr28LekhslN5zwwJwUvTgizamUl+uebzEb PIPn59U7uF05A4EK2HRTf6yRLyr3D3Z5UfaDD44xUWFava4oNQj6bVRuZBrIScFvafiE FQpg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature:dmarc-filter:delivered-to; bh=6E7yDBTdKJ6hyEOKWAJVMDo4SvFXHLwAHMqY2S16fXI=; fh=kbV0NOqiTuorklH6HBA9bfclLeeDA0ay8K7s4dUrk/A=; b=N4P+6IgqGR0DVEs9aljokm/O5iT9DBEvWNM8QJaBLWZszmkyEM5CUcdRese4mVa25w rA49DHGkAJj12AzSvBb5i/k7LJ9Cbm8gMTiY7NYkwqU1W5WOt2GQ5SXvicNrvWWqvrPh uLnIV91McsOrh3qVdxMLOAD1P1nUYz5sPfuA3McDplKaaRcKNSwIrwHfjpT5mwrmzCCq cvLoWZMCiAbDz3UL2QLbN988WdRPr47KTK295QKrBoKNxOJcwwW2PMcl0fv6i/g3VdZd HiuoZiWh5mORWbwqbmqZ9dnnFJhUX7fIJxjDmv9LSkVpU96o5t6txN++1GuxVCFs49An dTAg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=Acq7PKZW; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (ip-8-43-85-97.sourceware.org. [8.43.85.97]) by mx.google.com with ESMTPS id m17-20020a50ef11000000b00532c6fcb85esi4832818eds.143.2023.10.09.21.15.02 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:15:02 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) client-ip=8.43.85.97; Authentication-Results: mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=Acq7PKZW; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 8.43.85.97 as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 2EBA93836E87 for ; Tue, 10 Oct 2023 04:13:48 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-pf1-x42d.google.com (mail-pf1-x42d.google.com [IPv6:2607:f8b0:4864:20::42d]) by sourceware.org (Postfix) with ESMTPS id 2C7963858C30 for ; Tue, 10 Oct 2023 04:13:16 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 2C7963858C30 Authentication-Results: sourceware.org; dmarc=pass (p=reject dis=none) header.from=sifive.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=sifive.com Received: by mail-pf1-x42d.google.com with SMTP id d2e1a72fcca58-69af8a42066so2929176b3a.1 for ; Mon, 09 Oct 2023 21:13:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1696911195; x=1697515995; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=6E7yDBTdKJ6hyEOKWAJVMDo4SvFXHLwAHMqY2S16fXI=; b=Acq7PKZWCGyNeHtq/bpMOmzlA3eu6/Wb2r8DdC8TIJtxpEwSnfiHWqxJoQIYmGUF0o f7/W37m5cvHm9hGxNQ+Of/OJRLpgDgIeeAoDpjrYZX7sZ6VKN+YMclzhe3muQPWgr655 Af6qX5ybEtf2/KRSZUlTwaaC88xeE3mkoh7IY+AJ0LPg6Bf6jaQbxw//fHtXFX1vY6L6 3nSI2j57gWzmFqe25zol81pd3EMBmd6LijaWk4/Tr69H3WOEIisNqW+9zppKyi4YjQPa MyNVPbLWCOMICwLtFTKpcArr5ZuAroa3zL1kh/fzzzXjsS9Lhhe/TMzGhQoV/sFNHzBA MMxg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696911195; x=1697515995; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=6E7yDBTdKJ6hyEOKWAJVMDo4SvFXHLwAHMqY2S16fXI=; b=dwiaUuecsj1mddPVr88JRuiCgsZEr/sdwhDepd+d4JZ+sasDQDGF9N1ZZMNXjaBZnD cC7YKTWjk0o+LlbCB+h3lR7ZhdYr5VNqSlNKYnvTKNUaxs/JtyX3yUtI/ngKXbon+xf6 nozip2mT82fA6FM56/lvkQCbc0GapCIZKbQylz3vv2qFxgCjwsAIpTmVi6lvqhTYflMC lqfh4m6PSt0staZC2y8dkTAwlM1WsL2Tik7WRwldp21Yi54j8LKYRnLkP7X6PkTFjLsg zfudGeqGBUFwoFKgO48DymUf1wPs8RpG+TpwCQGtLjNXiJV9CfvJXHRiafQNREKmkf9K XuVA== X-Gm-Message-State: AOJu0YzWd8PJNBhSLSDa1xqirGtD8VAnoT2B9dIJEDD7HpOoyagdGpWc EdXYLeKvXT8rIJNbrsR+zQs/vv/NlQmoPB/Wk6S2Yj4f0L+vhE77mLjI9yT9RPxgG+sSb47kTz3 BpzpNqkp09LDakUJ/K7TvegGDWJAYdETZ0UxaImNy98vItpTlnpLLO/aRLF/PvDklAhcjoKDdgD 0CsS9S5Q== X-Received: by 2002:a05:6a20:394b:b0:171:a8bc:74b2 with SMTP id r11-20020a056a20394b00b00171a8bc74b2mr1084479pzg.7.1696911194492; Mon, 09 Oct 2023 21:13:14 -0700 (PDT) Received: from SiX1E.. ([12.44.202.61]) by smtp.gmail.com with ESMTPSA id f12-20020a170902ab8c00b001c444106bcasm10501093plr.46.2023.10.09.21.13.13 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:13:14 -0700 (PDT) From: Kito Cheng To: gcc-patches@gcc.gnu.org, kito.cheng@gmail.com, palmer@dabbelt.com, jeffreyalaw@gmail.com, rdapp@ventanamicro.com, juzhe.zhong@rivai.ai Cc: Kito Cheng Subject: [PATCH v2 2/4] RISC-V: Refactor riscv_option_override and riscv_convert_vector_bits. [NFC] Date: Mon, 9 Oct 2023 21:13:03 -0700 Message-Id: <20231010041305.9111-3-kito.cheng@sifive.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231010041305.9111-1-kito.cheng@sifive.com> References: <20231010041305.9111-1-kito.cheng@sifive.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.4 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1779340465713928664 X-GMAIL-MSGID: 1779340465713928664 Allow those funciton apply from a local gcc_options rather than the global options. Preparatory for target attribute, sperate this change for eaiser reivew since it's a NFC. gcc/ChangeLog: * config/riscv/riscv.cc (riscv_convert_vector_bits): Get setting from argument rather than get setting from global setting. (riscv_override_options_internal): New, splited from riscv_override_options, also take a gcc_options argument. (riscv_option_override): Splited most part to riscv_override_options_internal. --- gcc/config/riscv/riscv.cc | 93 ++++++++++++++++++++++----------------- 1 file changed, 52 insertions(+), 41 deletions(-) diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index b7acf836d02..c7d0d300345 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -8066,10 +8066,11 @@ riscv_init_machine_status (void) /* Return the VLEN value associated with -march. TODO: So far we only support length-agnostic value. */ static poly_uint16 -riscv_convert_vector_bits (void) +riscv_convert_vector_bits (struct gcc_options *opts) { int chunk_num; - if (TARGET_MIN_VLEN > 32) + int min_vlen = TARGET_MIN_VLEN_OPTS (opts); + if (min_vlen > 32) { /* When targetting minimum VLEN > 32, we should use 64-bit chunk size. Otherwise we can not include SEW = 64bits. @@ -8087,7 +8088,7 @@ riscv_convert_vector_bits (void) - TARGET_MIN_VLEN = 2048bit: [256,256] - TARGET_MIN_VLEN = 4096bit: [512,512] FIXME: We currently DON'T support TARGET_MIN_VLEN > 4096bit. */ - chunk_num = TARGET_MIN_VLEN / 64; + chunk_num = min_vlen / 64; } else { @@ -8106,10 +8107,10 @@ riscv_convert_vector_bits (void) to set RVV mode size. The RVV machine modes size are run-time constant if TARGET_VECTOR is enabled. The RVV machine modes size remains default compile-time constant if TARGET_VECTOR is disabled. */ - if (TARGET_VECTOR) + if (TARGET_VECTOR_OPTS_P (opts)) { - if (riscv_autovec_preference == RVV_FIXED_VLMAX) - return (int) TARGET_MIN_VLEN / (riscv_bytes_per_vector_chunk * 8); + if (opts->x_riscv_autovec_preference == RVV_FIXED_VLMAX) + return (int) min_vlen / (riscv_bytes_per_vector_chunk * 8); else return poly_uint16 (chunk_num, chunk_num); } @@ -8117,40 +8118,33 @@ riscv_convert_vector_bits (void) return 1; } -/* Implement TARGET_OPTION_OVERRIDE. */ - -static void -riscv_option_override (void) +/* 'Unpack' up the internal tuning structs and update the options + in OPTS. The caller must have set up selected_tune and selected_arch + as all the other target-specific codegen decisions are + derived from them. */ +void +riscv_override_options_internal (struct gcc_options *opts) { const struct riscv_tune_info *cpu; -#ifdef SUBTARGET_OVERRIDE_OPTIONS - SUBTARGET_OVERRIDE_OPTIONS; -#endif - - flag_pcc_struct_return = 0; - - if (flag_pic) - g_switch_value = 0; - /* The presence of the M extension implies that division instructions are present, so include them unless explicitly disabled. */ - if (TARGET_MUL && (target_flags_explicit & MASK_DIV) == 0) - target_flags |= MASK_DIV; - else if (!TARGET_MUL && TARGET_DIV) + if (TARGET_MUL_OPTS_P (opts) && (target_flags_explicit & MASK_DIV) == 0) + opts->x_target_flags |= MASK_DIV; + else if (!TARGET_MUL_OPTS_P (opts) && TARGET_DIV_OPTS_P (opts)) error ("%<-mdiv%> requires %<-march%> to subsume the % extension"); /* Likewise floating-point division and square root. */ if ((TARGET_HARD_FLOAT || TARGET_ZFINX) && (target_flags_explicit & MASK_FDIV) == 0) - target_flags |= MASK_FDIV; + opts->x_target_flags |= MASK_FDIV; /* Handle -mtune, use -mcpu if -mtune is not given, and use default -mtune if both -mtune and -mcpu are not given. */ - cpu = riscv_parse_tune (riscv_tune_string ? riscv_tune_string : - (riscv_cpu_string ? riscv_cpu_string : + cpu = riscv_parse_tune (opts->x_riscv_tune_string ? opts->x_riscv_tune_string : + (opts->x_riscv_cpu_string ? opts->x_riscv_cpu_string : RISCV_TUNE_STRING_DEFAULT)); riscv_microarchitecture = cpu->microarchitecture; - tune_param = optimize_size ? &optimize_size_tune_info : cpu->tune_param; + tune_param = opts->x_optimize_size ? &optimize_size_tune_info : cpu->tune_param; /* Use -mtune's setting for slow_unaligned_access, even when optimizing for size. For architectures that trap and emulate unaligned accesses, @@ -8166,15 +8160,38 @@ riscv_option_override (void) if ((target_flags_explicit & MASK_STRICT_ALIGN) == 0 && cpu->tune_param->slow_unaligned_access) - target_flags |= MASK_STRICT_ALIGN; + opts->x_target_flags |= MASK_STRICT_ALIGN; /* If the user hasn't specified a branch cost, use the processor's default. */ - if (riscv_branch_cost == 0) - riscv_branch_cost = tune_param->branch_cost; + if (opts->x_riscv_branch_cost == 0) + opts->x_riscv_branch_cost = tune_param->branch_cost; - /* Function to allocate machine-dependent function status. */ - init_machine_status = &riscv_init_machine_status; + /* FIXME: We don't allow TARGET_MIN_VLEN > 4096 since the datatypes of + both GET_MODE_SIZE and GET_MODE_BITSIZE are poly_uint16. + + We can only allow TARGET_MIN_VLEN * 8 (LMUL) < 65535. */ + if (TARGET_MIN_VLEN_OPTS (opts) > 4096) + sorry ("Current RISC-V GCC cannot support VLEN greater than 4096bit for " + "'V' Extension"); + + /* Convert -march to a chunks count. */ + riscv_vector_chunks = riscv_convert_vector_bits (opts); +} + +/* Implement TARGET_OPTION_OVERRIDE. */ + +static void +riscv_option_override (void) +{ +#ifdef SUBTARGET_OVERRIDE_OPTIONS + SUBTARGET_OVERRIDE_OPTIONS; +#endif + + flag_pcc_struct_return = 0; + + if (flag_pic) + g_switch_value = 0; if (flag_pic) riscv_cmodel = CM_PIC; @@ -8289,20 +8306,14 @@ riscv_option_override (void) riscv_stack_protector_guard_offset = offs; } - /* FIXME: We don't allow TARGET_MIN_VLEN > 4096 since the datatypes of - both GET_MODE_SIZE and GET_MODE_BITSIZE are poly_uint16. - - We can only allow TARGET_MIN_VLEN * 8 (LMUL) < 65535. */ - if (TARGET_MIN_VLEN > 4096) - sorry ( - "Current RISC-V GCC cannot support VLEN greater than 4096bit for 'V' Extension"); - SET_OPTION_IF_UNSET (&global_options, &global_options_set, param_sched_pressure_algorithm, SCHED_PRESSURE_MODEL); - /* Convert -march to a chunks count. */ - riscv_vector_chunks = riscv_convert_vector_bits (); + /* Function to allocate machine-dependent function status. */ + init_machine_status = &riscv_init_machine_status; + + riscv_override_options_internal (&global_options); } /* Implement TARGET_CONDITIONAL_REGISTER_USAGE. */ From patchwork Tue Oct 10 04:13:04 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kito Cheng X-Patchwork-Id: 150477 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:a888:0:b0:403:3b70:6f57 with SMTP id x8csp2267480vqo; Mon, 9 Oct 2023 21:16:14 -0700 (PDT) X-Google-Smtp-Source: AGHT+IFZWGVkjGhKKVfx2EEuXghuRBj6+NUeXLTE2bKQdcGDlEKhK/o5JuLp6wjZ8dceVpjB06kM X-Received: by 2002:a17:906:2cf:b0:9ae:3d6b:9521 with SMTP id 15-20020a17090602cf00b009ae3d6b9521mr14181022ejk.56.1696911374464; Mon, 09 Oct 2023 21:16:14 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696911374; cv=none; d=google.com; s=arc-20160816; b=HHhQ/RQ5Q7Zf76g90cFY1xZryzfP6AZNd3e9MsP7aJteT6EK+XukxAHRw8XOjVUXas kmsQppK06ZLyhvQPW2pG7V7S9GBQykA6WZNYXZ0Hrn+OLrKEB7oC9elVPF6q6Kx9U2ea CHk0VCWSSzUVsfU2miVHCKuvqH/6e/3e42Sk+HUS9BEt3OhEpyFtZh8fT1Owqf2nguB0 hpysnkXoSoI/2odl36vBpOBQ8TFLaoNnJsv4K1kexlAJISnV5I+ruA9g9yseCkvNsK7c Qm9/js1MF+wnQD0VPAoB897DRuKMfb/P1xOe6uOJMgylwM5B2BvJyye5A/cq9uJeEsic bdTA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature:dmarc-filter:delivered-to; bh=fazDJXEwSYluJiExSRlzb6kdznCAvsQHGliKZlk3pY8=; fh=kbV0NOqiTuorklH6HBA9bfclLeeDA0ay8K7s4dUrk/A=; b=0JUj2Gns3ismmtwETzperU257YCt3131yOLyG1/Jj/GFckmnXvB0TKXqKUQzOEqQg4 ZBmbpg4U6V8q4w4U0DqiEnMhRsPL/Zd8fZPbVtiYkvkOr8iyaUAkIQp89P+dqUb61XeP PeQg13JhHAkR7vI0RvYlgfe/cSs+wXawB9wubCoARa6kJC3Eh3QgFfrwzNU2ibNVBClt jDB2QjTCXTRTtZGeswTe6pMOGT+pFlvWcFthRHMKm7vUgWugyOE3D0QVTrvDQV3wO5tj EDo26gErg2HyYqlaeEpltfnNTA8RDrBV5Q1BMY7enaWeLAzQtblQVTZlLMTMnge6WJ3a stag== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=DzkVz+iC; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id rn19-20020a170906d93300b0099318359ea8si5144067ejb.452.2023.10.09.21.16.14 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:16:14 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=DzkVz+iC; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id D191F385414F for ; Tue, 10 Oct 2023 04:14:11 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-pl1-x633.google.com (mail-pl1-x633.google.com [IPv6:2607:f8b0:4864:20::633]) by sourceware.org (Postfix) with ESMTPS id 89D2238582B0 for ; Tue, 10 Oct 2023 04:13:17 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 89D2238582B0 Authentication-Results: sourceware.org; dmarc=pass (p=reject dis=none) header.from=sifive.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=sifive.com Received: by mail-pl1-x633.google.com with SMTP id d9443c01a7336-1c5bf7871dcso37976935ad.1 for ; Mon, 09 Oct 2023 21:13:17 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1696911196; x=1697515996; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=fazDJXEwSYluJiExSRlzb6kdznCAvsQHGliKZlk3pY8=; b=DzkVz+iCCq56n1MmAwzuhP4oOvrWPSeZc7IA873VkowIdlajSTilfchgy547Wz95T2 DG0dU1hMNujlO1xiRW9/DnldsGIU3O0JSyQ2IEANvinLLGZin7ti67GMT/PVRMVwtGCC eTgZ/4PoGAf1B+kz8Kof80UThrslu6Uqrs9VxxurliKgo5cLl63hjlmRgBgu6N+xRi+m TBYVuz1+I7BQsNF5L6jw40IhMP+DQr08nWNlTrUUqALyQcwR+wzM2S4A7D16GPKDQX2+ 8dUb/56inmppAoX58Yfqs/pPFc8QGgGQT3/8SwryJxvyeklPX1roCwcuOGPEEPCXE4Yg WIjw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696911196; x=1697515996; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=fazDJXEwSYluJiExSRlzb6kdznCAvsQHGliKZlk3pY8=; b=urfGyLhw4yF/+kv17F9bYSpuZqzNB0fmR1Jn0wee4aNxuAF2vlJ5/+ub8qeKK3wGZg gfLGGVnKIn3DRRpMoxmBD4ert5EUKx7A32XvAwXCGapW64DVS+rpRvGbwq7Ko9gDVPzq dJEjN+ZkBk1/FKCPNOfwejIA88kb2KRR4Gkt+XgJJaITOkIfvlCXLwnRMtsoLtazAo/H cJOCamDxcGANfH3KYONVeebCMKHHDas2WkPDlmotOqLe2VoZHc6eeGwMqF6hUOAEGhkR BTdBzIAaZDeqeZMuTgPJ7sngzy9O9qGrl1AyQDJGCOwr3SLNXy75nw22caIm1CvrdYcS LcJA== X-Gm-Message-State: AOJu0Ywmyy0BGjN8jcnL5FLL4fEHYhJFblwC0fE7BijgfQ6DoJMC2/bI eKS4prldVgMC0hIv1BM7xmnizcEL6mDa5IBLBSRKhBXdHUA6d2btphr2MRjJG2TaDI800STRc4k LSFRIdZiTtmwekTg0k371JT9JwakzkjAOb3KpIRm/5ysOmEf7ovY8abZHjhxoElb+ztHBO23n5A rYEUZojA== X-Received: by 2002:a17:903:54d:b0:1c6:1206:c5b0 with SMTP id jo13-20020a170903054d00b001c61206c5b0mr12712770plb.67.1696911195891; Mon, 09 Oct 2023 21:13:15 -0700 (PDT) Received: from SiX1E.. ([12.44.202.61]) by smtp.gmail.com with ESMTPSA id f12-20020a170902ab8c00b001c444106bcasm10501093plr.46.2023.10.09.21.13.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:13:15 -0700 (PDT) From: Kito Cheng To: gcc-patches@gcc.gnu.org, kito.cheng@gmail.com, palmer@dabbelt.com, jeffreyalaw@gmail.com, rdapp@ventanamicro.com, juzhe.zhong@rivai.ai Cc: Kito Cheng Subject: [PATCH v2 3/4] RISC-V: Extend riscv_subset_list, preparatory for target attribute support Date: Mon, 9 Oct 2023 21:13:04 -0700 Message-Id: <20231010041305.9111-4-kito.cheng@sifive.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231010041305.9111-1-kito.cheng@sifive.com> References: <20231010041305.9111-1-kito.cheng@sifive.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1779340541671336392 X-GMAIL-MSGID: 1779340541671336392 riscv_subset_list only accept a full arch string before, but we need to parse single extension when supporting target attribute, also we may set a riscv_subset_list directly rather than re-parsing the ISA string again. gcc/ChangeLog: * config/riscv/riscv-subset.h (riscv_subset_list::parse_single_std_ext): New. (riscv_subset_list::parse_single_multiletter_ext): Ditto. (riscv_subset_list::clone): Ditto. (riscv_subset_list::parse_single_ext): Ditto. (riscv_subset_list::set_loc): Ditto. (riscv_set_arch_by_subset_list): Ditto. * common/config/riscv/riscv-common.cc (riscv_subset_list::parse_single_std_ext): New. (riscv_subset_list::parse_single_multiletter_ext): Ditto. (riscv_subset_list::clone): Ditto. (riscv_subset_list::parse_single_ext): Ditto. (riscv_subset_list::set_loc): Ditto. (riscv_set_arch_by_subset_list): Ditto. --- gcc/common/config/riscv/riscv-common.cc | 203 ++++++++++++++++++++++++ gcc/config/riscv/riscv-subset.h | 11 ++ 2 files changed, 214 insertions(+) diff --git a/gcc/common/config/riscv/riscv-common.cc b/gcc/common/config/riscv/riscv-common.cc index 9a0a68fe5db..25630d5923e 100644 --- a/gcc/common/config/riscv/riscv-common.cc +++ b/gcc/common/config/riscv/riscv-common.cc @@ -1036,6 +1036,41 @@ riscv_subset_list::parse_std_ext (const char *p) return p; } +/* Parsing function for one standard extensions. + + Return Value: + Points to the end of extensions. + + Arguments: + `p`: Current parsing position. */ + +const char * +riscv_subset_list::parse_single_std_ext (const char *p) +{ + if (*p == 'x' || *p == 's' || *p == 'z') + { + error_at (m_loc, + "%<-march=%s%>: Not single-letter extension. " + "%<%c%>", + m_arch, *p); + return nullptr; + } + + unsigned major_version = 0; + unsigned minor_version = 0; + bool explicit_version_p = false; + char subset[2] = {0, 0}; + + subset[0] = *p; + + p++; + + p = parsing_subset_version (subset, p, &major_version, &minor_version, + /* std_ext_p= */ true, &explicit_version_p); + + add (subset, major_version, minor_version, explicit_version_p, false); + return p; +} /* Check any implied extensions for EXT. */ void @@ -1138,6 +1173,102 @@ riscv_subset_list::handle_combine_ext () } } +/* Parsing function for multi-letter extensions. + + Return Value: + Points to the end of extensions. + + Arguments: + `p`: Current parsing position. + `ext_type`: What kind of extensions, 's', 'z' or 'x'. + `ext_type_str`: Full name for kind of extension. */ + + +const char * +riscv_subset_list::parse_single_multiletter_ext (const char *p, + const char *ext_type, + const char *ext_type_str) +{ + unsigned major_version = 0; + unsigned minor_version = 0; + size_t ext_type_len = strlen (ext_type); + + if (strncmp (p, ext_type, ext_type_len) != 0) + return NULL; + + char *subset = xstrdup (p); + const char *end_of_version; + bool explicit_version_p = false; + char *ext; + char backup; + size_t len = strlen (p); + size_t end_of_version_pos, i; + bool found_any_number = false; + bool found_minor_version = false; + + end_of_version_pos = len; + /* Find the begin of version string. */ + for (i = len -1; i > 0; --i) + { + if (ISDIGIT (subset[i])) + { + found_any_number = true; + continue; + } + /* Might be version seperator, but need to check one more char, + we only allow p, so we could stop parsing if found + any more `p`. */ + if (subset[i] == 'p' && + !found_minor_version && + found_any_number && ISDIGIT (subset[i-1])) + { + found_minor_version = true; + continue; + } + + end_of_version_pos = i + 1; + break; + } + + backup = subset[end_of_version_pos]; + subset[end_of_version_pos] = '\0'; + ext = xstrdup (subset); + subset[end_of_version_pos] = backup; + + end_of_version + = parsing_subset_version (ext, subset + end_of_version_pos, &major_version, + &minor_version, /* std_ext_p= */ false, + &explicit_version_p); + free (ext); + + if (end_of_version == NULL) + return NULL; + + subset[end_of_version_pos] = '\0'; + + if (strlen (subset) == 1) + { + error_at (m_loc, "%<-march=%s%>: name of %s must be more than 1 letter", + m_arch, ext_type_str); + free (subset); + return NULL; + } + + add (subset, major_version, minor_version, explicit_version_p, false); + p += end_of_version - subset; + free (subset); + + if (*p != '\0' && *p != '_') + { + error_at (m_loc, "%<-march=%s%>: %s must separate with %<_%>", + m_arch, ext_type_str); + return NULL; + } + + return p; + +} + /* Parsing function for multi-letter extensions. Return Value: @@ -1250,6 +1381,30 @@ riscv_subset_list::parse_multiletter_ext (const char *p, return p; } +/* Parsing function for a single-letter or multi-letter extensions. + + Return Value: + Points to the end of extensions. + + Arguments: + `p`: Current parsing position. */ + +const char * +riscv_subset_list::parse_single_ext (const char *p) +{ + switch (p[0]) + { + case 'x': + return parse_single_multiletter_ext (p, "x", "non-standard extension"); + case 'z': + return parse_single_multiletter_ext (p, "z", "sub-extension"); + case 's': + return parse_single_multiletter_ext (p, "s", "supervisor extension"); + default: + return parse_single_std_ext (p); + } +} + /* Parsing arch string to subset list, return NULL if parsing failed. */ riscv_subset_list * @@ -1342,6 +1497,26 @@ fail: return NULL; } +/* Clone whole subset list. */ + +riscv_subset_list * +riscv_subset_list::clone () const +{ + riscv_subset_list *new_list = new riscv_subset_list (m_arch, m_loc); + for (riscv_subset_t *itr = m_head; itr != NULL; itr = itr->next) + new_list->add (itr->name.c_str (), itr->major_version, itr->minor_version, + itr->explicit_version_p, true); + + new_list->m_xlen = m_xlen; + return new_list; +} + +void +riscv_subset_list::set_loc (location_t loc) +{ + m_loc = loc; +} + /* Return the current arch string. */ std::string @@ -1498,6 +1673,34 @@ static const riscv_ext_flag_table_t riscv_ext_flag_table[] = {NULL, NULL, 0} }; +void +riscv_set_arch_by_subset_list (riscv_subset_list *subset_list, + struct gcc_options *opts) +{ + if (opts) + { + const riscv_ext_flag_table_t *arch_ext_flag_tab; + /* Clean up target flags before we set. */ + for (arch_ext_flag_tab = &riscv_ext_flag_table[0]; arch_ext_flag_tab->ext; + ++arch_ext_flag_tab) + opts->*arch_ext_flag_tab->var_ref &= ~arch_ext_flag_tab->mask; + + if (subset_list->xlen () == 32) + opts->x_target_flags &= ~MASK_64BIT; + else if (subset_list->xlen () == 64) + opts->x_target_flags |= MASK_64BIT; + + for (arch_ext_flag_tab = &riscv_ext_flag_table[0]; arch_ext_flag_tab->ext; + ++arch_ext_flag_tab) + { + if (subset_list->lookup (arch_ext_flag_tab->ext)) + opts->*arch_ext_flag_tab->var_ref |= arch_ext_flag_tab->mask; + } + } + + current_subset_list = subset_list; +} + /* Parse a RISC-V ISA string into an option mask. Must clear or set all arch dependent mask bits, in case more than one -march string is passed. */ diff --git a/gcc/config/riscv/riscv-subset.h b/gcc/config/riscv/riscv-subset.h index dca07284efa..d2a4bd20530 100644 --- a/gcc/config/riscv/riscv-subset.h +++ b/gcc/config/riscv/riscv-subset.h @@ -69,8 +69,12 @@ private: const char *parse_std_ext (const char *); + const char *parse_single_std_ext (const char *); + const char *parse_multiletter_ext (const char *, const char *, const char *); + const char *parse_single_multiletter_ext (const char *, const char *, + const char *); void handle_implied_ext (const char *); bool check_implied_ext (); @@ -91,14 +95,21 @@ public: unsigned xlen () const {return m_xlen;}; + riscv_subset_list *clone () const; + static riscv_subset_list *parse (const char *, location_t); + const char *parse_single_ext (const char *); const riscv_subset_t *begin () const {return m_head;}; const riscv_subset_t *end () const {return NULL;}; int match_score (riscv_subset_list *) const; + + void set_loc (location_t); }; extern const riscv_subset_list *riscv_current_subset_list (void); +extern void +riscv_set_arch_by_subset_list (riscv_subset_list *, struct gcc_options *); #endif /* ! GCC_RISCV_SUBSET_H */ From patchwork Tue Oct 10 04:13:05 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kito Cheng X-Patchwork-Id: 150476 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:a888:0:b0:403:3b70:6f57 with SMTP id x8csp2267328vqo; Mon, 9 Oct 2023 21:15:42 -0700 (PDT) X-Google-Smtp-Source: AGHT+IHaIqiLPlJXEKDZZU5BpXfL5GHUKFPscOVCroTZ+Zp0eNu9EKTfEaHQYN6iglXqScq5Wh7s X-Received: by 2002:a17:906:51d5:b0:9b2:ba66:bbb0 with SMTP id v21-20020a17090651d500b009b2ba66bbb0mr14222094ejk.28.1696911341924; Mon, 09 Oct 2023 21:15:41 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696911341; cv=none; d=google.com; s=arc-20160816; b=ULXBOPpZDk17WdlBwImDh8ij/oa3uenmA1t5pjDGup3OFYBrMy9OwbXxyyS+GQQmBx KEgqnx3kW49WYhxGEEXA+jitQA7kaPRZhzP9VX5IaDCGlzUg3v0X3MjeAuA0L073zTVZ RjSHJiwgQB6HNN615L5B+qmozTAe1bv7JuZOZI9wS4FCFIcXswgWTmO9UkkYb7OI9Sle iN1ZBZrH5+Kgu/QKrzUlfiPjwxsDHqemqfeBg8vrmBy51qm9LIkzi3395Kzs777BwzTl wyIlRG/v+GFOIB3a8nOl088n11PqJ7Sk9W/72OabY7+ao37RCj0vdXNQj6JtYD1adXWa oA0Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=errors-to:list-subscribe:list-help:list-post:list-archive :list-unsubscribe:list-id:precedence:content-transfer-encoding :mime-version:references:in-reply-to:message-id:date:subject:cc:to :from:dkim-signature:dmarc-filter:delivered-to; bh=DUte991/T9JGWV2mtCnpEsHf9nnjxZBtHWAcLLUyibY=; fh=kbV0NOqiTuorklH6HBA9bfclLeeDA0ay8K7s4dUrk/A=; b=ns7xPdWJr/ZlKBSslSKATeGOp5Dv+0eAdEVjJiRyVlUv/JhAw9KY7tgaXya6H7RlRj PcsvW5Qjf8yxOaarhA8j12hTjH+uAPs55RQ2yFE8+xgSTWXtyvCw8DVv8upYGmVVOKjY shD9vgldySmNyw1q/Tgws0vkXRFdLR877mrsPqgzV3goudJuMCiddG31fJ0Q7HuAKKhb v7M+7GvDbrXF6ksWcWqOGheLioz5IaHusBdADoAcq03uLKzDiqHsAGdGLX5qL+cSTzfa KI9Dfi3pOjBdl6HtQ/zmISf018V3vBG91zWHYKYrXa9EyhWgsCAsYGCRHsBp8DGGvRtS 44+w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=UgCeqhA7; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id n26-20020a1709061d1a00b009b953f26abbsi5280273ejh.1019.2023.10.09.21.15.41 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:15:41 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) client-ip=2620:52:3:1:0:246e:9693:128c; Authentication-Results: mx.google.com; dkim=pass header.i=@sifive.com header.s=google header.b=UgCeqhA7; spf=pass (google.com: domain of gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org designates 2620:52:3:1:0:246e:9693:128c as permitted sender) smtp.mailfrom="gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org"; dmarc=pass (p=REJECT sp=REJECT dis=NONE) header.from=sifive.com Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 8FB4B3830B7D for ; Tue, 10 Oct 2023 04:14:00 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-pl1-x62d.google.com (mail-pl1-x62d.google.com [IPv6:2607:f8b0:4864:20::62d]) by sourceware.org (Postfix) with ESMTPS id 101A4385781F for ; Tue, 10 Oct 2023 04:13:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 101A4385781F Authentication-Results: sourceware.org; dmarc=pass (p=reject dis=none) header.from=sifive.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=sifive.com Received: by mail-pl1-x62d.google.com with SMTP id d9443c01a7336-1c736b00639so35525675ad.2 for ; Mon, 09 Oct 2023 21:13:20 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sifive.com; s=google; t=1696911199; x=1697515999; darn=gcc.gnu.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=DUte991/T9JGWV2mtCnpEsHf9nnjxZBtHWAcLLUyibY=; b=UgCeqhA7tdU4D3c8hZMNmGpvl7khwLmjdKaHDLr5W2rgC/862IU5YTV6MVDp9Gqak5 oZzKAk907xnu8Xk0mx7ovy1dSo1gOTZ2DS/DMEUgemsEEP7KvS4anEETWpm7vLT5jaQ5 bWaXn6w+PUdTz9JQDAPYEG9+U3r62D4hB10h+0PR6/aUV4CrrVBaAzu3JVOXm2NB9Lyu 4ucCdqW53K7J0tiFHSS92vrvohzIJffn2vUCj0Q/I4Pcp8pj1QJFY1ZtJe+UU3LYXuhK FkJO+yfSNCXV0elb3uJayejpYk+07d7oujaRuuNqcEok19Q7U11Csl4QE77k/bOD6qIb Nbwg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1696911199; x=1697515999; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=DUte991/T9JGWV2mtCnpEsHf9nnjxZBtHWAcLLUyibY=; b=ivBpFdoC+QDchrmAVNPafDAvj8McUY5vIreSHdPCKS62imKIvawml41Y/qfgvjsxhF Qdodh9291ltNFB/8VjZKo4K/SsFx7v0aGHGE/Zra3aMjhUIBMVSD3JE/WQFQrH2Qy7hJ YCVoojTd8SN0p1Ng/sdkvKdCOkr2hLsFhZ3gLx7vsV8jwQ1xsj/ZYC2WrXD1GfWeE4ce kVFzmWk38VP8Tnf48Hidhlalzywgj882YTOHUN3Rlw4gLxUrDINbjuTITYLUV0qupsvh OdG1T2/Fq5ZA6j6uZMYjt+DDU+e8JbNz4FpLZf388rWl7P8VMQGtBgJDEfZaXyyNCZks D/1w== X-Gm-Message-State: AOJu0YzZl0ZDq++Xxr3Ge5uL1h6f2Fxt0BzPsvWdJUBjMvdu/uuHDZkS fopPMIuazjHmtMAP9Oyjn88UQTTpMPySNVs3VPFdq4A3+emp1SEUAUmpnJtbZyMMOYyU+f1Mhq1 lhsgqch8EeGLF3Y8YGXePQemrTCu9ECEr2J5JQSz8FQjJVk6coSnSBIkoTm30q/EXbjGPUGJtaV OVjG6brg== X-Received: by 2002:a17:903:1211:b0:1c3:64f9:45ad with SMTP id l17-20020a170903121100b001c364f945admr17226149plh.48.1696911197513; Mon, 09 Oct 2023 21:13:17 -0700 (PDT) Received: from SiX1E.. ([12.44.202.61]) by smtp.gmail.com with ESMTPSA id f12-20020a170902ab8c00b001c444106bcasm10501093plr.46.2023.10.09.21.13.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Oct 2023 21:13:17 -0700 (PDT) From: Kito Cheng To: gcc-patches@gcc.gnu.org, kito.cheng@gmail.com, palmer@dabbelt.com, jeffreyalaw@gmail.com, rdapp@ventanamicro.com, juzhe.zhong@rivai.ai Cc: Kito Cheng Subject: [PATCH v2 4/4] RISC-V: Implement target attribute Date: Mon, 9 Oct 2023 21:13:05 -0700 Message-Id: <20231010041305.9111-5-kito.cheng@sifive.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231010041305.9111-1-kito.cheng@sifive.com> References: <20231010041305.9111-1-kito.cheng@sifive.com> MIME-Version: 1.0 X-Spam-Status: No, score=-12.6 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+ouuuleilei=gmail.com@gcc.gnu.org X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1779340507396058044 X-GMAIL-MSGID: 1779340507396058044 The target attribute which proposed in [1], target attribute allow user to specify a local setting per-function basis. The syntax of target attribute is `__attribute__((target("")))`. and the syntax of `` describes below: ``` ATTR-STRING := ATTR-STRING ';' ATTR | ATTR ATTR := ARCH-ATTR | CPU-ATTR | TUNE-ATTR ARCH-ATTR := 'arch=' EXTENSIONS-OR-FULLARCH EXTENSIONS-OR-FULLARCH := | EXTENSIONS := ',' | FULLARCHSTR := EXTENSION := OP := '+' VERSION := [0-9]+ 'p' [0-9]+ | [1-9][0-9]* | EXTENSION-NAME := Naming rule is defined in RISC-V ISA manual CPU-ATTR := 'cpu=' TUNE-ATTR := 'tune=' ``` [1] https://github.com/riscv-non-isa/riscv-c-api-doc/pull/35 gcc/ChangeLog: * config.gcc (riscv): Add riscv-target-attr.o. * config/riscv/riscv-opts.h (TARGET_MIN_VLEN_OPTS): New. * config/riscv/riscv-protos.h (riscv_declare_function_size) New. (riscv_option_valid_attribute_p): New. (riscv_override_options_internal): New. (struct riscv_tune_info): New. (riscv_parse_tune): New. * config/riscv/riscv-target-attr.cc (class riscv_target_attr_parser): New. (struct riscv_attribute_info): New. (riscv_attributes): New. (riscv_target_attr_parser::parse_arch): (riscv_target_attr_parser::handle_arch): (riscv_target_attr_parser::handle_cpu): (riscv_target_attr_parser::handle_tune): (riscv_target_attr_parser::update_settings): (riscv_process_one_target_attr): (num_occurences_in_str): (riscv_process_target_attr): (riscv_option_valid_attribute_p): * config/riscv/riscv.cc: Include target-globals.h and riscv-subset.h. (struct riscv_tune_info): Move to riscv-protos.h. (get_tune_str): (riscv_parse_tune): (riscv_declare_function_size): (riscv_option_override): Build target_option_default_node and target_option_current_node. (riscv_save_restore_target_globals): (riscv_option_restore): (riscv_previous_fndecl): (riscv_set_current_function): Apply the target attribute. (TARGET_OPTION_RESTORE): Define. (TARGET_OPTION_VALID_ATTRIBUTE_P): Ditto. * config/riscv/riscv.h (SWITCHABLE_TARGET): Define to 1. (ASM_DECLARE_FUNCTION_SIZE) Define. * config/riscv/riscv.opt (mtune=): Add Save attribute. (mcpu=): Ditto. (mcmodel=): Ditto. * config/riscv/t-riscv: Add build rule for riscv-target-attr.o * doc/extend.texi: Add doc for target attribute. gcc/testsuite/ChangeLog: * gcc.target/riscv/target-attr-01.c: New. * gcc.target/riscv/target-attr-02.c: Ditto. * gcc.target/riscv/target-attr-03.c: Ditto. * gcc.target/riscv/target-attr-04.c: Ditto. * gcc.target/riscv/target-attr-05.c: Ditto. * gcc.target/riscv/target-attr-06.c: Ditto. * gcc.target/riscv/target-attr-07.c: Ditto. * gcc.target/riscv/target-attr-bad-01.c: Ditto. * gcc.target/riscv/target-attr-bad-02.c: Ditto. * gcc.target/riscv/target-attr-bad-03.c: Ditto. * gcc.target/riscv/target-attr-bad-04.c: Ditto. * gcc.target/riscv/target-attr-bad-05.c: Ditto. * gcc.target/riscv/target-attr-bad-06.c: Ditto. * gcc.target/riscv/target-attr-bad-07.c: Ditto. * gcc.target/riscv/target-attr-warning-01.c: Ditto. * gcc.target/riscv/target-attr-warning-02.c: Ditto. * gcc.target/riscv/target-attr-warning-03.c: Ditto. --- gcc/config.gcc | 2 +- gcc/config/riscv/riscv-opts.h | 6 + gcc/config/riscv/riscv-protos.h | 21 + gcc/config/riscv/riscv-target-attr.cc | 395 ++++++++++++++++++ gcc/config/riscv/riscv.cc | 192 +++++++-- gcc/config/riscv/riscv.h | 6 + gcc/config/riscv/riscv.opt | 6 +- gcc/config/riscv/t-riscv | 5 + gcc/doc/extend.texi | 58 +++ .../gcc.target/riscv/target-attr-01.c | 31 ++ .../gcc.target/riscv/target-attr-02.c | 31 ++ .../gcc.target/riscv/target-attr-03.c | 26 ++ .../gcc.target/riscv/target-attr-04.c | 28 ++ .../gcc.target/riscv/target-attr-05.c | 27 ++ .../gcc.target/riscv/target-attr-06.c | 27 ++ .../gcc.target/riscv/target-attr-07.c | 25 ++ .../gcc.target/riscv/target-attr-bad-01.c | 13 + .../gcc.target/riscv/target-attr-bad-02.c | 13 + .../gcc.target/riscv/target-attr-bad-03.c | 13 + .../gcc.target/riscv/target-attr-bad-04.c | 13 + .../gcc.target/riscv/target-attr-bad-05.c | 13 + .../gcc.target/riscv/target-attr-bad-06.c | 13 + .../gcc.target/riscv/target-attr-bad-07.c | 13 + .../gcc.target/riscv/target-attr-warning-01.c | 8 + .../gcc.target/riscv/target-attr-warning-02.c | 8 + .../gcc.target/riscv/target-attr-warning-03.c | 8 + 26 files changed, 956 insertions(+), 45 deletions(-) create mode 100644 gcc/config/riscv/riscv-target-attr.cc create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-01.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-02.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-03.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-04.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-05.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-06.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-07.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-warning-01.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-warning-02.c create mode 100644 gcc/testsuite/gcc.target/riscv/target-attr-warning-03.c diff --git a/gcc/config.gcc b/gcc/config.gcc index cc37a9c768d..4c3d5cb2c8a 100644 --- a/gcc/config.gcc +++ b/gcc/config.gcc @@ -545,7 +545,7 @@ riscv*) extra_objs="riscv-builtins.o riscv-c.o riscv-sr.o riscv-shorten-memrefs.o riscv-selftests.o riscv-string.o" extra_objs="${extra_objs} riscv-v.o riscv-vsetvl.o riscv-vector-costs.o" extra_objs="${extra_objs} riscv-vector-builtins.o riscv-vector-builtins-shapes.o riscv-vector-builtins-bases.o" - extra_objs="${extra_objs} thead.o" + extra_objs="${extra_objs} thead.o riscv-target-attr.o" d_target_objs="riscv-d.o" extra_headers="riscv_vector.h" target_gtfiles="$target_gtfiles \$(srcdir)/config/riscv/riscv-vector-builtins.cc" diff --git a/gcc/config/riscv/riscv-opts.h b/gcc/config/riscv/riscv-opts.h index e7c6b75c5ea..31ee42dea6b 100644 --- a/gcc/config/riscv/riscv-opts.h +++ b/gcc/config/riscv/riscv-opts.h @@ -112,6 +112,12 @@ enum riscv_entity ? 0 \ : 32 << (__builtin_popcount (riscv_zvl_flags) - 1)) +/* Same as TARGET_MIN_VLEN, but take an OPTS as gcc_options. */ +#define TARGET_MIN_VLEN_OPTS(opts) \ + ((opts->x_riscv_zvl_flags == 0) \ + ? 0 \ + : 32 << (__builtin_popcount (opts->x_riscv_zvl_flags) - 1)) + /* We only enable VLS modes for VLA vectorization since fixed length VLMAX mode is the highest priority choice and should not conflict with VLS modes. */ #define TARGET_VECTOR_VLS \ diff --git a/gcc/config/riscv/riscv-protos.h b/gcc/config/riscv/riscv-protos.h index 43426a5326b..eb23eb1e78f 100644 --- a/gcc/config/riscv/riscv-protos.h +++ b/gcc/config/riscv/riscv-protos.h @@ -103,6 +103,7 @@ extern void riscv_split_doubleword_move (rtx, rtx); extern const char *riscv_output_move (rtx, rtx); extern const char *riscv_output_return (); extern void riscv_declare_function_name (FILE *, const char *, tree); +extern void riscv_declare_function_size (FILE *, const char *, tree); extern void riscv_asm_output_alias (FILE *, const tree, const tree); extern void riscv_asm_output_external (FILE *, const tree, const char *); extern bool @@ -579,5 +580,25 @@ th_mempair_output_move (rtx[4], bool, machine_mode, RTX_CODE); extern bool riscv_use_divmod_expander (void); void riscv_init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, tree, int); +extern bool +riscv_option_valid_attribute_p (tree, tree, tree, int); +extern void +riscv_override_options_internal (struct gcc_options *); + +struct riscv_tune_param; +/* Information about one micro-arch we know about. */ +struct riscv_tune_info { + /* This micro-arch canonical name. */ + const char *name; + + /* Which automaton to use for tuning. */ + enum riscv_microarchitecture_type microarchitecture; + + /* Tuning parameters for this micro-arch. */ + const struct riscv_tune_param *tune_param; +}; + +const struct riscv_tune_info * +riscv_parse_tune (const char *, bool); #endif /* ! GCC_RISCV_PROTOS_H */ diff --git a/gcc/config/riscv/riscv-target-attr.cc b/gcc/config/riscv/riscv-target-attr.cc new file mode 100644 index 00000000000..33cff2c222f --- /dev/null +++ b/gcc/config/riscv/riscv-target-attr.cc @@ -0,0 +1,395 @@ +/* Subroutines used for parsing target attribute for RISC-V. + Copyright (C) 2023 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 +. */ + +#define IN_TARGET_CODE 1 + +#define INCLUDE_STRING +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "target.h" +#include "tree.h" +#include "tm_p.h" +#include "diagnostic.h" +#include "opts.h" +#include "riscv-subset.h" + +namespace { +class riscv_target_attr_parser +{ +public: + riscv_target_attr_parser (location_t loc) + : m_found_arch_p (false) + , m_found_tune_p (false) + , m_found_cpu_p (false) + , m_subset_list (nullptr) + , m_loc (loc) + , m_cpu_info (nullptr) + , m_tune (nullptr) + { + } + + bool handle_arch (const char *); + bool handle_cpu (const char *); + bool handle_tune (const char *); + + void set_loc (location_t loc) { + m_loc = loc; + } + + void update_settings (struct gcc_options *opts) const; +private: + const char *m_raw_attr_str; + bool parse_arch (const char *); + + bool m_found_arch_p; + bool m_found_tune_p; + bool m_found_cpu_p; + riscv_subset_list *m_subset_list; + location_t m_loc; + const riscv_cpu_info *m_cpu_info; + const char *m_tune; +}; +} + +/* All the information needed to handle a target attribute. + NAME is the name of the attribute. + HANDLER is the function that takes the attribute string as an argument. */ + +struct riscv_attribute_info +{ + const char *name; + bool (riscv_target_attr_parser::*handler) (const char *); +}; + +/* The target attributes that we support. */ + +static const struct riscv_attribute_info riscv_attributes[] + = {{"arch", &riscv_target_attr_parser::handle_arch}, + {"cpu", &riscv_target_attr_parser::handle_cpu}, + {"tune", &riscv_target_attr_parser::handle_tune}}; + +bool +riscv_target_attr_parser::parse_arch (const char *str) +{ + if (m_subset_list) + delete m_subset_list; + /* Check if it's setting full arch string. */ + if (strncmp ("rv", str, strlen ("rv")) == 0) + { + m_subset_list = riscv_subset_list::parse (str, location_t ()); + + if (m_subset_list == nullptr) + goto fail; + + return true; + } + else + { + /* Parsing the extension list like "+[,+]*". */ + size_t len = strlen (str); + char *str_to_check = (char *) alloca (len + 1); + strcpy (str_to_check, str); + const char *token = strtok_r (str_to_check, ",", &str_to_check); + m_subset_list = riscv_current_subset_list ()->clone (); + m_subset_list->set_loc (m_loc); + while (token) + { + if (token[0] != '+') + { + error_at ( + m_loc, + "unexpected arch for % attribute: must start " + "with + or rv"); + goto fail; + } + else + { + const char *result = m_subset_list->parse_single_ext (token + 1); + /* Check parse_single_ext has consume all string. */ + if (*result != '\0') + { + error_at ( + m_loc, + "unexpected arch for % attribute: bad " + "string found %<%s%>", token); + goto fail; + } + } + token = strtok_r (NULL, ",", &str_to_check); + } + + return true; + } +fail: + if (m_subset_list != nullptr) + { + delete m_subset_list; + m_subset_list = nullptr; + } + return false; +} + +/* Handle the ARCH_STR argument to the arch= target attribute. */ + +bool +riscv_target_attr_parser::handle_arch (const char *str) +{ + if (m_found_arch_p) + warning_at (m_loc, 0, + "% attribute: arch appears more than once, the " + "settings of the last one will be used"); + m_found_arch_p = true; + return parse_arch (str); +} + +/* Handle the CPU_STR argument to the cpu= target attribute. */ + +bool +riscv_target_attr_parser::handle_cpu (const char *str) +{ + if (m_found_cpu_p) + warning_at (m_loc, 0, + "% attribute: cpu appears more than once, the " + "settings of the last one will be used"); + + m_found_cpu_p = true; + const riscv_cpu_info *cpu_info = riscv_find_cpu (str); + + if (!cpu_info) + { + error_at (m_loc, "% attribute: unknown CPU %qs", str); + return false; + } + + if (m_subset_list == nullptr) + { + const char *arch_str = cpu_info->arch; + m_subset_list = riscv_subset_list::parse (arch_str, m_loc); + gcc_assert (m_subset_list); + } + + m_cpu_info = cpu_info; + return true; +} + +/* Handle the TUNE_STR argument to the tune= target attribute. */ + +bool +riscv_target_attr_parser::handle_tune (const char *str) +{ + if (m_found_tune_p) + warning_at (m_loc, 0, + "% attribute: tune appears more than once, the " + "settings of the last one will be used"); + m_found_tune_p = true; + const struct riscv_tune_info *tune = riscv_parse_tune (str, true); + + if (tune == nullptr) + { + error_at (m_loc, "% attribute: unknown TUNE %qs", str); + return false; + } + + m_tune = tune->name; + + return true; +} + +void +riscv_target_attr_parser::update_settings (struct gcc_options *opts) const +{ + if (m_subset_list) + riscv_set_arch_by_subset_list (m_subset_list, opts); + + if (m_cpu_info) + opts->x_riscv_cpu_string = m_cpu_info->name; + + if (m_tune) + opts->x_riscv_tune_string = m_tune; + else + { + if (m_cpu_info) + opts->x_riscv_tune_string = m_cpu_info->tune; + } +} + +/* Parse ARG_STR which contains the definition of one target attribute. + Show appropriate errors if any or return true if the attribute is valid. */ + +static bool +riscv_process_one_target_attr (char *arg_str, + location_t loc, + riscv_target_attr_parser &attr_parser) +{ + size_t len = strlen (arg_str); + + if (len == 0) + { + error_at (loc, "malformed % attribute"); + return false; + } + + char *str_to_check = (char *) alloca (len + 1); + strcpy (str_to_check, arg_str); + + char *arg = strchr (str_to_check, '='); + + if (!arg) + { + error_at ( + loc, + "attribute % does not accept an argument", + str_to_check); + return false; + } + + arg[0] = '\0'; + ++arg; + for (const auto &attr : riscv_attributes) + { + /* If the names don't match up, or the user has given an argument + to an attribute that doesn't accept one, or didn't give an argument + to an attribute that expects one, fail to match. */ + if (strncmp (str_to_check, attr.name, strlen (attr.name)) != 0) + continue; + + return (&attr_parser->*attr.handler) (arg); + } + error_at (loc, "Got unknown attribute %", str_to_check); + + return false; +} + +/* Count how many times the character C appears in + NULL-terminated string STR. */ + +static unsigned int +num_occurences_in_str (char c, char *str) +{ + unsigned int res = 0; + while (*str != '\0') + { + if (*str == c) + res++; + + str++; + } + + return res; +} + +/* Parse the tree in ARGS that contains the target attribute information + and update the global target options space. */ + +static bool +riscv_process_target_attr (tree args, location_t loc, struct gcc_options *opts) +{ + if (TREE_CODE (args) == TREE_LIST) + { + do + { + tree head = TREE_VALUE (args); + if (head) + { + if (!riscv_process_target_attr (head, loc, opts)) + return false; + } + args = TREE_CHAIN (args); + } while (args); + + return true; + } + + if (TREE_CODE (args) != STRING_CST) + { + error_at (loc, "attribute % argument not a string"); + return false; + } + size_t len = strlen (TREE_STRING_POINTER (args)); + char *str_to_check = (char *) alloca (len + 1); + strcpy (str_to_check, TREE_STRING_POINTER (args)); + + /* No need to emit warning or error on empty string here, generic code already + handle this case. */ + if (len == 0) + return false; + + /* Used to catch empty spaces between commas i.e. + attribute ((target ("attr1;;attr2"))). */ + unsigned int num_commas = num_occurences_in_str (';', str_to_check); + + /* Handle multiple target attributes separated by ','. */ + char *token = strtok_r (str_to_check, ";", &str_to_check); + + riscv_target_attr_parser attr_parser (loc); + unsigned int num_attrs = 0; + while (token) + { + num_attrs++; + riscv_process_one_target_attr (token, loc, attr_parser); + token = strtok_r (NULL, ";", &str_to_check); + } + + if (num_attrs != num_commas + 1) + { + error_at (loc, "malformed % attribute", + TREE_STRING_POINTER (args)); + return false; + } + + /* Apply settings from target attribute. */ + attr_parser.update_settings (opts); + + return true; +} + +/* Implement TARGET_OPTION_VALID_ATTRIBUTE_P. This is used to + process attribute ((target ("..."))). */ + +bool +riscv_option_valid_attribute_p (tree fndecl, tree, tree args, int) +{ + struct cl_target_option cur_target; + bool ret; + tree new_target; + location_t loc = DECL_SOURCE_LOCATION (fndecl); + + /* Save the current target options to restore at the end. */ + cl_target_option_save (&cur_target, &global_options, &global_options_set); + + ret = riscv_process_target_attr (args, loc, &global_options); + + if (ret) + { + riscv_override_options_internal (&global_options); + new_target + = build_target_option_node (&global_options, &global_options_set); + } + else + new_target = NULL; + + if (fndecl && ret) + { + DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target; + } + + cl_target_option_restore (&global_options, &global_options_set, &cur_target); + return ret; +} diff --git a/gcc/config/riscv/riscv.cc b/gcc/config/riscv/riscv.cc index c7d0d300345..61c601f78b5 100644 --- a/gcc/config/riscv/riscv.cc +++ b/gcc/config/riscv/riscv.cc @@ -73,10 +73,12 @@ along with GCC; see the file COPYING3. If not see #include "tree-vectorizer.h" #include "gcse.h" #include "tree-dfa.h" +#include "target-globals.h" /* This file should be included last. */ #include "target-def.h" #include "riscv-vector-costs.h" +#include "riscv-subset.h" /* True if X is an UNSPEC wrapper around a SYMBOL_REF or LABEL_REF. */ #define UNSPEC_ADDRESS_P(X) \ @@ -261,17 +263,6 @@ struct riscv_tune_param bool use_divmod_expansion; }; -/* Information about one micro-arch we know about. */ -struct riscv_tune_info { - /* This micro-arch canonical name. */ - const char *name; - - /* Which automaton to use for tuning. */ - enum riscv_microarchitecture_type microarchitecture; - - /* Tuning parameters for this micro-arch. */ - const struct riscv_tune_param *tune_param; -}; /* Global variables for machine-dependent things. */ @@ -498,10 +489,23 @@ riscv_min_arithmetic_precision (void) return 32; } -/* Return the riscv_tune_info entry for the given name string. */ +template +static const char * +get_tune_str (const T *opts) +{ + const char *tune_string = RISCV_TUNE_STRING_DEFAULT; + if (opts->x_riscv_tune_string) + tune_string = opts->x_riscv_tune_string; + else if (opts->x_riscv_cpu_string) + tune_string = opts->x_riscv_cpu_string; + return tune_string; +} + +/* Return the riscv_tune_info entry for the given name string, return nullptr + if NULL_P is true, otherwise return an placeholder and report error. */ -static const struct riscv_tune_info * -riscv_parse_tune (const char *tune_string) +const struct riscv_tune_info * +riscv_parse_tune (const char *tune_string, bool null_p) { const riscv_cpu_info *cpu = riscv_find_cpu (tune_string); @@ -512,6 +516,9 @@ riscv_parse_tune (const char *tune_string) if (strcmp (riscv_tune_info_table[i].name, tune_string) == 0) return riscv_tune_info_table + i; + if (null_p) + return nullptr; + error ("unknown cpu %qs for %<-mtune%>", tune_string); return riscv_tune_info_table; } @@ -7929,6 +7936,33 @@ riscv_declare_function_name (FILE *stream, const char *name, tree fndecl) riscv_asm_output_variant_cc (stream, fndecl, name); ASM_OUTPUT_TYPE_DIRECTIVE (stream, name, "function"); ASM_OUTPUT_LABEL (stream, name); + if (DECL_FUNCTION_SPECIFIC_TARGET (fndecl)) + { + fprintf (stream, "\t.option push\n"); + std::string isa = riscv_current_subset_list ()->to_string (true); + fprintf (stream, "\t.option arch, %s\n", isa.c_str ()); + + struct cl_target_option *local_cl_target = + TREE_TARGET_OPTION (DECL_FUNCTION_SPECIFIC_TARGET (fndecl)); + struct cl_target_option *global_cl_target = + TREE_TARGET_OPTION (target_option_default_node); + const char *local_tune_str = get_tune_str (local_cl_target); + const char *global_tune_str = get_tune_str (global_cl_target); + if (strcmp (local_tune_str, global_tune_str) != 0) + fprintf (stream, "\t# tune = %s\n", local_tune_str); + } +} + +void +riscv_declare_function_size (FILE *stream, const char *name, tree fndecl) +{ + if (!flag_inhibit_size_directive) + ASM_OUTPUT_MEASURED_SIZE (stream, name); + + if (DECL_FUNCTION_SPECIFIC_TARGET (fndecl)) + { + fprintf (stream, "\t.option pop\n"); + } } /* Implement ASM_OUTPUT_DEF_FROM_DECLS. */ @@ -8135,16 +8169,18 @@ riscv_override_options_internal (struct gcc_options *opts) error ("%<-mdiv%> requires %<-march%> to subsume the % extension"); /* Likewise floating-point division and square root. */ - if ((TARGET_HARD_FLOAT || TARGET_ZFINX) && (target_flags_explicit & MASK_FDIV) == 0) + if ((TARGET_HARD_FLOAT_OPTS_P (opts) || TARGET_ZFINX_OPTS_P (opts)) + && ((target_flags_explicit & MASK_FDIV) == 0)) opts->x_target_flags |= MASK_FDIV; /* Handle -mtune, use -mcpu if -mtune is not given, and use default -mtune if both -mtune and -mcpu are not given. */ - cpu = riscv_parse_tune (opts->x_riscv_tune_string ? opts->x_riscv_tune_string : - (opts->x_riscv_cpu_string ? opts->x_riscv_cpu_string : - RISCV_TUNE_STRING_DEFAULT)); + const char *tune_string = get_tune_str (opts); + cpu = riscv_parse_tune (tune_string, false); riscv_microarchitecture = cpu->microarchitecture; - tune_param = opts->x_optimize_size ? &optimize_size_tune_info : cpu->tune_param; + tune_param = opts->x_optimize_size + ? &optimize_size_tune_info + : cpu->tune_param; /* Use -mtune's setting for slow_unaligned_access, even when optimizing for size. For architectures that trap and emulate unaligned accesses, @@ -8156,7 +8192,7 @@ riscv_override_options_internal (struct gcc_options *opts) /* Make a note if user explicity passed -mstrict-align for later builtin macro generation. Can't use target_flags_explicitly since it is set even for -mno-strict-align. */ - riscv_user_wants_strict_align = TARGET_STRICT_ALIGN; + riscv_user_wants_strict_align = TARGET_STRICT_ALIGN_OPTS_P (opts); if ((target_flags_explicit & MASK_STRICT_ALIGN) == 0 && cpu->tune_param->slow_unaligned_access) @@ -8314,8 +8350,41 @@ riscv_option_override (void) init_machine_status = &riscv_init_machine_status; riscv_override_options_internal (&global_options); + + /* Save these options as the default ones in case we push and pop them later + while processing functions with potential target attributes. */ + target_option_default_node = target_option_current_node + = build_target_option_node (&global_options, &global_options_set); +} + +/* Restore or save the TREE_TARGET_GLOBALS from or to NEW_TREE. + Used by riscv_set_current_function to + make sure optab availability predicates are recomputed when necessary. */ + +void +riscv_save_restore_target_globals (tree new_tree) +{ + if (TREE_TARGET_GLOBALS (new_tree)) + restore_target_globals (TREE_TARGET_GLOBALS (new_tree)); + else if (new_tree == target_option_default_node) + restore_target_globals (&default_target_globals); + else + TREE_TARGET_GLOBALS (new_tree) = save_target_globals_default_opts (); } +/* Implements TARGET_OPTION_RESTORE. Restore the backend codegen decisions + using the information saved in PTR. */ + +static void +riscv_option_restore (struct gcc_options *opts, + struct gcc_options * /* opts_set */, + struct cl_target_option * /* ptr */) +{ + riscv_override_options_internal (opts); +} + +static GTY (()) tree riscv_previous_fndecl; + /* Implement TARGET_CONDITIONAL_REGISTER_USAGE. */ static void @@ -8561,7 +8630,12 @@ riscv_get_interrupt_type (tree decl) return MACHINE_MODE; } -/* Implement `TARGET_SET_CURRENT_FUNCTION'. */ +/* Implement `TARGET_SET_CURRENT_FUNCTION'. Unpack the codegen decisions + like tuning and ISA features from the DECL_FUNCTION_SPECIFIC_TARGET + of the function, if such exists. This function may be called multiple + times on a single function so use aarch64_previous_fndecl to avoid + setting up identical state. */ + /* Sanity cheching for above function attributes. */ static void riscv_set_current_function (tree decl) @@ -8569,36 +8643,66 @@ riscv_set_current_function (tree decl) if (decl == NULL_TREE || current_function_decl == NULL_TREE || current_function_decl == error_mark_node - || ! cfun->machine - || cfun->machine->attributes_checked_p) + || ! cfun->machine) return; - cfun->machine->naked_p = riscv_naked_function_p (decl); - cfun->machine->interrupt_handler_p - = riscv_interrupt_type_p (TREE_TYPE (decl)); + if (!cfun->machine->attributes_checked_p) + { + cfun->machine->naked_p = riscv_naked_function_p (decl); + cfun->machine->interrupt_handler_p + = riscv_interrupt_type_p (TREE_TYPE (decl)); - if (cfun->machine->naked_p && cfun->machine->interrupt_handler_p) - error ("function attributes %qs and %qs are mutually exclusive", - "interrupt", "naked"); + if (cfun->machine->naked_p && cfun->machine->interrupt_handler_p) + error ("function attributes %qs and %qs are mutually exclusive", + "interrupt", "naked"); - if (cfun->machine->interrupt_handler_p) - { - tree ret = TREE_TYPE (TREE_TYPE (decl)); - tree args = TYPE_ARG_TYPES (TREE_TYPE (decl)); + if (cfun->machine->interrupt_handler_p) + { + tree ret = TREE_TYPE (TREE_TYPE (decl)); + tree args = TYPE_ARG_TYPES (TREE_TYPE (decl)); + + if (TREE_CODE (ret) != VOID_TYPE) + error ("%qs function cannot return a value", "interrupt"); - if (TREE_CODE (ret) != VOID_TYPE) - error ("%qs function cannot return a value", "interrupt"); + if (args && TREE_CODE (TREE_VALUE (args)) != VOID_TYPE) + error ("%qs function cannot have arguments", "interrupt"); - if (args && TREE_CODE (TREE_VALUE (args)) != VOID_TYPE) - error ("%qs function cannot have arguments", "interrupt"); + cfun->machine->interrupt_mode = riscv_get_interrupt_type (decl); - cfun->machine->interrupt_mode = riscv_get_interrupt_type (decl); + gcc_assert (cfun->machine->interrupt_mode != UNKNOWN_MODE); + } - gcc_assert (cfun->machine->interrupt_mode != UNKNOWN_MODE); + /* Don't print the above diagnostics more than once. */ + cfun->machine->attributes_checked_p = 1; } - /* Don't print the above diagnostics more than once. */ - cfun->machine->attributes_checked_p = 1; + if (!decl || decl == riscv_previous_fndecl) + return; + + tree old_tree = (riscv_previous_fndecl + ? DECL_FUNCTION_SPECIFIC_TARGET (riscv_previous_fndecl) + : NULL_TREE); + + tree new_tree = DECL_FUNCTION_SPECIFIC_TARGET (decl); + + /* If current function has no attributes but the previous one did, + use the default node. */ + if (!new_tree && old_tree) + new_tree = target_option_default_node; + + /* If nothing to do, return. #pragma GCC reset or #pragma GCC pop to + the default have been handled by aarch64_save_restore_target_globals from + aarch64_pragma_target_parse. */ + if (old_tree == new_tree) + return; + + riscv_previous_fndecl = decl; + + /* First set the target options. */ + cl_target_option_restore (&global_options, &global_options_set, + TREE_TARGET_OPTION (new_tree)); + + riscv_save_restore_target_globals (new_tree); } /* Implement TARGET_MERGE_DECL_ATTRIBUTES. */ @@ -9706,6 +9810,12 @@ riscv_preferred_else_value (unsigned ifn, tree vectype, unsigned int nops, #undef TARGET_OPTION_OVERRIDE #define TARGET_OPTION_OVERRIDE riscv_option_override +#undef TARGET_OPTION_RESTORE +#define TARGET_OPTION_RESTORE riscv_option_restore + +#undef TARGET_OPTION_VALID_ATTRIBUTE_P +#define TARGET_OPTION_VALID_ATTRIBUTE_P riscv_option_valid_attribute_p + #undef TARGET_LEGITIMIZE_ADDRESS #define TARGET_LEGITIMIZE_ADDRESS riscv_legitimize_address diff --git a/gcc/config/riscv/riscv.h b/gcc/config/riscv/riscv.h index 7ac78847b3a..a88c6f917a6 100644 --- a/gcc/config/riscv/riscv.h +++ b/gcc/config/riscv/riscv.h @@ -25,6 +25,8 @@ along with GCC; see the file COPYING3. If not see #include #include "config/riscv/riscv-opts.h" +#define SWITCHABLE_TARGET 1 + /* Target CPU builtins. */ #define TARGET_CPU_CPP_BUILTINS() riscv_cpu_cpp_builtins (pfile) @@ -1054,6 +1056,10 @@ while (0) #define ASM_DECLARE_FUNCTION_NAME(STR, NAME, DECL) \ riscv_declare_function_name (STR, NAME, DECL) +#undef ASM_DECLARE_FUNCTION_SIZE +#define ASM_DECLARE_FUNCTION_SIZE(FILE, FNAME, DECL) \ + riscv_declare_function_size (FILE, FNAME, DECL) + /* Add output .variant_cc directive for specific alias definition. */ #undef ASM_OUTPUT_DEF_FROM_DECLS #define ASM_OUTPUT_DEF_FROM_DECLS(STR, DECL, TARGET) \ diff --git a/gcc/config/riscv/riscv.opt b/gcc/config/riscv/riscv.opt index e35ce2de364..4898e3b8260 100644 --- a/gcc/config/riscv/riscv.opt +++ b/gcc/config/riscv/riscv.opt @@ -84,11 +84,11 @@ Target RejectNegative Joined Negative(march=) lower-case. mtune= -Target RejectNegative Joined Var(riscv_tune_string) +Target RejectNegative Joined Var(riscv_tune_string) Save -mtune=PROCESSOR Optimize the output for PROCESSOR. mcpu= -Target RejectNegative Joined Var(riscv_cpu_string) +Target RejectNegative Joined Var(riscv_cpu_string) Save -mcpu=PROCESSOR Use architecture of and optimize the output for PROCESSOR. msmall-data-limit= @@ -106,7 +106,7 @@ memory accesses to be generated as compressed instructions. Currently targets 32-bit integer load/stores. mcmodel= -Target RejectNegative Joined Enum(code_model) Var(riscv_cmodel) Init(TARGET_DEFAULT_CMODEL) +Target RejectNegative Joined Enum(code_model) Var(riscv_cmodel) Init(TARGET_DEFAULT_CMODEL) Save Specify the code model. mstrict-align diff --git a/gcc/config/riscv/t-riscv b/gcc/config/riscv/t-riscv index f137e1f17ef..d46459ff462 100644 --- a/gcc/config/riscv/t-riscv +++ b/gcc/config/riscv/t-riscv @@ -108,6 +108,11 @@ riscv-v.o: $(srcdir)/config/riscv/riscv-v.cc \ $(COMPILE) $< $(POSTCOMPILE) +riscv-target-attr.o: $(srcdir)/config/riscv/riscv-target-attr.cc $(CONFIG_H) \ + $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(DIAGNOSTIC_CORE_H) + $(COMPILER) -c $(ALL_COMPILERFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) \ + $(srcdir)/config/riscv/riscv-target-attr.cc + thead.o: $(srcdir)/config/riscv/thead.cc \ $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TARGET_H) backend.h $(RTL_H) \ memmodel.h $(EMIT_RTL_H) poly-int.h output.h diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi index b82497f00e4..d39d599ccb5 100644 --- a/gcc/doc/extend.texi +++ b/gcc/doc/extend.texi @@ -6227,8 +6227,66 @@ void f (void) __attribute__ ((interrupt ("user"))); Permissible values for this parameter are @code{user}, @code{supervisor}, and @code{machine}. If there is no parameter, then it defaults to @code{machine}. + +@end table + +The following target-specific function attributes are available for the +RISC-V target. For the most part, these options mirror the behavior of +similar command-line options (@pxref{RISC-V Options}), but on a +per-function basis. + +@table @code +@cindex @code{arch=} function attribute, RISC-V +@item arch= +Specifies the architecture version and architectural extensions to use +for this function. The behavior and permissible arguments are the same as +for the @option{-march=} command-line option, in addtion, it also support +extension enablement list, a list of extension name and prefixed with @code{+}, +like @code{arch=+zba} means enable @code{zba} extension. +Multiple extension can be enabled by separating them with a comma. For example: +@code{arch=+zba,+zbb}. + +@cindex @code{tune=} function attribute, RISC-V +@item tune= +Specifies the core for which to tune the performance of this function. +The behavior and permissible arguments are the same as for the @option{-mtune=} +command-line option. + +@cindex @code{cpu=} function attribute, RISC-V +@item cpu= +Specifies the core for which to tune the performance of this function and also +whose architectural features to use. The behavior and valid arguments are the +same as for the @option{-mcpu=} command-line option. + @end table +The above target attributes can be specified as follows: + +@smallexample +__attribute__((target("@var{attr-string}"))) +int +f (int a) +@{ + return a + 5; +@} +@end smallexample + +where @code{@var{attr-string}} is one of the attribute strings specified above. + +Multiple target function attributes can be specified by separating them with +a semicolon. For example: +@smallexample +__attribute__((target("arch=+zba,+zbb;tune=rocket"))) +int +foo (int a) +@{ + return a + 5; +@} +@end smallexample + +is valid and compiles function @code{foo} with @code{zba} +and @code{zbb} extensions and tunes it for @code{rocket}. + @node RL78 Function Attributes @subsection RL78 Function Attributes diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-01.c b/gcc/testsuite/gcc.target/riscv/target-attr-01.c new file mode 100644 index 00000000000..b3f3d65d543 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-01.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + + +/* +** foo: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ + + +long foo() __attribute__((target("arch=rv64gc_zba"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** slli\s*a1,a1,1 +** add\s*a0,a1,a0 +** ... +*/ + + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-02.c b/gcc/testsuite/gcc.target/riscv/target-attr-02.c new file mode 100644 index 00000000000..c010089a823 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-02.c @@ -0,0 +1,31 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + + +/* +** foo: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ + + +long foo() __attribute__((target("arch=+zba"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** slli\s*a1,a1,1 +** add\s*a0,a1,a0 +** ... +*/ + + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-03.c b/gcc/testsuite/gcc.target/riscv/target-attr-03.c new file mode 100644 index 00000000000..b4896cb2e27 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-03.c @@ -0,0 +1,26 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +/* +** foo: +** ... +** slli\s*a1,a1,1 +** add\s*a0,a1,a0 +** ... +*/ +long foo() __attribute__((target("arch=rv64gc"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-04.c b/gcc/testsuite/gcc.target/riscv/target-attr-04.c new file mode 100644 index 00000000000..369d6514e5a --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-04.c @@ -0,0 +1,28 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +/* +** foo: +** ... +** # tune = sifive-7-series +** ... +** slli\s*a1,a1,1 +** add\s*a0,a1,a0 +** ... +*/ +long foo() __attribute__((target("cpu=sifive-u74"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-05.c b/gcc/testsuite/gcc.target/riscv/target-attr-05.c new file mode 100644 index 00000000000..c75368dcebf --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-05.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +/* +** foo: +** ... +** # tune = sifive-7-series +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long foo() __attribute__((target("cpu=sifive-u74;arch=rv64gc_zba"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-06.c b/gcc/testsuite/gcc.target/riscv/target-attr-06.c new file mode 100644 index 00000000000..369c95eeb54 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-06.c @@ -0,0 +1,27 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +/* +** foo: +** ... +** # tune = sifive-5-series +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long foo() __attribute__((target("cpu=sifive-u74;tune=sifive-5-series;arch=rv64gc_zba"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-07.c b/gcc/testsuite/gcc.target/riscv/target-attr-07.c new file mode 100644 index 00000000000..4ff81166a62 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-07.c @@ -0,0 +1,25 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc_zba -O2 -mabi=lp64 -mtune=rocket" } */ +/* { dg-final { check-function-bodies "**" "" } } */ + +/* +** foo: +** ... +** # tune = sifive-5-series +** ... +*/ +long foo() __attribute__((target("tune=sifive-5-series"))); +long foo(long a, long b){ + return a + (b * 2); +} + +/* +** bar: +** ... +** sh1add\s*a0,a1,a0 +** ... +*/ +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c new file mode 100644 index 00000000000..91cbcaac21d --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-01.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target("arch=rv64gc_zba;;"))); /* { dg-error "malformed" } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c new file mode 100644 index 00000000000..0c838bb3ca7 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-02.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target("cpu=xyz-cpu"))); /* { dg-error "unknown CPU" } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c new file mode 100644 index 00000000000..09702d1690a --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-03.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target("tune=xyz-cpu"))); /* { dg-error "unknown TUNE" } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c new file mode 100644 index 00000000000..1d9a0ffdd88 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-04.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target(123))); /* { dg-error "argument not a string" } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c new file mode 100644 index 00000000000..24a81c5279b --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-05.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target(""))); /* { dg-warning "empty string in attribute .target." } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c new file mode 100644 index 00000000000..a0d65859d40 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-06.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target("arch=*x"))); /* { dg-error "must start with \\+ or rv" } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c b/gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c new file mode 100644 index 00000000000..8aa82504dc1 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-bad-07.c @@ -0,0 +1,13 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + + +long foo() __attribute__((target("arch=+zbb_zba"))); /* { dg-error "extension 'zbb_zba' starts with 'z' but is unsupported standard extension" } */ +long foo(long a, long b){ + return a + (b * 2); +} + +long bar(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-warning-01.c b/gcc/testsuite/gcc.target/riscv/target-attr-warning-01.c new file mode 100644 index 00000000000..d4b6e4e505a --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-warning-01.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + +long foo() __attribute__((target("arch=rv64gc_zba;arch=rv64gc_zba"))); /* { dg-warning "arch appears more than once" } */ +long foo(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-warning-02.c b/gcc/testsuite/gcc.target/riscv/target-attr-warning-02.c new file mode 100644 index 00000000000..b43b131c955 --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-warning-02.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + +long foo() __attribute__((target("cpu=sifive-u74;cpu=sifive-u74"))); /* { dg-warning "cpu appears more than once" } */ +long foo(long a, long b){ + return a + (b * 2); +} diff --git a/gcc/testsuite/gcc.target/riscv/target-attr-warning-03.c b/gcc/testsuite/gcc.target/riscv/target-attr-warning-03.c new file mode 100644 index 00000000000..551c56e37dc --- /dev/null +++ b/gcc/testsuite/gcc.target/riscv/target-attr-warning-03.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-skip-if "" { *-*-* } { "-fno-fat-lto-objects" } } */ +/* { dg-options "-march=rv64gc -O2 -mabi=lp64" } */ + +long foo() __attribute__((target("tune=sifive-u74;tune=sifive-u74"))); /* { dg-warning "tune appears more than once" } */ +long foo(long a, long b){ + return a + (b * 2); +}