From patchwork Mon Oct 23 01:44:15 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ian Lance Taylor X-Patchwork-Id: 156630 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a59:ce89:0:b0:403:3b70:6f57 with SMTP id p9csp1025471vqx; Sun, 22 Oct 2023 18:45:38 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGFe/WT/dxr4hi87XAI6KO/X1ScIRSpRdI/npxIuKfb6Kogyuu5h/WBaoEhShqrgidCoGZ/ X-Received: by 2002:a05:620a:b83:b0:76f:19f9:82a6 with SMTP id k3-20020a05620a0b8300b0076f19f982a6mr7137864qkh.21.1698025537965; Sun, 22 Oct 2023 18:45:37 -0700 (PDT) ARC-Seal: i=2; a=rsa-sha256; t=1698025537; cv=pass; d=google.com; s=arc-20160816; b=kpbtZCi00HXqq/ta+2ZDO8IeS7Q7fomA/9lSfdg6tvoQitF0wi9gWWTvS+9VBd4cgi V8tUQuBpvhS0XqqOCX/bBLJBFTnV3u1WylMYq5EmiQVIjFyNMeTRb9cPEnODP6eCn5uk hU3mP5mau2pl5bSk4S7ztVVKVhcwMNvD5KNADiow4DAdFZhswJKKM7t1mkfbUZQwSm83 UHANTl/WiqXdlvsEBYkRtXQiC4cF61LEkE+FubiE7bx0ORhzUBaav8NKEsl1QO2OmSik SS1d1SRZFa55W9KgKbx1fG1dD7kbAE1cikeLPgDz/1z/pvC1chnp+EcFtkC0ROOqHI4N u40g== ARC-Message-Signature: i=2; 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:to:subject:message-id:date:from :mime-version:dkim-signature:arc-filter:dmarc-filter:delivered-to; bh=AUjpWk2x0xK5AZcz5Cm0DtUo53yRZ4qBheVVdHKiKl0=; fh=sx1AF6BoRLLvWrm7PiL2RBt/kekZxFGoFwZKL1Ho560=; b=CRHGxSrTCHrr4eNVrwZyTehfh1/A3oIWO+26Ghlkq3qZ2iz5i9Hau3igaYmbR5BEZL zu2Y6EyV5pjECzVqGS0XCwY25IKCnH0m7kBNbvN3il9rIQmBmkxUhtarRCwCDfdGyOeA GCxb7TkyompwVHKu18V3P8sxu7jVSE+8qZp/gNrpeBQWsP4QmzalGiuyB9H/GuszNyMV 6Nd9VmJ7otJqfYzsWlWvR+iOBu5uVgfdcGd1n9jCQVG2KtSPMtu0t8JbSa8soqPyAFSA NBMs2rdh9KGcdd62zNc7C01+p3W0Jfukr+SVt27JKtbe6IRqU89IzbLqhni0DeSbgV21 PxMw== ARC-Authentication-Results: i=2; mx.google.com; dkim=pass header.i=@golang-org.20230601.gappssmtp.com header.s=20230601 header.b=V4qjuZu+; arc=pass (i=1); 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=fail (p=NONE sp=NONE dis=NONE) header.from=golang.org Received: from server2.sourceware.org (server2.sourceware.org. [2620:52:3:1:0:246e:9693:128c]) by mx.google.com with ESMTPS id pc6-20020a056214488600b0066b0f53b19asi4983567qvb.242.2023.10.22.18.45.37 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 22 Oct 2023 18:45:37 -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=@golang-org.20230601.gappssmtp.com header.s=20230601 header.b=V4qjuZu+; arc=pass (i=1); 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=fail (p=NONE sp=NONE dis=NONE) header.from=golang.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id B46DC3858298 for ; Mon, 23 Oct 2023 01:45:37 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-yw1-x1134.google.com (mail-yw1-x1134.google.com [IPv6:2607:f8b0:4864:20::1134]) by sourceware.org (Postfix) with ESMTPS id C62313857724 for ; Mon, 23 Oct 2023 01:44:27 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C62313857724 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=golang.org Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=golang.org ARC-Filter: OpenARC Filter v1.0.0 sourceware.org C62313857724 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2607:f8b0:4864:20::1134 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698025474; cv=none; b=g+aYBf7t1KcF4B1kYoLMp0TSC+AwIyuDKjD2TIZDq8Nm/g+30xPYbdOqvWejUubLQhvdUkrPKjviHqYGxT++8c/Ob4Cmjt+urmI0VjiIzAvZC9S03uRcOeZByXak91mVE1W2ws450ejkeLJc0Cem4CHC4k5IVGfGC0UdmseCUEM= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1698025474; c=relaxed/simple; bh=pkx/P9gKi6H9H1qr8AfCWvmHPJpY11nl2+LDJ3PEgMw=; h=DKIM-Signature:MIME-Version:From:Date:Message-ID:Subject:To; b=rCQ/x2Mr+62QS4s4781q+f5Ui6Dmf+61KN6ydRdQInf2oayYccArDnEGXzgBL8MKEcIENXrLRcNXjXI2y28ETw2UkSSDg9FEsrC7gyhfZMXKYaZtAXw/6hoeKtX+2+2yN8Ih4PgfXACUa9KfCkwB99Pixzk+dmlJeT1+Zp/vZjI= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-yw1-x1134.google.com with SMTP id 00721157ae682-5a87ac9d245so28987427b3.3 for ; Sun, 22 Oct 2023 18:44:27 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=golang-org.20230601.gappssmtp.com; s=20230601; t=1698025467; x=1698630267; darn=gcc.gnu.org; h=to:subject:message-id:date:from:mime-version:from:to:cc:subject :date:message-id:reply-to; bh=AUjpWk2x0xK5AZcz5Cm0DtUo53yRZ4qBheVVdHKiKl0=; b=V4qjuZu+NQDlvAn1j5RVQASD3ZLcSvGOGJtQVZorpnh7Ahq0+fB5yFYr4JViIa4Ex6 AZ+GqqilfhbwD5U/BuawB994hi0DY7t45F81wgZlYhGUsRQzOfjafC6ggw/UiTDjQOlR oW0kn7UkYeZcjqW61hZ5zMJ5z/aAidVE4V8IOuXW0QxcGx53wGk1+/gYSWfdvyetb9zD NxLpAyeaWAX1aXlE2Ew3eVNYXZOEtdfdOUaHafeodvY3YyzoDaypQ6x1cQg+sQPJjv70 8Pzx/1seRJe5+LW4YchEyr+6xo7N+1KAlmgzY6Uw2iQvNBkB/RJDENfGWAkT0YXTkTgy YVsg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1698025467; x=1698630267; h=to:subject:message-id:date:from:mime-version:x-gm-message-state :from:to:cc:subject:date:message-id:reply-to; bh=AUjpWk2x0xK5AZcz5Cm0DtUo53yRZ4qBheVVdHKiKl0=; b=nH7PG1HquFM6+APCgrpyaShkKBUQ8JCz+CP2A8xI9B8ujjLu5KQ15eV5JIXXngkSLN I0YG+bzvRlFi1bAJ0liiQSHJ/zCfZFtgHHNUPUdAhcLAzGtd5mxV8mEoyMCWMQPFGcPu UIkMxQC37/PRYM4wOHsRrWo0iLfXvJGNm1R6i7qOmHQvRx1aVvB0+uGSKTC7YpMEl71f KwoSy1drI8yVeTifiNez1h40brhqhWB1OazINPjErcrDm/eqjnG6RbjN92UbkEiJWIzF v5z61joUdn3038h+Nwo1vX1+pHwP94rFvkMpen8AFYj4/AF9wp1vER92OP21KDE+3hV/ tzIw== X-Gm-Message-State: AOJu0YxN5ptZkiJ7Povjq9HQIeWwUHN6HT/0hKt5xn6v1JQkGllcQXyc XeDs9a41NcNHZRXC0q5VXpUuPeZ9m+zBPCJUbV4vjxYDkPnfP9IWURI= X-Received: by 2002:a05:690c:f87:b0:59f:b0d9:5df2 with SMTP id df7-20020a05690c0f8700b0059fb0d95df2mr10477889ywb.0.1698025466928; Sun, 22 Oct 2023 18:44:26 -0700 (PDT) MIME-Version: 1.0 From: Ian Lance Taylor Date: Sun, 22 Oct 2023 18:44:15 -0700 Message-ID: Subject: Go patch committed: pass Gogo to more passes To: gcc-patches , gofrontend-dev X-Spam-Status: No, score=-9.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, 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: 1780508826430683598 X-GMAIL-MSGID: 1780508826430683598 This patch to the G frontend passes a pointer to the Gogo IR to the determine types pass and the type verification pass. This is a straight refactoring that does not change the compiler behavior. This is in preparation for future CLs that rearrange the pass ordering. This introduces one new call to go_get_gogo, which will be removed in a future CL. Bootstrapped and ran Go testsuite on x86_64-pc-linux-gnu. Committed to mainline. Ian b513aa235d6e5d7e2a36ee789c60891fce873340 diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE index d24054e0d93..28683d6852b 100644 --- a/gcc/go/gofrontend/MERGE +++ b/gcc/go/gofrontend/MERGE @@ -1,4 +1,4 @@ -967a215d6419c3db58f8f59a0c252c458abce395 +06ada1f2ab9b05e54641438db28c557c6900b2a3 The first line of this file holds the git revision number of the last merge done from the gofrontend repository. diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc index d276bd811cc..273831fabf3 100644 --- a/gcc/go/gofrontend/expressions.cc +++ b/gcc/go/gofrontend/expressions.cc @@ -205,18 +205,18 @@ Expression::report_error(const char* msg) // child class. void -Expression::determine_type(const Type_context* context) +Expression::determine_type(Gogo* gogo, const Type_context* context) { - this->do_determine_type(context); + this->do_determine_type(gogo, context); } // Set types when there is no context. void -Expression::determine_type_no_context() +Expression::determine_type_no_context(Gogo* gogo) { Type_context context; - this->do_determine_type(&context); + this->do_determine_type(gogo, &context); } // Return true if two expressions refer to the same variable or struct @@ -842,7 +842,7 @@ class Error_expression : public Expression { return Type::make_error_type(); } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -897,7 +897,7 @@ Type_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } void @@ -998,10 +998,10 @@ Var_expression::do_type() // Determine the type of a reference to a variable. void -Var_expression::do_determine_type(const Type_context*) +Var_expression::do_determine_type(Gogo* gogo, const Type_context*) { if (this->variable_->is_variable()) - this->variable_->var_value()->determine_type(); + this->variable_->var_value()->determine_type(gogo); } // Something takes the address of this variable. This means that we @@ -1303,9 +1303,10 @@ Set_and_use_temporary_expression::do_type() void Set_and_use_temporary_expression::do_determine_type( + Gogo* gogo, const Type_context* context) { - this->expr_->determine_type(context); + this->expr_->determine_type(gogo, context); } // Take the address. @@ -1378,7 +1379,7 @@ class Sink_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -1410,7 +1411,7 @@ Sink_expression::do_type() // Determine the type of a sink expression. void -Sink_expression::do_determine_type(const Type_context* context) +Sink_expression::do_determine_type(Gogo*, const Type_context* context) { if (context->type != NULL) this->type_ = context->type; @@ -1805,7 +1806,7 @@ class Func_code_reference_expression : public Expression { return Type::make_pointer_type(Type::make_void_type()); } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -1983,7 +1984,7 @@ class Boolean_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -2035,7 +2036,7 @@ Boolean_expression::do_type() // Set the type from the context. void -Boolean_expression::do_determine_type(const Type_context* context) +Boolean_expression::do_determine_type(Gogo*, const Type_context* context) { if (this->type_ != NULL && !this->type_->is_abstract()) ; @@ -2108,7 +2109,7 @@ String_expression::do_type() // Set the type from the context. void -String_expression::do_determine_type(const Type_context* context) +String_expression::do_determine_type(Gogo*, const Type_context* context) { if (this->type_ != NULL && !this->type_->is_abstract()) ; @@ -2278,7 +2279,7 @@ class String_info_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { go_unreachable(); } Expression* @@ -2390,7 +2391,7 @@ class String_value_expression : public Expression { return Type::make_string_type(); } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { go_unreachable(); } Expression* @@ -2499,7 +2500,7 @@ class Integer_expression : public Expression do_type(); void - do_determine_type(const Type_context* context); + do_determine_type(Gogo*, const Type_context* context); void do_check_types(Gogo*); @@ -2587,7 +2588,7 @@ Integer_expression::do_type() // abstract type to a real type. void -Integer_expression::do_determine_type(const Type_context* context) +Integer_expression::do_determine_type(Gogo*, const Type_context* context) { if (this->type_ != NULL && !this->type_->is_abstract()) ; @@ -2934,7 +2935,7 @@ class Float_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2993,7 +2994,7 @@ Float_expression::do_type() // abstract type to a real type. void -Float_expression::do_determine_type(const Type_context* context) +Float_expression::do_determine_type(Gogo*, const Type_context* context) { if (this->type_ != NULL && !this->type_->is_abstract()) ; @@ -3158,7 +3159,7 @@ class Complex_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3219,7 +3220,7 @@ Complex_expression::do_type() // abstract type to a real type. void -Complex_expression::do_determine_type(const Type_context* context) +Complex_expression::do_determine_type(Gogo*, const Type_context* context) { if (this->type_ != NULL && !this->type_->is_abstract()) ; @@ -3507,7 +3508,7 @@ Const_expression::do_type() // Set the type of the const reference. void -Const_expression::do_determine_type(const Type_context* context) +Const_expression::do_determine_type(Gogo*, const Type_context* context) { Type* ctype = this->constant_->const_value()->type(); Type* cetype = (ctype != NULL @@ -3719,7 +3720,7 @@ class Nil_expression : public Expression { return Type::make_nil_type(); } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -4137,10 +4138,10 @@ Type_conversion_expression::do_boolean_constant_value(bool* val) const // Determine the resulting type of the conversion. void -Type_conversion_expression::do_determine_type(const Type_context*) +Type_conversion_expression::do_determine_type(Gogo* gogo, const Type_context*) { Type_context subcontext(this->type_, false); - this->expr_->determine_type(&subcontext); + this->expr_->determine_type(gogo, &subcontext); } // Check that types are convertible. @@ -5087,7 +5088,7 @@ Unary_expression::do_type() // Determine abstract types for a unary expression. void -Unary_expression::do_determine_type(const Type_context* context) +Unary_expression::do_determine_type(Gogo* gogo, const Type_context* context) { switch (this->op_) { @@ -5095,7 +5096,7 @@ Unary_expression::do_determine_type(const Type_context* context) case OPERATOR_MINUS: case OPERATOR_NOT: case OPERATOR_XOR: - this->expr_->determine_type(context); + this->expr_->determine_type(gogo, context); break; case OPERATOR_AND: @@ -5105,7 +5106,7 @@ Unary_expression::do_determine_type(const Type_context* context) ? NULL : context->type->points_to()); Type_context subcontext(subtype, false); - this->expr_->determine_type(&subcontext); + this->expr_->determine_type(gogo, &subcontext); } break; @@ -5116,7 +5117,7 @@ Unary_expression::do_determine_type(const Type_context* context) ? NULL : Type::make_pointer_type(context->type)); Type_context subcontext(subtype, false); - this->expr_->determine_type(&subcontext); + this->expr_->determine_type(gogo, &subcontext); } break; @@ -6705,7 +6706,7 @@ Binary_expression::do_type() // Set type for a binary expression. void -Binary_expression::do_determine_type(const Type_context* context) +Binary_expression::do_determine_type(Gogo* gogo, const Type_context* context) { Type* tleft = this->left_->type(); Type* tright = this->right_->type(); @@ -6782,7 +6783,7 @@ Binary_expression::do_determine_type(const Type_context* context) subcontext.type = subcontext.type->make_non_abstract_type(); } - this->left_->determine_type(&subcontext); + this->left_->determine_type(gogo, &subcontext); if (is_shift_op) { @@ -6802,7 +6803,7 @@ Binary_expression::do_determine_type(const Type_context* context) subcontext.may_be_abstract = false; } - this->right_->determine_type(&subcontext); + this->right_->determine_type(gogo, &subcontext); if (is_comparison) { @@ -7689,7 +7690,8 @@ String_concat_expression::do_type() } void -String_concat_expression::do_determine_type(const Type_context* context) +String_concat_expression::do_determine_type(Gogo* gogo, + const Type_context* context) { Type_context subcontext(*context); for (Expression_list::iterator pe = this->exprs_->begin(); @@ -7708,7 +7710,7 @@ String_concat_expression::do_determine_type(const Type_context* context) for (Expression_list::iterator pe = this->exprs_->begin(); pe != this->exprs_->end(); ++pe) - (*pe)->determine_type(&subcontext); + (*pe)->determine_type(gogo, &subcontext); } void @@ -7862,7 +7864,7 @@ Bound_method_expression::do_type() // Determine the types of a method expression. void -Bound_method_expression::do_determine_type(const Type_context*) +Bound_method_expression::do_determine_type(Gogo* gogo, const Type_context*) { Named_object* fn = this->method_->named_object(); Function_type* fntype; @@ -7873,11 +7875,11 @@ Bound_method_expression::do_determine_type(const Type_context*) else fntype = NULL; if (fntype == NULL || !fntype->is_method()) - this->expr_->determine_type_no_context(); + this->expr_->determine_type_no_context(gogo); else { Type_context subcontext(fntype->receiver()->type(), false); - this->expr_->determine_type(&subcontext); + this->expr_->determine_type(gogo, &subcontext); } } @@ -8310,7 +8312,7 @@ Builtin_call_expression::do_set_recover_arg(Expression* arg) // specific expressions. We also convert to a constant if we can. Expression* -Builtin_call_expression::do_lower(Gogo*, Named_object* function, +Builtin_call_expression::do_lower(Gogo* gogo, Named_object* function, Statement_inserter* inserter, int) { if (this->is_error_expression()) @@ -8388,7 +8390,7 @@ Builtin_call_expression::do_lower(Gogo*, Named_object* function, break; case BUILTIN_MAKE: - return this->lower_make(inserter); + return this->lower_make(gogo, inserter); case BUILTIN_RECOVER: if (function != NULL) @@ -8840,7 +8842,7 @@ Builtin_call_expression::do_flatten(Gogo* gogo, Named_object* function, // Lower a make expression. Expression* -Builtin_call_expression::lower_make(Statement_inserter* inserter) +Builtin_call_expression::lower_make(Gogo* gogo, Statement_inserter* inserter) { Location loc = this->location(); @@ -8899,7 +8901,7 @@ Builtin_call_expression::lower_make(Statement_inserter* inserter) else { len_arg = *parg; - len_arg->determine_type(&int_context); + len_arg->determine_type(gogo, &int_context); if (len_arg->type()->integer_type() == NULL) { go_error_at(len_arg->location(), "non-integer len argument in make"); @@ -8919,7 +8921,7 @@ Builtin_call_expression::lower_make(Statement_inserter* inserter) if (is_slice && parg != args->end()) { cap_arg = *parg; - cap_arg->determine_type(&int_context); + cap_arg->determine_type(gogo, &int_context); if (cap_arg->type()->integer_type() == NULL) { go_error_at(cap_arg->location(), "non-integer cap argument in make"); @@ -9709,7 +9711,8 @@ Builtin_call_expression::do_numeric_constant_value(Numeric_constant* nc) const // We may be replacing this expression with a constant // during lowering, so verify the type to report any errors. // It's OK to verify an array type more than once. - arg_type->verify(); + // FIXME: Remove this reference to go_get_gogo. + arg_type->verify(go_get_gogo()); if (!arg_type->is_error()) { Expression* e = arg_type->array_type()->length(); @@ -10048,12 +10051,13 @@ Builtin_call_expression::do_type() // Determine the type. void -Builtin_call_expression::do_determine_type(const Type_context* context) +Builtin_call_expression::do_determine_type(Gogo* gogo, + const Type_context* context) { if (!this->determining_types()) return; - this->fn()->determine_type_no_context(); + this->fn()->determine_type_no_context(gogo); const Expression_list* args = this->args(); @@ -10113,16 +10117,16 @@ Builtin_call_expression::do_determine_type(const Type_context* context) if (args != NULL && args->size() == 2) { if (this->code_ == BUILTIN_SLICE) - args->front()->determine_type_no_context(); + args->front()->determine_type_no_context(gogo); else { Type* pointer = Type::make_pointer_type(Type::make_void_type()); Type_context subcontext(pointer, false); - args->front()->determine_type(&subcontext); + args->front()->determine_type(gogo, &subcontext); } Type* int_type = Type::lookup_integer_type("int"); Type_context subcontext(int_type, false); - args->back()->determine_type(&subcontext); + args->back()->determine_type(gogo, &subcontext); return; } is_print = false; @@ -10183,7 +10187,7 @@ Builtin_call_expression::do_determine_type(const Type_context* context) } } - (*pa)->determine_type(&subcontext); + (*pa)->determine_type(gogo, &subcontext); if (trailing_arg_types != NULL) { @@ -12513,12 +12517,12 @@ Call_expression::do_type() // parameter types to set the types of the arguments. void -Call_expression::do_determine_type(const Type_context* context) +Call_expression::do_determine_type(Gogo* gogo, const Type_context* context) { if (!this->determining_types()) return; - this->fn_->determine_type_no_context(); + this->fn_->determine_type_no_context(gogo); Function_type* fntype = this->get_function_type(); const Typed_identifier_list* parameters = NULL; if (fntype != NULL) @@ -12545,7 +12549,7 @@ Call_expression::do_determine_type(const Type_context* context) if (rtype->points_to() == NULL) rtype = Type::make_pointer_type(rtype); Type_context subcontext(rtype, false); - (*pa)->determine_type(&subcontext); + (*pa)->determine_type(gogo, &subcontext); continue; } } @@ -12553,11 +12557,11 @@ Call_expression::do_determine_type(const Type_context* context) if (parameters != NULL && pt != parameters->end()) { Type_context subcontext(pt->type(), false); - (*pa)->determine_type(&subcontext); + (*pa)->determine_type(gogo, &subcontext); ++pt; } else - (*pa)->determine_type_no_context(); + (*pa)->determine_type_no_context(gogo); } } @@ -13110,9 +13114,9 @@ Call_result_expression::do_check_types(Gogo*) // needs to pass down to the caller. void -Call_result_expression::do_determine_type(const Type_context*) +Call_result_expression::do_determine_type(Gogo* gogo, const Type_context*) { - this->call_->determine_type_no_context(); + this->call_->determine_type_no_context(gogo); } // Return the backend representation. We just refer to the temporary set by the @@ -13358,16 +13362,16 @@ Array_index_expression::do_type() // Set the type of an array index. void -Array_index_expression::do_determine_type(const Type_context*) +Array_index_expression::do_determine_type(Gogo* gogo, const Type_context*) { - this->array_->determine_type_no_context(); + this->array_->determine_type_no_context(gogo); Type_context index_context(Type::lookup_integer_type("int"), false); - this->start_->determine_type(&index_context); + this->start_->determine_type(gogo, &index_context); if (this->end_ != NULL) - this->end_->determine_type(&index_context); + this->end_->determine_type(gogo, &index_context); if (this->cap_ != NULL) - this->cap_->determine_type(&index_context); + this->cap_->determine_type(gogo, &index_context); } // Check types of an array index. @@ -14031,14 +14035,14 @@ String_index_expression::do_type() // Determine the type of a string index. void -String_index_expression::do_determine_type(const Type_context*) +String_index_expression::do_determine_type(Gogo* gogo, const Type_context*) { - this->string_->determine_type_no_context(); + this->string_->determine_type_no_context(gogo); Type_context index_context(Type::lookup_integer_type("int"), false); - this->start_->determine_type(&index_context); + this->start_->determine_type(gogo, &index_context); if (this->end_ != NULL) - this->end_->determine_type(&index_context); + this->end_->determine_type(gogo, &index_context); } // Check types of a string index. @@ -14331,13 +14335,13 @@ Map_index_expression::do_type() // Fix the type of a map index. void -Map_index_expression::do_determine_type(const Type_context*) +Map_index_expression::do_determine_type(Gogo* gogo, const Type_context*) { - this->map_->determine_type_no_context(); + this->map_->determine_type_no_context(gogo); Map_type* mt = this->get_map_type(); Type* key_type = mt == NULL ? NULL : mt->key_type(); Type_context subcontext(key_type, false); - this->index_->determine_type(&subcontext); + this->index_->determine_type(gogo, &subcontext); } // Check types of a map index. @@ -14770,9 +14774,10 @@ Interface_field_reference_expression::do_type() // Determine types. void -Interface_field_reference_expression::do_determine_type(const Type_context*) +Interface_field_reference_expression::do_determine_type(Gogo* gogo, + const Type_context*) { - this->expr_->determine_type_no_context(); + this->expr_->determine_type_no_context(gogo); } // Check the types for an interface field reference. @@ -15541,7 +15546,8 @@ Struct_construction_expression::do_is_static_initializer() const // Final type determination. void -Struct_construction_expression::do_determine_type(const Type_context*) +Struct_construction_expression::do_determine_type(Gogo* gogo, + const Type_context*) { if (this->vals() == NULL) return; @@ -15556,13 +15562,13 @@ Struct_construction_expression::do_determine_type(const Type_context*) if (*pv != NULL) { Type_context subcontext(pf->type(), false); - (*pv)->determine_type(&subcontext); + (*pv)->determine_type(gogo, &subcontext); } } // Extra values are an error we will report elsewhere; we still want // to determine the type to avoid knockon errors. for (; pv != this->vals()->end(); ++pv) - (*pv)->determine_type_no_context(); + (*pv)->determine_type_no_context(gogo); } // Check types. @@ -15827,7 +15833,8 @@ Array_construction_expression::do_is_static_initializer() const // Final type determination. void -Array_construction_expression::do_determine_type(const Type_context*) +Array_construction_expression::do_determine_type(Gogo* gogo, + const Type_context*) { if (this->is_error_expression()) { @@ -15850,7 +15857,7 @@ Array_construction_expression::do_determine_type(const Type_context*) ++pv) { if (*pv != NULL) - (*pv)->determine_type(&subcontext); + (*pv)->determine_type(gogo, &subcontext); } } @@ -16378,7 +16385,7 @@ Map_construction_expression::do_flatten(Gogo* gogo, Named_object*, // Final type determination. void -Map_construction_expression::do_determine_type(const Type_context*) +Map_construction_expression::do_determine_type(Gogo* gogo, const Type_context*) { if (this->vals_ == NULL) return; @@ -16390,9 +16397,9 @@ Map_construction_expression::do_determine_type(const Type_context*) pv != this->vals_->end(); ++pv) { - (*pv)->determine_type(&key_context); + (*pv)->determine_type(gogo, &key_context); ++pv; - (*pv)->determine_type(&val_context); + (*pv)->determine_type(gogo, &val_context); } } @@ -17910,7 +17917,7 @@ class Type_descriptor_expression : public Expression { return true; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -17978,7 +17985,7 @@ class GC_symbol_expression : public Expression { return true; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -18037,7 +18044,7 @@ class Ptrmask_symbol_expression : public Expression { return true; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -18124,7 +18131,7 @@ class Type_info_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -18311,11 +18318,11 @@ Slice_value_expression::do_traverse(Traverse* traverse) // Determine type of a slice value. void -Slice_value_expression::do_determine_type(const Type_context*) +Slice_value_expression::do_determine_type(Gogo* gogo, const Type_context*) { - this->valmem_->determine_type_no_context(); - this->len_->determine_type_no_context(); - this->cap_->determine_type_no_context(); + this->valmem_->determine_type_no_context(gogo); + this->len_->determine_type_no_context(gogo); + this->cap_->determine_type_no_context(gogo); } Expression* @@ -18421,7 +18428,7 @@ class Interface_info_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -18591,7 +18598,7 @@ class Interface_value_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { go_unreachable(); } Expression* @@ -18686,7 +18693,7 @@ class Interface_mtable_expression : public Expression { return true; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { go_unreachable(); } Expression* @@ -18932,7 +18939,7 @@ class Struct_field_offset_expression : public Expression { return Type::lookup_integer_type("uintptr"); } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -19017,7 +19024,7 @@ class Label_addr_expression : public Expression { return Type::make_pointer_type(Type::make_void_type()); } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -19080,11 +19087,12 @@ Conditional_expression::do_type() // Determine type for a conditional expression. void -Conditional_expression::do_determine_type(const Type_context* context) +Conditional_expression::do_determine_type(Gogo* gogo, + const Type_context* context) { - this->cond_->determine_type_no_context(); - this->then_->determine_type(context); - this->else_->determine_type(context); + this->cond_->determine_type_no_context(gogo); + this->then_->determine_type(gogo, context); + this->else_->determine_type(gogo, context); } // Get the backend representation of a conditional expression. @@ -19150,10 +19158,10 @@ Compound_expression::do_type() // Determine type for a compound expression. void -Compound_expression::do_determine_type(const Type_context* context) +Compound_expression::do_determine_type(Gogo* gogo, const Type_context* context) { - this->init_->determine_type_no_context(); - this->expr_->determine_type(context); + this->init_->determine_type_no_context(gogo); + this->expr_->determine_type(gogo, context); } // Get the backend representation of a compound expression. diff --git a/gcc/go/gofrontend/expressions.h b/gcc/go/gofrontend/expressions.h index bdb7ccd010d..2abc9cb8425 100644 --- a/gcc/go/gofrontend/expressions.h +++ b/gcc/go/gofrontend/expressions.h @@ -1002,7 +1002,7 @@ class Expression // floating point, or complex type. TYPE_CONTEXT describes the // expected type. void - determine_type(const Type_context*); + determine_type(Gogo*, const Type_context*); // Check types in an expression. void @@ -1011,7 +1011,7 @@ class Expression // Determine the type when there is no context. void - determine_type_no_context(); + determine_type_no_context(Gogo*); // Return the current type of the expression. This may be changed // by determine_type. This should not be called before the lowering @@ -1208,7 +1208,7 @@ class Expression // Child class implements determining type information. virtual void - do_determine_type(const Type_context*) = 0; + do_determine_type(Gogo*, const Type_context*) = 0; // Child class implements type checking if needed. virtual void @@ -1456,7 +1456,7 @@ class Parser_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { go_unreachable(); } void @@ -1522,7 +1522,7 @@ class Const_expression : public Expression // The type of a const is set by the declaration, not the use. void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -1581,7 +1581,7 @@ class Var_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -1649,8 +1649,8 @@ class Enclosed_var_expression : public Expression { return this->reference_->type(); } void - do_determine_type(const Type_context* context) - { return this->reference_->determine_type(context); } + do_determine_type(Gogo* gogo, const Type_context* context) + { return this->reference_->determine_type(gogo, context); } Expression* do_copy() @@ -1707,7 +1707,7 @@ class Temporary_reference_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -1772,7 +1772,7 @@ class Set_and_use_temporary_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -1849,7 +1849,7 @@ class String_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -1954,7 +1954,7 @@ class Type_conversion_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2021,8 +2021,8 @@ class Unsafe_type_conversion_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*) - { this->expr_->determine_type_no_context(); } + do_determine_type(Gogo* gogo, const Type_context*) + { this->expr_->determine_type_no_context(gogo); } Expression* do_copy(); @@ -2149,7 +2149,7 @@ class Unary_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2309,7 +2309,7 @@ class Binary_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2425,7 +2425,7 @@ class String_concat_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2599,7 +2599,7 @@ class Call_expression : public Expression do_type(); virtual void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); virtual void do_check_types(Gogo*); @@ -2777,7 +2777,7 @@ class Builtin_call_expression : public Call_expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2815,7 +2815,7 @@ class Builtin_call_expression : public Call_expression complex_type(Type*); Expression* - lower_make(Statement_inserter*); + lower_make(Gogo*, Statement_inserter*); bool check_int_value(Expression*, bool is_length, bool* small); @@ -2874,7 +2874,7 @@ class Call_result_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -2955,10 +2955,10 @@ class Func_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo* gogo, const Type_context*) { if (this->closure_ != NULL) - this->closure_->determine_type_no_context(); + this->closure_->determine_type_no_context(gogo); } Expression* @@ -3015,7 +3015,7 @@ class Func_descriptor_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* @@ -3207,7 +3207,7 @@ class Array_index_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3312,7 +3312,7 @@ class String_index_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3408,7 +3408,7 @@ class Map_index_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3511,7 +3511,7 @@ class Bound_method_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3601,8 +3601,8 @@ class Field_reference_expression : public Expression do_type(); void - do_determine_type(const Type_context*) - { this->expr_->determine_type_no_context(); } + do_determine_type(Gogo* gogo, const Type_context*) + { this->expr_->determine_type_no_context(gogo); } void do_check_types(Gogo*); @@ -3697,7 +3697,7 @@ class Interface_field_reference_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3759,7 +3759,7 @@ class Allocation_expression : public Expression do_type(); void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } void @@ -3925,7 +3925,7 @@ class Struct_construction_expression : public Expression, { return this->type_; } void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -3992,7 +3992,7 @@ protected: { return this->type_; } void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -4124,7 +4124,7 @@ class Map_construction_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); void do_check_types(Gogo*); @@ -4187,8 +4187,8 @@ class Type_guard_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*) - { this->expr_->determine_type_no_context(); } + do_determine_type(Gogo* gogo, const Type_context*) + { this->expr_->determine_type_no_context(gogo); } void do_check_types(Gogo*); @@ -4238,8 +4238,8 @@ class Heap_expression : public Expression Type* do_type(); void - do_determine_type(const Type_context*) - { this->expr_->determine_type_no_context(); } + do_determine_type(Gogo* gogo, const Type_context*) + { this->expr_->determine_type_no_context(gogo); } Expression* do_copy() @@ -4301,8 +4301,8 @@ class Receive_expression : public Expression do_flatten(Gogo*, Named_object*, Statement_inserter*); void - do_determine_type(const Type_context*) - { this->channel_->determine_type_no_context(); } + do_determine_type(Gogo* gogo, const Type_context*) + { this->channel_->determine_type_no_context(gogo); } void do_check_types(Gogo*); @@ -4364,7 +4364,7 @@ class Slice_value_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy(); @@ -4417,8 +4417,8 @@ class Slice_info_expression : public Expression do_type(); void - do_determine_type(const Type_context*) - { this->slice_->determine_type_no_context(); } + do_determine_type(Gogo* gogo, const Type_context*) + { this->slice_->determine_type_no_context(gogo); } Expression* do_copy() @@ -4475,7 +4475,7 @@ class Conditional_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -4524,7 +4524,7 @@ class Compound_expression : public Expression do_type(); void - do_determine_type(const Type_context*); + do_determine_type(Gogo*, const Type_context*); Expression* do_copy() @@ -4571,7 +4571,7 @@ class Backend_expression : public Expression { return this->type_; } void - do_determine_type(const Type_context*) + do_determine_type(Gogo*, const Type_context*) { } Expression* diff --git a/gcc/go/gofrontend/gogo.cc b/gcc/go/gofrontend/gogo.cc index fa3cd6ebe9f..499459b5366 100644 --- a/gcc/go/gofrontend/gogo.cc +++ b/gcc/go/gofrontend/gogo.cc @@ -2865,12 +2865,16 @@ Gogo::add_type_to_verify(Type* type) class Verify_types : public Traverse { public: - Verify_types() - : Traverse(traverse_types) + Verify_types(Gogo* gogo) + : Traverse(traverse_types), + gogo_(gogo) { } int type(Type*); + + private: + Gogo* gogo_; }; // Verify that a type is correct. @@ -2878,7 +2882,7 @@ class Verify_types : public Traverse int Verify_types::type(Type* t) { - if (!t->verify()) + if (!t->verify(this->gogo_)) return TRAVERSE_SKIP_COMPONENTS; return TRAVERSE_CONTINUE; } @@ -2888,13 +2892,13 @@ Verify_types::type(Type* t) void Gogo::verify_types() { - Verify_types traverse; + Verify_types traverse(this); this->traverse(&traverse); for (std::vector::iterator p = this->verify_types_.begin(); p != this->verify_types_.end(); ++p) - (*p)->verify(); + (*p)->verify(this); this->verify_types_.clear(); } @@ -3224,9 +3228,10 @@ Gogo::add_conversions_in_block(Block *b) class Remove_deadcode : public Traverse { public: - Remove_deadcode() + Remove_deadcode(Gogo* gogo) : Traverse(traverse_statements - | traverse_expressions) + | traverse_expressions), + gogo_(gogo) { } int @@ -3234,6 +3239,9 @@ class Remove_deadcode : public Traverse int expression(Expression**); + + private: + Gogo* gogo_; }; // Remove deadcode in a statement. @@ -3283,7 +3291,7 @@ Remove_deadcode::expression(Expression** pexpr) { *pexpr = Expression::make_boolean(bval, be->location()); Type_context context(NULL, false); - (*pexpr)->determine_type(&context); + (*pexpr)->determine_type(this->gogo_, &context); } return TRAVERSE_CONTINUE; } @@ -3293,7 +3301,7 @@ Remove_deadcode::expression(Expression** pexpr) void Gogo::remove_deadcode() { - Remove_deadcode remove_deadcode; + Remove_deadcode remove_deadcode(this); this->traverse(&remove_deadcode); } @@ -3622,11 +3630,11 @@ Gogo::determine_types() ++p) { if ((*p)->is_function()) - (*p)->func_value()->determine_types(); + (*p)->func_value()->determine_types(this); else if ((*p)->is_variable()) - (*p)->var_value()->determine_type(); + (*p)->var_value()->determine_type(this); else if ((*p)->is_const()) - (*p)->const_value()->determine_type(); + (*p)->const_value()->determine_type(this); // See if a variable requires us to build an initialization // function. We know that we will see all global variables @@ -3662,7 +3670,7 @@ Gogo::determine_types() for (Packages::const_iterator p = this->packages_.begin(); p != this->packages_.end(); ++p) - p->second->determine_types(); + p->second->determine_types(this); } // Traversal class used for type checking. @@ -4809,7 +4817,7 @@ Build_recover_thunks::function(Named_object* orig_no) call->set_varargs_are_lowered(); Statement* s = Statement::make_return_from_call(call, location); - s->determine_types(); + s->determine_types(this->gogo_); gogo->add_statement(s); Block* b = gogo->finish_block(location); @@ -5882,10 +5890,10 @@ Function::traverse(Traverse* traverse) // Work out types for unspecified variables and constants. void -Function::determine_types() +Function::determine_types(Gogo* gogo) { if (this->block_ != NULL) - this->block_->determine_types(); + this->block_->determine_types(gogo); } // Return the function descriptor, the value you get when you refer to @@ -6961,7 +6969,7 @@ Block::traverse(Traverse* traverse) // Work out types for unspecified variables and constants. void -Block::determine_types() +Block::determine_types(Gogo* gogo) { for (Bindings::const_definitions_iterator pb = this->bindings_->begin_definitions(); @@ -6969,15 +6977,15 @@ Block::determine_types() ++pb) { if ((*pb)->is_variable()) - (*pb)->var_value()->determine_type(); + (*pb)->var_value()->determine_type(gogo); else if ((*pb)->is_const()) - (*pb)->const_value()->determine_type(); + (*pb)->const_value()->determine_type(gogo); } for (std::vector::const_iterator ps = this->statements_.begin(); ps != this->statements_.end(); ++ps) - (*ps)->determine_types(); + (*ps)->determine_types(gogo); } // Return true if the statements in this block may fall through. @@ -7456,7 +7464,7 @@ Function_declaration::import_function_body(Gogo* gogo, Named_object* no) return; gogo->lower_block(no, outer); - outer->determine_types(); + outer->determine_types(gogo); gogo->add_imported_inline_function(no); } @@ -7826,14 +7834,14 @@ Variable::type() const // Set the type if necessary. void -Variable::determine_type() +Variable::determine_type(Gogo* gogo) { if (this->determined_type_) return; this->determined_type_ = true; if (this->preinit_ != NULL) - this->preinit_->determine_types(); + this->preinit_->determine_types(gogo); // A variable in a type switch with a nil case will have the wrong // type here. It will have an initializer which is a type guard. @@ -7854,14 +7862,14 @@ Variable::determine_type() else if (this->type_from_init_tuple_) { Expression *init = this->init_; - init->determine_type_no_context(); + init->determine_type_no_context(gogo); this->type_ = this->type_from_tuple(init, true); this->init_ = NULL; } else if (this->type_from_range_index_ || this->type_from_range_value_) { Expression* init = this->init_; - init->determine_type_no_context(); + init->determine_type_no_context(gogo); this->type_ = this->type_from_range(init, this->type_from_range_index_, true); this->init_ = NULL; @@ -7869,14 +7877,14 @@ Variable::determine_type() else if (this->type_from_chan_element_) { Expression* init = this->init_; - init->determine_type_no_context(); + init->determine_type_no_context(gogo); this->type_ = this->type_from_chan_element(init, true); this->init_ = NULL; } else { Type_context context(this->type_, false); - this->init_->determine_type(&context); + this->init_->determine_type(gogo, &context); if (this->type_ == NULL) { Type* type = this->init_->type(); @@ -8204,18 +8212,18 @@ Named_constant::traverse_expression(Traverse* traverse) // Determine the type of the constant. void -Named_constant::determine_type() +Named_constant::determine_type(Gogo* gogo) { if (this->type_ != NULL) { Type_context context(this->type_, false); - this->expr_->determine_type(&context); + this->expr_->determine_type(gogo, &context); } else { // A constant may have an abstract type. Type_context context(NULL, true); - this->expr_->determine_type(&context); + this->expr_->determine_type(gogo, &context); this->type_ = this->expr_->type(); go_assert(this->type_ != NULL); } @@ -9566,7 +9574,7 @@ Package::add_alias(const std::string& alias, Location location) // type. Constants may have abstract types. void -Package::determine_types() +Package::determine_types(Gogo* gogo) { Bindings* bindings = this->bindings_; for (Bindings::const_definitions_iterator p = bindings->begin_definitions(); @@ -9574,7 +9582,7 @@ Package::determine_types() ++p) { if ((*p)->is_const()) - (*p)->const_value()->determine_type(); + (*p)->const_value()->determine_type(gogo); } } diff --git a/gcc/go/gofrontend/gogo.h b/gcc/go/gofrontend/gogo.h index 4fd45bfa040..f254a615dbb 100644 --- a/gcc/go/gofrontend/gogo.h +++ b/gcc/go/gofrontend/gogo.h @@ -1429,7 +1429,7 @@ class Block // Set final types for unspecified variables and constants. void - determine_types(); + determine_types(Gogo*); // Return true if execution of this block may fall through to the // next block. @@ -1760,7 +1760,7 @@ class Function // Determine types in the function. void - determine_types(); + determine_types(Gogo*); // Return an expression for the function descriptor, given the named // object for this function. This may only be called for functions @@ -2365,7 +2365,7 @@ class Variable // Determine the type of the variable if necessary. void - determine_type(); + determine_type(Gogo*); // Get the backend representation of the variable. Bvariable* @@ -2620,7 +2620,7 @@ class Named_constant // Determine the type of the constant if necessary. void - determine_type(); + determine_type(Gogo*); // Indicate that we found and reported an error for this constant. void @@ -3687,7 +3687,7 @@ class Package // Determine types of constants. void - determine_types(); + determine_types(Gogo*); private: // The package path for type reflection data. diff --git a/gcc/go/gofrontend/runtime.cc b/gcc/go/gofrontend/runtime.cc index 3cc5ded3617..e113a1adfc9 100644 --- a/gcc/go/gofrontend/runtime.cc +++ b/gcc/go/gofrontend/runtime.cc @@ -317,7 +317,7 @@ Runtime::convert_types(Gogo* gogo) Type* t = runtime_function_types[i]; if (t != NULL && t->named_type() != NULL) { - bool r = t->verify(); + bool r = t->verify(gogo); go_assert(r); t->named_type()->convert(gogo); } diff --git a/gcc/go/gofrontend/statements.cc b/gcc/go/gofrontend/statements.cc index af8c7d15998..33b568e3eeb 100644 --- a/gcc/go/gofrontend/statements.cc +++ b/gcc/go/gofrontend/statements.cc @@ -117,9 +117,9 @@ Statement::traverse_type(Traverse* traverse, Type* type) // the child class. void -Statement::determine_types() +Statement::determine_types(Gogo* gogo) { - this->do_determine_types(); + this->do_determine_types(gogo); } // Read a statement from export data. @@ -524,7 +524,7 @@ Temporary_statement::do_traverse_assignments(Traverse_assignments* tassign) // Determine types. void -Temporary_statement::do_determine_types() +Temporary_statement::do_determine_types(Gogo* gogo) { if (this->type_ != NULL && this->type_->is_abstract()) this->type_ = this->type_->make_non_abstract_type(); @@ -532,11 +532,11 @@ Temporary_statement::do_determine_types() if (this->init_ != NULL) { if (this->type_ == NULL) - this->init_->determine_type_no_context(); + this->init_->determine_type_no_context(gogo); else { Type_context context(this->type_, false); - this->init_->determine_type(&context); + this->init_->determine_type(gogo, &context); } } @@ -1046,14 +1046,14 @@ Assignment_statement::do_lower(Gogo* gogo, Named_object*, Block* enclosing, // Set types for the assignment. void -Assignment_statement::do_determine_types() +Assignment_statement::do_determine_types(Gogo* gogo) { - this->lhs_->determine_type_no_context(); + this->lhs_->determine_type_no_context(gogo); Type* rhs_context_type = this->lhs_->type(); if (rhs_context_type->is_sink_type()) rhs_context_type = NULL; Type_context context(rhs_context_type, false); - this->rhs_->determine_type(&context); + this->rhs_->determine_type(gogo, &context); } // Check types for an assignment. @@ -2080,9 +2080,9 @@ Expression_statement::Expression_statement(Expression* expr, bool is_ignored) // Determine types. void -Expression_statement::do_determine_types() +Expression_statement::do_determine_types(Gogo* gogo) { - this->expr_->determine_type_no_context(); + this->expr_->determine_type_no_context(gogo); } // Check the types of an expression statement. The only check we do @@ -2427,9 +2427,9 @@ Thunk_statement::do_traverse_assignments(Traverse_assignments* tassign) // Determine types in a thunk statement. void -Thunk_statement::do_determine_types() +Thunk_statement::do_determine_types(Gogo* gogo) { - this->call_->determine_type_no_context(); + this->call_->determine_type_no_context(gogo); } // Check types in a thunk statement. @@ -2679,7 +2679,7 @@ Thunk_statement::simplify_statement(Gogo* gogo, Named_object* function, // We already ran the determine_types pass, so we need to run it now // for the new statement. - s->determine_types(); + s->determine_types(gogo); // Sanity check. gogo->check_types_in_block(block); @@ -2833,11 +2833,11 @@ Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name, gogo->add_statement(Statement::make_goto_statement(retaddr_label, location)); Block* then_block = gogo->finish_block(location); - then_block->determine_types(); + then_block->determine_types(gogo); Statement* s = Statement::make_if_statement(call, then_block, NULL, location); - s->determine_types(); + s->determine_types(gogo); gogo->add_statement(s); function->func_value()->set_calls_defer_retaddr(); @@ -2977,7 +2977,7 @@ Thunk_statement::build_thunk(Gogo* gogo, const std::string& thunk_name, // We already ran the determine_types pass, so we need to run it // just for the call statement now. The other types are known. - call_statement->determine_types(); + call_statement->determine_types(gogo); gogo->add_conversions_in_block(b); @@ -3173,8 +3173,8 @@ Return_statement::do_traverse_assignments(Traverse_assignments* tassign) // return. This lets panic/recover work correctly. Statement* -Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing, - Statement_inserter*) +Return_statement::do_lower(Gogo* gogo, Named_object* function, + Block* enclosing, Statement_inserter*) { if (this->is_lowered_) return this; @@ -3253,7 +3253,7 @@ Return_statement::do_lower(Gogo*, Named_object* function, Block* enclosing, Type *rvtype = rv->result_var_value()->type(); Type_context type_context(rvtype, false); - e->determine_type(&type_context); + e->determine_type(gogo, &type_context); std::string reason; if (Type::are_assignable(rvtype, e->type(), &reason)) @@ -3764,13 +3764,13 @@ If_statement::do_traverse(Traverse* traverse) } void -If_statement::do_determine_types() +If_statement::do_determine_types(Gogo* gogo) { Type_context context(Type::lookup_bool_type(), false); - this->cond_->determine_type(&context); - this->then_block_->determine_types(); + this->cond_->determine_type(gogo, &context); + this->then_block_->determine_types(gogo); if (this->else_block_ != NULL) - this->else_block_->determine_types(); + this->else_block_->determine_types(gogo); } // Check types. @@ -4082,7 +4082,7 @@ Case_clauses::Case_clause::lower(Block* b, Temporary_statement* val_temp, // Determine types. void -Case_clauses::Case_clause::determine_types(Type* type) +Case_clauses::Case_clause::determine_types(Gogo* gogo, Type* type) { if (this->cases_ != NULL) { @@ -4090,10 +4090,10 @@ Case_clauses::Case_clause::determine_types(Type* type) for (Expression_list::iterator p = this->cases_->begin(); p != this->cases_->end(); ++p) - (*p)->determine_type(&case_context); + (*p)->determine_type(gogo, &case_context); } if (this->statements_ != NULL) - this->statements_->determine_types(); + this->statements_->determine_types(gogo); } // Check types. Returns false if there was an error. @@ -4319,12 +4319,12 @@ Case_clauses::lower(Block* b, Temporary_statement* val_temp, // Determine types. void -Case_clauses::determine_types(Type* type) +Case_clauses::determine_types(Gogo* gogo, Type* type) { for (Clauses::iterator p = this->clauses_.begin(); p != this->clauses_.end(); ++p) - p->determine_types(type); + p->determine_types(gogo, type); } // Check types. Returns false if there was an error. @@ -4425,7 +4425,7 @@ class Constant_switch_statement : public Statement do_traverse(Traverse*); void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -4458,10 +4458,10 @@ Constant_switch_statement::do_traverse(Traverse* traverse) // Determine types. void -Constant_switch_statement::do_determine_types() +Constant_switch_statement::do_determine_types(Gogo* gogo) { - this->val_->determine_type_no_context(); - this->clauses_->determine_types(this->val_->type()); + this->val_->determine_type_no_context(gogo); + this->clauses_->determine_types(gogo, this->val_->type()); } // Check types. @@ -5083,14 +5083,14 @@ Send_statement::do_traverse(Traverse* traverse) // Determine types. void -Send_statement::do_determine_types() +Send_statement::do_determine_types(Gogo* gogo) { - this->channel_->determine_type_no_context(); + this->channel_->determine_type_no_context(gogo); Type* type = this->channel_->type(); Type_context context; if (type->channel_type() != NULL) context.type = type->channel_type()->element_type(); - this->val_->determine_type(&context); + this->val_->determine_type(gogo, &context); } // Check types. @@ -5492,11 +5492,11 @@ Select_clauses::Select_clause::set_case(Block* b, // Determine types. void -Select_clauses::Select_clause::determine_types() +Select_clauses::Select_clause::determine_types(Gogo* gogo) { go_assert(this->is_lowered_); if (this->statements_ != NULL) - this->statements_->determine_types(); + this->statements_->determine_types(gogo); } // Check types. @@ -5676,12 +5676,12 @@ Select_clauses::lower(Gogo* gogo, Named_object* function, Block* b, // Determine types. void -Select_clauses::determine_types() +Select_clauses::determine_types(Gogo* gogo) { for (Clauses::iterator p = this->clauses_.begin(); p != this->clauses_.end(); ++p) - p->determine_types(); + p->determine_types(gogo); } // Check types. diff --git a/gcc/go/gofrontend/statements.h b/gcc/go/gofrontend/statements.h index 3d1ee33a3e5..eb795c4b920 100644 --- a/gcc/go/gofrontend/statements.h +++ b/gcc/go/gofrontend/statements.h @@ -321,7 +321,7 @@ class Statement // Set type information for unnamed constants. void - determine_types(); + determine_types(Gogo*); // Check types in a statement. This simply checks that any // expressions used by the statement have the right type. @@ -508,7 +508,7 @@ class Statement // constants. Any statement which includes an expression needs to // implement this. virtual void - do_determine_types() + do_determine_types(Gogo*) { } // Implemented by child class: check types of expressions used in a @@ -640,7 +640,7 @@ class Assignment_statement : public Statement do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -757,7 +757,7 @@ class Temporary_statement : public Statement do_traverse_assignments(Traverse_assignments*); void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -916,7 +916,7 @@ class Expression_statement : public Statement { return this->traverse_expression(traverse, &this->expr_); } void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -983,8 +983,8 @@ class Block_statement : public Statement { return this->block_->traverse(traverse); } void - do_determine_types() - { this->block_->determine_types(); } + do_determine_types(Gogo* gogo) + { this->block_->determine_types(gogo); } int do_inlining_cost() @@ -1033,7 +1033,7 @@ class Send_statement : public Statement do_traverse(Traverse* traverse); void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -1106,7 +1106,7 @@ class Select_clauses // Determine types. void - determine_types(); + determine_types(Gogo*); // Check types. void @@ -1157,7 +1157,7 @@ class Select_clauses // Determine types. void - determine_types(); + determine_types(Gogo*); // Check types. void @@ -1326,8 +1326,8 @@ class Select_statement : public Statement do_lower(Gogo*, Named_object*, Block*, Statement_inserter*); void - do_determine_types() - { this->clauses_->determine_types(); } + do_determine_types(Gogo* gogo) + { this->clauses_->determine_types(gogo); } void do_check_types(Gogo*) @@ -1387,7 +1387,7 @@ class Thunk_statement : public Statement do_traverse_assignments(Traverse_assignments*); void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -1655,7 +1655,7 @@ class If_statement : public Statement do_traverse(Traverse*); void - do_determine_types(); + do_determine_types(Gogo*); void do_check_types(Gogo*); @@ -1894,7 +1894,7 @@ class Case_clauses // Determine types of expressions. The Type parameter is the type // of the switch value. void - determine_types(Type*); + determine_types(Gogo*, Type*); // Check types. The Type parameter is the type of the switch value. bool @@ -1968,7 +1968,7 @@ class Case_clauses // Determine types. void - determine_types(Type*); + determine_types(Gogo*, Type*); // Check types. bool diff --git a/gcc/go/gofrontend/types.cc b/gcc/go/gofrontend/types.cc index 7f471eab428..e6b1250ba38 100644 --- a/gcc/go/gofrontend/types.cc +++ b/gcc/go/gofrontend/types.cc @@ -1555,7 +1555,7 @@ Type::convert_builtin_named_types(Gogo* gogo) p != Type::named_builtin_types.end(); ++p) { - bool r = (*p)->verify(); + bool r = (*p)->verify(gogo); go_assert(r); (*p)->convert(gogo); } @@ -5950,7 +5950,7 @@ Struct_type::do_traverse(Traverse* traverse) // Verify that the struct type is complete and valid. bool -Struct_type::do_verify() +Struct_type::do_verify(Gogo*) { Struct_field_list* fields = this->fields_; if (fields == NULL) @@ -7337,13 +7337,13 @@ Array_type::do_traverse(Traverse* traverse) // Check that the length is valid. bool -Array_type::verify_length() +Array_type::verify_length(Gogo* gogo) { if (this->length_ == NULL) return true; Type_context context(Type::lookup_integer_type("int"), false); - this->length_->determine_type(&context); + this->length_->determine_type(gogo, &context); if (this->length_->is_error_expression() || this->length_->type()->is_error()) @@ -7421,14 +7421,14 @@ Array_type::verify_length() // Verify the type. bool -Array_type::do_verify() +Array_type::do_verify(Gogo* gogo) { if (this->element_type()->is_error_type()) { this->set_is_error(); return false; } - if (!this->verify_length()) + if (!this->verify_length(gogo)) { this->length_ = Expression::make_error(this->length_->location()); this->set_is_error(); @@ -8225,7 +8225,7 @@ Map_type::do_traverse(Traverse* traverse) // Check that the map type is OK. bool -Map_type::do_verify() +Map_type::do_verify(Gogo*) { // The runtime support uses "map[void]void". if (!this->key_type_->is_comparable() && !this->key_type_->is_void_type()) @@ -8768,7 +8768,7 @@ Type::make_map_type(Type* key_type, Type* val_type, Location location) // Verify. bool -Channel_type::do_verify() +Channel_type::do_verify(Gogo*) { // We have no location for this error, but this is not something the // ordinary user will see. @@ -10833,7 +10833,7 @@ Find_alias::type(Type* type) // Verify that a named type does not refer to itself. bool -Named_type::do_verify() +Named_type::do_verify(Gogo*) { if (this->is_verified_) return true; @@ -11016,7 +11016,7 @@ Named_type::convert(Gogo* gogo) // If we are called to turn unsafe.Sizeof into a constant, we may // not have verified the type yet. We have to make sure it is // verified, since that sets the list of dependencies. - this->verify(); + this->verify(gogo); // Convert all the dependencies. If they refer indirectly back to // this type, they will pick up the intermediate representation we just @@ -12791,7 +12791,7 @@ Forward_declaration_type::do_traverse(Traverse* traverse) // Verify the type. bool -Forward_declaration_type::do_verify() +Forward_declaration_type::do_verify(Gogo*) { if (!this->is_defined() && !this->is_nil_constant_as_type()) { diff --git a/gcc/go/gofrontend/types.h b/gcc/go/gofrontend/types.h index 057fa014cee..15f29f76b8c 100644 --- a/gcc/go/gofrontend/types.h +++ b/gcc/go/gofrontend/types.h @@ -584,8 +584,8 @@ class Type // returns false if the type is invalid and we should not continue // traversing it. bool - verify() - { return this->do_verify(); } + verify(Gogo* gogo) + { return this->do_verify(gogo); } // Bit flags to pass to are_identical and friends. @@ -1101,7 +1101,7 @@ class Type // Verify the type. virtual bool - do_verify() + do_verify(Gogo*) { return true; } virtual bool @@ -2297,8 +2297,8 @@ class Pointer_type : public Type do_traverse(Traverse*); bool - do_verify() - { return this->to_type_->verify(); } + do_verify(Gogo* gogo) + { return this->to_type_->verify(gogo); } // If this is a pointer to a type that can't be in the heap, then // the garbage collector does not have to look at this, so pretend @@ -2675,7 +2675,7 @@ class Struct_type : public Type do_traverse(Traverse*); bool - do_verify(); + do_verify(Gogo*); bool do_has_pointer() const; @@ -2855,7 +2855,7 @@ class Array_type : public Type do_traverse(Traverse* traverse); bool - do_verify(); + do_verify(Gogo*); bool do_has_pointer() const; @@ -2901,7 +2901,7 @@ class Array_type : public Type private: bool - verify_length(); + verify_length(Gogo*); Expression* array_type_descriptor(Gogo*, Named_type*); @@ -3003,7 +3003,7 @@ class Map_type : public Type do_traverse(Traverse*); bool - do_verify(); + do_verify(Gogo*); bool do_has_pointer() const @@ -3123,7 +3123,7 @@ class Channel_type : public Type { return Type::traverse(this->element_type_, traverse); } bool - do_verify(); + do_verify(Gogo*); bool do_has_pointer() const @@ -3604,7 +3604,7 @@ class Named_type : public Type { return Type::traverse(this->type_, traverse); } bool - do_verify(); + do_verify(Gogo*); bool do_has_pointer() const; @@ -3762,7 +3762,7 @@ class Forward_declaration_type : public Type do_traverse(Traverse* traverse); bool - do_verify(); + do_verify(Gogo*); bool do_has_pointer() const