From patchwork Sun Jun 20 23:36:20 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "H.J. Lu" X-Patchwork-Id: 43925 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 6AE0A385F030 for ; Sun, 20 Jun 2021 23:39:00 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6AE0A385F030 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=sourceware.org; s=default; t=1624232340; bh=6ZaV2U7XmUOfai7iGWwTK77y2IfvIJ7GYVHteAZzu70=; h=To:Subject:Date:In-Reply-To:References:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To: From; b=a4UXNzxrVDyc+ECmyEMxEhK8LM8QiRsEB9TbsQoSJTS43P8Fd9wY1QJD9NA8u1929 dOlrDwMQVM/1hdsFc7mPKXaTvFTmfrHPgo6Dg9/4ndHhxO2rzGcJ4m0kOMW3BOuGDr 0p3pXFoj0H+dPDkkWupGocZcgaVuSo3Owq0MKpSk= X-Original-To: libc-alpha@sourceware.org Delivered-To: libc-alpha@sourceware.org Received: from mail-pg1-x531.google.com (mail-pg1-x531.google.com [IPv6:2607:f8b0:4864:20::531]) by sourceware.org (Postfix) with ESMTPS id D6832385E00D for ; Sun, 20 Jun 2021 23:36:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org D6832385E00D Received: by mail-pg1-x531.google.com with SMTP id u190so8831682pgd.8 for ; Sun, 20 Jun 2021 16:36:24 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=6ZaV2U7XmUOfai7iGWwTK77y2IfvIJ7GYVHteAZzu70=; b=ULJsUwsYG8xUJp2QQk4zVqrZaABCQPSTem5s+9lPXK6SM4wX3EaAvOTRBEqtxss1ci AKOh1oOL3CJ8va4LPbAa/mEBFLLrVSTpdf2r+xCuc19yCuSFDbLUQ+L48HX3w4Ni0AP6 NEXJTsUYN8XKx3J1HdGRjaThyjeBQ663mQWPqPIiC3YE5y7mWBREt3idnkSbLQWdO1g8 IiX2Vz4kKc15HRLnznkfXwqDn1cdgvdT990bNi5YPpJLns3wRBGetBBjL5TEf5YmO8+b TQCqEUCFV7GYs5wAPq5fZ71lnGOgpJVCwRZ1gFVOrFaP54N5gCUIuco2MltzG9Q+Q8Ge Wr4Q== X-Gm-Message-State: AOAM5301EWeCzNhkdUoi//ECt6u0mipPeFL6RzkzMtNqVwyLr4HAGpdm m2xhE0yysCM5yVcthzUra996+rtgJ2I= X-Google-Smtp-Source: ABdhPJzrnKr8rd3mQ4HLz4kKFE7re+3vTSNpyea27H4zroWK+8mS9MKAbnqafYgqzfvJOGdNiJiZuw== X-Received: by 2002:a62:b415:0:b029:2f4:829f:e483 with SMTP id h21-20020a62b4150000b02902f4829fe483mr16925499pfn.4.1624232183727; Sun, 20 Jun 2021 16:36:23 -0700 (PDT) Received: from gnu-cfl-2.localdomain ([172.56.39.115]) by smtp.gmail.com with ESMTPSA id s13sm15132987pgi.36.2021.06.20.16.36.21 for (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 20 Jun 2021 16:36:22 -0700 (PDT) Received: from gnu-cfl-2.. (localhost [IPv6:::1]) by gnu-cfl-2.localdomain (Postfix) with ESMTP id 56E42C05CB for ; Sun, 20 Jun 2021 16:36:20 -0700 (PDT) To: libc-alpha@sourceware.org Subject: [PATCH 4/4] Update tests for protected data and function symbols Date: Sun, 20 Jun 2021 16:36:20 -0700 Message-Id: <20210620233620.391576-5-hjl.tools@gmail.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210620233620.391576-1-hjl.tools@gmail.com> References: <20210620233620.391576-1-hjl.tools@gmail.com> MIME-Version: 1.0 X-Spam-Status: No, score=-3032.8 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_SHORT, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-alpha@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-alpha mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: "H.J. Lu via Libc-alpha" From: "H.J. Lu" Reply-To: "H.J. Lu" Errors-To: libc-alpha-bounces+patchwork=sourceware.org@sourceware.org Sender: "Libc-alpha" Protected data and function symbols don't work well without -fsingle-global-definition: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=37611 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=44166 1. Compile tst-protected1[ab].c and tst-protected1mod[ab].c with -fsingle-global-definition if possible so that GOT entries are used for undefined data accesses. 2. Add tests for protected function pointers. 3. Build tst-prelink.c without single global definition to keepp COPY relocation. --- elf/Makefile | 54 ++++++++++++++++ elf/tst-protected1moda.c | 10 +-- elf/tst-protected1modb.c | 4 +- elf/tst-protected2a.c | 130 ++++++++++++++++++++++++++++++++++++++ elf/tst-protected2apie.c | 1 + elf/tst-protected2b.c | 121 +++++++++++++++++++++++++++++++++++ elf/tst-protected2bpie.c | 1 + elf/tst-protected2mod.h | 35 ++++++++++ elf/tst-protected2moda.c | 52 +++++++++++++++ elf/tst-protected2moda2.c | 41 ++++++++++++ elf/tst-protected2modb.c | 45 +++++++++++++ elf/tst-protected2modb2.c | 28 ++++++++ 12 files changed, 512 insertions(+), 10 deletions(-) create mode 100644 elf/tst-protected2a.c create mode 100644 elf/tst-protected2apie.c create mode 100644 elf/tst-protected2b.c create mode 100644 elf/tst-protected2bpie.c create mode 100644 elf/tst-protected2mod.h create mode 100644 elf/tst-protected2moda.c create mode 100644 elf/tst-protected2moda2.c create mode 100644 elf/tst-protected2modb.c create mode 100644 elf/tst-protected2modb2.c diff --git a/elf/Makefile b/elf/Makefile index 38d08e03b8..abbb9a46b4 100644 --- a/elf/Makefile +++ b/elf/Makefile @@ -367,15 +367,59 @@ tests += tst-protected1a tst-protected1b $(objpfx)tst-protected1a: $(addprefix $(objpfx),tst-protected1moda.so tst-protected1modb.so) $(objpfx)tst-protected1b: $(addprefix $(objpfx),tst-protected1modb.so tst-protected1moda.so) tst-protected1modb.so-no-z-defs = yes +ifeq (yes,$(have-fsingle-global-definition)) +CFLAGS-tst-protected1a.c += -fsingle-global-definition +CFLAGS-tst-protected1b.c += -fsingle-global-definition +CFLAGS-tst-protected1moda.c += -fsingle-global-definition +CFLAGS-tst-protected1modb.c += -fsingle-global-definition +else # These tests fail with GCC versions prior to 5.1 and with some versions # of binutils. See https://sourceware.org/bugzilla/show_bug.cgi?id=17709 # and https://gcc.gnu.org/bugzilla/show_bug.cgi?id=65248 for details. # Perhaps in future we can make these XFAILs conditional on some detection # of compiler/linker behavior/version. +# NB: These tests pass with -fsingle-global-definition when GOT entries +# are used for undefined data accesses. test-xfail-tst-protected1a = yes test-xfail-tst-protected1b = yes endif +ifeq (yes,$(have-z-single-global-definition)) +LDFLAGS-tst-protected1moda.so += -Wl,-z,single-global-definition +LDFLAGS-tst-protected1modb.so += -Wl,-z,single-global-definition +endif +endif ifeq (yesyes,$(have-fpie)$(build-shared)) +ifeq (yes,$(have-z-single-global-definition)) +modules-names += tst-protected2moda tst-protected2modb +tests += tst-protected2a tst-protected2b +tests += tst-protected2apie tst-protected2bpie +tests-pie += tst-protected2apie tst-protected2bpie +test-extras += tst-protected2moda2 tst-protected2modb2 +extra-test-objs += tst-protected2moda2.os tst-protected2modb2.os +LDFLAGS-tst-protected2moda.so += -Wl,-z,single-global-definition +LDFLAGS-tst-protected2modb.so += -Wl,-z,single-global-definition +CFLAGS-tst-protected2apie.c += $(PIE-ccflag) +CFLAGS-tst-protected2bpie.c += $(PIE-ccflag) +ifeq (yes,$(have-fsingle-global-definition)) +CFLAGS-tst-protected2a.c += -fsingle-global-definition +CFLAGS-tst-protected2b.c += -fsingle-global-definition +CFLAGS-tst-protected2moda.c += -fsingle-global-definition +CFLAGS-tst-protected2moda2.c += -fsingle-global-definition +CFLAGS-tst-protected2modb.c += -fsingle-global-definition +CFLAGS-tst-protected2modb2.c += -fsingle-global-definition +else +# These non-PIE tests fail when GOT entries are not used for undefined +# function pointers. +test-xfail-tst-protected2a = yes +test-xfail-tst-protected2b = yes +endif +$(objpfx)tst-protected2moda.so: $(objpfx)tst-protected2moda2.os +$(objpfx)tst-protected2modb.so: $(objpfx)tst-protected2modb2.os +$(objpfx)tst-protected2a: $(addprefix $(objpfx),tst-protected2moda.so tst-protected2modb.so) +$(objpfx)tst-protected2b: $(addprefix $(objpfx),tst-protected2modb.so tst-protected2moda.so) +$(objpfx)tst-protected2apie: $(addprefix $(objpfx),tst-protected2moda.so tst-protected2modb.so) +$(objpfx)tst-protected2bpie: $(addprefix $(objpfx),tst-protected2modb.so tst-protected2moda.so) +endif modules-names += tst-piemod1 tests += tst-pie1 tst-pie2 tst-dlopen-pie tst-dlopen-tlsmodid-pie \ tst-dlopen-self-pie @@ -469,6 +513,16 @@ tests += tst-prelink tests-internal += tst-prelink-cmp # Don't compile tst-prelink.c with PIE for GLOB_DAT relocation. CFLAGS-tst-prelink.c += -fno-pie +ifeq ($(have-fsingle-global-definition),yes) +# Compile tst-prelink.c with -fno-single-global-definition to keepp COPY +# relocation. +CFLAGS-tst-prelink.c += -fno-single-global-definition +endif +ifeq ($(have-z-single-global-definition),yes) +# Link tst-prelink with -z nosingle-global-definition to keepp COPY +# relocation. +LDFLAGS-tst-prelink += -Wl,-z,nosingle-global-definition +endif tst-prelink-no-pie = yes endif diff --git a/elf/tst-protected1moda.c b/elf/tst-protected1moda.c index eeb18306bb..3d0eb1e877 100644 --- a/elf/tst-protected1moda.c +++ b/elf/tst-protected1moda.c @@ -17,17 +17,13 @@ #include "tst-protected1mod.h" -int protected1 = 3; +int protected1 __attribute__ ((visibility("protected"))) = 3; static int expected_protected1 = 3; -int protected2 = 4; +int protected2 __attribute__ ((visibility("protected"))) = 4; static int expected_protected2 = 4; -int protected3 = 5; +int protected3 __attribute__ ((visibility("protected"))) = 5; static int expected_protected3 = 5; -asm (".protected protected1"); -asm (".protected protected2"); -asm (".protected protected3"); - void set_protected1a (int i) { diff --git a/elf/tst-protected1modb.c b/elf/tst-protected1modb.c index 2cb1e61b17..ca82c64689 100644 --- a/elf/tst-protected1modb.c +++ b/elf/tst-protected1modb.c @@ -19,11 +19,9 @@ #include "tst-protected1mod.h" int protected1 = -3; -int protected3 = -5; +int protected3 __attribute__ ((visibility("protected"))) = -5; static int expected_protected3 = -5; -asm (".protected protected3"); - void set_protected1b (int i) { diff --git a/elf/tst-protected2a.c b/elf/tst-protected2a.c new file mode 100644 index 0000000000..21b666e12b --- /dev/null +++ b/elf/tst-protected2a.c @@ -0,0 +1,130 @@ +/* Test the protected visibility when main is linked with moda and modb + in that order: + 1. Protected function symbols, protected1, protected2 and protected3, + defined in moda, are used in moda. + 2. Protected function symbol, protected3, defined in modb, are used + in modb. + 3. Symbol, protected1, defined in moda, is also used in main and modb. + 4. Symbol, protected2, defined in main, is used in main. + 5. Symbol, protected3, defined in moda, is also used in main. + + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include +#include + +#include "tst-protected2mod.h" + +int +protected2 (void) +{ + return -1; +} + +int +__attribute__ ((weak, noclone, noinline)) +call_ptr (protected_func_type ptr) +{ + return ptr (); +} + +int +do_test (void) +{ + int res = 0; + + /* Check if we get the same address for the protected function symbol. */ + protected_func_type ptr = protected1a_p (); + if (&protected1 != ptr) + { + puts ("`protected1' in main and moda doesn't have the same address"); + res = 1; + } + ptr = protected1b_p (); + if (&protected1 != ptr) + { + puts ("`protected1' in main and modb doesn't have the same address"); + res = 1; + } + + /* Check if we get the right protected function symbol. */ + if (call_ptr (ptr) != 3) + { + puts ("`protected1' in main and moda doesn't return the same value"); + res = 1; + } + + /* Check if we get the right function defined in executable. */ + if (protected2 () != -1) + { + puts ("`protected2' in main returns the wrong value"); + res = 1; + } + + /* Check `protected1' in moda. */ + if (!check_protected1 ()) + { + puts ("`protected1' in moda returns the wrong value"); + res = 1; + } + + /* Check `protected2' in moda. */ + if (!check_protected2 ()) + { + puts ("`protected2' in moda returns the wrong value"); + res = 1; + } + + /* Check if we get the same address for the protected function symbol. */ + if (&protected3 != protected3a_p ()) + { + puts ("`protected3' in main and moda doesn't have the same address"); + res = 1; + } + if (&protected3 == protected3b_p ()) + { + puts ("`protected3' in main and modb has the same address"); + res = 1; + } + + /* Check if we get the right value for the protected data symbol. */ + if (protected3 () != 5) + { + puts ("`protected3' in main and moda doesn't return the same value"); + res = 1; + } + + /* Check `protected3' in moda. */ + if (!check_protected3a ()) + { + puts ("`protected3' in moda has the wrong value"); + res = 1; + } + + /* Check `protected3' in modb. */ + if (!check_protected3b ()) + { + puts ("`protected3' in modb has the wrong value"); + res = 1; + } + + return res; +} + +#include diff --git a/elf/tst-protected2apie.c b/elf/tst-protected2apie.c new file mode 100644 index 0000000000..28a7aa3d1a --- /dev/null +++ b/elf/tst-protected2apie.c @@ -0,0 +1 @@ +#include "tst-protected2a.c" diff --git a/elf/tst-protected2b.c b/elf/tst-protected2b.c new file mode 100644 index 0000000000..500323e33f --- /dev/null +++ b/elf/tst-protected2b.c @@ -0,0 +1,121 @@ +/* Test the protected visibility when main is linked with modb and moda + in that order: + 1. Protected function symbols, protected1, protected2 and protected3, + defined in moda, are used in moda. + 2. Protected function symbol, protected3, defined in modb, are used + in modb. + 3. Symbol, protected1, defined in modb, is used in main and modb. + 4. Symbol, protected2, defined in main, is used in main. + 5. Symbol, protected3, defined in modb, is also used in main. + + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include +#include + +#include "tst-protected2mod.h" + +int +protected2 (void) +{ + return -1; +} + +int +do_test (void) +{ + int res = 0; + + /* Check if we get the same address for the protected data symbol. */ + if (&protected1 == protected1a_p ()) + { + puts ("`protected1' in main and moda has the same address"); + res = 1; + } + if (&protected1 != protected1b_p ()) + { + puts ("`protected1' in main and modb doesn't have the same address"); + res = 1; + } + + /* Check if we get the right protected function symbol. */ + if (protected1 () != -3) + { + puts ("`protected1' in main and modb doesn't return the same value"); + res = 1; + } + + /* Check if we get the right function defined in executable. */ + if (protected2 () != -1) + { + puts ("`protected2' in main returns the wrong value"); + res = 1; + } + + /* Check `protected1' in moda. */ + if (!check_protected1 ()) + { + puts ("`protected1' in moda returns the wrong value"); + res = 1; + } + + /* Check `protected2' in moda. */ + if (!check_protected2 ()) + { + puts ("`protected2' in moda returns the wrong value"); + res = 1; + } + + /* Check if we get the same address for the protected function symbol. */ + if (&protected3 == protected3a_p ()) + { + puts ("`protected3' in main and moda has the same address"); + res = 1; + } + if (&protected3 != protected3b_p ()) + { + puts ("`protected3' in main and modb doesn't have the same address"); + res = 1; + } + + /* Check if we get the right protected function symbol. */ + if (protected3 () != -5) + { + puts ("`protected3' in main and modb doesn't return the same value"); + res = 1; + } + + /* Check `protected3' in moda. */ + if (!check_protected3a ()) + { + puts ("`protected3' in moda returns the wrong value"); + res = 1; + } + + /* Check `protected3' in modb. */ + if (!check_protected3b ()) + { + puts ("`protected3' in modb returns the wrong value"); + res = 1; + } + + return res; +} + +#include diff --git a/elf/tst-protected2bpie.c b/elf/tst-protected2bpie.c new file mode 100644 index 0000000000..8dcfbd04cb --- /dev/null +++ b/elf/tst-protected2bpie.c @@ -0,0 +1 @@ +#include "tst-protected2b.c" diff --git a/elf/tst-protected2mod.h b/elf/tst-protected2mod.h new file mode 100644 index 0000000000..feb28ab0d5 --- /dev/null +++ b/elf/tst-protected2mod.h @@ -0,0 +1,35 @@ +/* Test protected function symbols. + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +/* Prototypes for the functions in the DSOs. */ +extern int protected1 (void); +extern int protected2 (void); +extern int protected3 (void); + +typedef int (*protected_func_type) (void); + +extern protected_func_type protected1a_p (void); +extern protected_func_type protected1b_p (void); + +extern int check_protected1 (void); +extern int check_protected2 (void); + +extern int check_protected3a (void); +extern protected_func_type protected3a_p (void); +extern int check_protected3b (void); +extern protected_func_type protected3b_p (void); diff --git a/elf/tst-protected2moda.c b/elf/tst-protected2moda.c new file mode 100644 index 0000000000..db04e8dfb9 --- /dev/null +++ b/elf/tst-protected2moda.c @@ -0,0 +1,52 @@ +/* Test protected function symbols. + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include "tst-protected2mod.h" + +__attribute__ ((visibility("protected"))) +int +protected1 (void) +{ + return 3; +} + +__attribute__ ((visibility("protected"))) +int +protected2 (void) +{ + return 4; +} + +__attribute__ ((visibility("protected"))) +int +protected3 (void) +{ + return 5; +} + +protected_func_type +protected1a_p (void) +{ + return &protected1; +} + +protected_func_type +protected3a_p (void) +{ + return &protected3; +} diff --git a/elf/tst-protected2moda2.c b/elf/tst-protected2moda2.c new file mode 100644 index 0000000000..fae72177f9 --- /dev/null +++ b/elf/tst-protected2moda2.c @@ -0,0 +1,41 @@ +/* Test protected function symbols. + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include "tst-protected2mod.h" + +extern int protected1 (void) __attribute__ ((visibility("protected"))); +extern int protected2 (void) __attribute__ ((visibility("protected"))); +extern int protected3 (void) __attribute__ ((visibility("protected"))); + +int +check_protected1 (void) +{ + return protected1 () == 3; +} + +int +check_protected2 (void) +{ + return protected2 () == 4; +} + +int +check_protected3a (void) +{ + return protected3 () == 5; +} diff --git a/elf/tst-protected2modb.c b/elf/tst-protected2modb.c new file mode 100644 index 0000000000..3c5063f0c3 --- /dev/null +++ b/elf/tst-protected2modb.c @@ -0,0 +1,45 @@ +/* Test protected function symbols. + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include "tst-protected2mod.h" + +int +protected1 (void) +{ + return -3; +} + +__attribute__ ((visibility("protected"))) +int +protected3 (void) +{ + return -5; +} + +protected_func_type +protected1b_p (void) +{ + return &protected1; +} + +protected_func_type +protected3b_p (void) +{ + return &protected3; +} diff --git a/elf/tst-protected2modb2.c b/elf/tst-protected2modb2.c new file mode 100644 index 0000000000..b21b827134 --- /dev/null +++ b/elf/tst-protected2modb2.c @@ -0,0 +1,28 @@ +/* Test protected function symbols. + Copyright (C) 2021 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include "tst-protected2mod.h" + +extern int protected3 (void) __attribute__ ((visibility("protected"))); + +int +check_protected3b (void) +{ + return protected3 () == -5; +}