diff --git a/SOURCES/_gdb.spec.Patch.include b/SOURCES/_gdb.spec.Patch.include
index 0a15ee8..f9e20b1 100644
--- a/SOURCES/_gdb.spec.Patch.include
+++ b/SOURCES/_gdb.spec.Patch.include
@@ -743,3 +743,11 @@ Patch181: gdb-rhbz1842691-corefile-mem-access-15of15.patch
# Nick Clifton and Keith Seitz, RH BZ 1878810
Patch182: gdb-rhbz1878810-bfd-suppress-loadable-section-outside-ELF-sections.patch
+# Backport "fortran dynamic type related fixes"
+# Andrew Burgess (RH BZ 1905701)
+Patch183: gdb-rhbz1905701-DWARF-data_location.patch
+
+# Backport of "Correct recording of 'store on condition' insns"
+# Andreas Arnaz (RH BZ 1903374)
+Patch184: gdb-rhbz1903374-s390x-store-on-condition.patch
+
diff --git a/SOURCES/_gdb.spec.patch.include b/SOURCES/_gdb.spec.patch.include
index 68a3258..f14d36a 100644
--- a/SOURCES/_gdb.spec.patch.include
+++ b/SOURCES/_gdb.spec.patch.include
@@ -180,3 +180,5 @@
%patch180 -p1
%patch181 -p1
%patch182 -p1
+%patch183 -p1
+%patch184 -p1
diff --git a/SOURCES/gdb-rhbz1903374-s390x-store-on-condition.patch b/SOURCES/gdb-rhbz1903374-s390x-store-on-condition.patch
new file mode 100644
index 0000000..b132391
--- /dev/null
+++ b/SOURCES/gdb-rhbz1903374-s390x-store-on-condition.patch
@@ -0,0 +1,64 @@
+From FEDORA_PATCHES Mon Sep 17 00:00:00 2001
+From: Andreas Arnez <arnez@linux.ibm.com>
+Date: Thu, 19 Nov 2020 19:10:58 +0100
+Subject: gdb-rhbz1903374-s390x-store-on-condition.patch
+
+;; Backport of "Correct recording of 'store on condition' insns"
+;; Andreas Arnaz (RH BZ 1903374)
+
+gdb/s390: Correct recording of "store on condition" insns
+
+The "store on condition" instructions STOC, STOCG, and STOCFH are recorded
+as if their instruction formats resembled that of STG. This is wrong,
+usually resulting in "failed to record execution log" errors when trying
+to record code with any of these instructions.
+
+This patch fixes the recording of these instructions.
+
+gdb/ChangeLog:
+
+ PR tdep/26916
+ * s390-tdep.c (s390_process_record): Fix recording of STOC, STOCG,
+ and STOCFH.
+
+diff --git a/gdb/s390-tdep.c b/gdb/s390-tdep.c
+--- a/gdb/s390-tdep.c
++++ b/gdb/s390-tdep.c
+@@ -5332,7 +5332,6 @@ ex:
+ case 0xe325: /* NTSTG - nontransactional store */
+ case 0xe326: /* CVDY - convert to decimal */
+ case 0xe32f: /* STRVG - store reversed */
+- case 0xebe3: /* STOCG - store on condition */
+ case 0xed67: /* STDY - store */
+ oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
+ if (record_full_arch_list_add_mem (oaddr, 8))
+@@ -5361,8 +5360,6 @@ ex:
+ case 0xe33e: /* STRV - store reversed */
+ case 0xe350: /* STY - store */
+ case 0xe3cb: /* STFH - store high */
+- case 0xebe1: /* STOCFH - store high on condition */
+- case 0xebf3: /* STOC - store on condition */
+ case 0xed66: /* STEY - store */
+ oaddr = s390_record_calc_disp (gdbarch, regcache, inib[3], insn[1], ibyte[4]);
+ if (record_full_arch_list_add_mem (oaddr, 4))
+@@ -6075,6 +6072,20 @@ ex:
+
+ /* 0xeb9c-0xebbf undefined */
+ /* 0xebc1-0xebdb undefined */
++
++ case 0xebe1: /* STOCFH - store high on condition */
++ case 0xebf3: /* STOC - store on condition */
++ oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
++ if (record_full_arch_list_add_mem (oaddr, 4))
++ return -1;
++ break;
++
++ case 0xebe3: /* STOCG - store on condition */
++ oaddr = s390_record_calc_disp (gdbarch, regcache, 0, insn[1], ibyte[4]);
++ if (record_full_arch_list_add_mem (oaddr, 8))
++ return -1;
++ break;
++
+ /* 0xebe5 undefined */
+ /* 0xebe9 undefined */
+ /* 0xebeb-0xebf1 undefined */
diff --git a/SOURCES/gdb-rhbz1905701-DWARF-data_location.patch b/SOURCES/gdb-rhbz1905701-DWARF-data_location.patch
new file mode 100644
index 0000000..3c74a9e
--- /dev/null
+++ b/SOURCES/gdb-rhbz1905701-DWARF-data_location.patch
@@ -0,0 +1,573 @@
+From FEDORA_PATCHES Mon Sep 17 00:00:00 2001
+From: Keith Seitz <keiths@redhat.com>
+Date: Wed, 2 Dec 2020 17:39:33 -0500
+Subject: gdb-rhbz1905701-DWARF-data_location.patch
+
+;; Backport "fortran dynamic type related fixes"
+;; Andrew Burgess (RH BZ 1905701)
+
+ commit e79eb02f2f09baecffb144bac6804f975065466f
+
+ gdb/fortran: resolve dynamic types when readjusting after an indirection
+
+ After dereferencing a pointer (in value_ind) or following a
+ reference (in coerce_ref) we call readjust_indirect_value_type to
+ "fixup" the type of the resulting value object.
+
+ This fixup handles cases relating to the type of the resulting object
+ being different (a sub-class) of the original pointers target type.
+
+ If we encounter a pointer to a dynamic type then after dereferencing a
+ pointer (in value_ind) the type of the object created will have had
+ its dynamic type resolved. However, in readjust_indirect_value_type,
+ we use the target type of the original pointer to "fixup" the type of
+ the resulting value. In this case, the target type will be a dynamic
+ type, so the resulting value object, once again has a dynamic type.
+
+ This then triggers an assertion later within GDB.
+
+ The solution I propose here is that we call resolve_dynamic_type on
+ the pointer's target type (within readjust_indirect_value_type) so
+ that the resulting value is not converted back to a dynamic type.
+
+ The test case is based on the original test in the bug report.
+
+ gdb/ChangeLog:
+
+ PR fortran/23051
+ PR fortran/26139
+ * valops.c (value_ind): Pass address to
+ readjust_indirect_value_type.
+ * value.c (readjust_indirect_value_type): Make parameter
+ non-const, and add extra address parameter. Resolve original type
+ before using it.
+ * value.h (readjust_indirect_value_type): Update function
+ signature and comment.
+
+ gdb/testsuite/ChangeLog:
+
+ PR fortran/23051
+ PR fortran/26139
+ * gdb.fortran/class-allocatable-array.exp: New file.
+ * gdb.fortran/class-allocatable-array.f90: New file.
+ * gdb.fortran/pointer-to-pointer.exp: New file.
+ * gdb.fortran/pointer-to-pointer.f90: New file.
+
+diff --git a/gdb/testsuite/gdb.dwarf2/graalvm-data-loc2.c b/gdb/testsuite/gdb.dwarf2/graalvm-data-loc2.c
+new file mode 100644
+--- /dev/null
++++ b/gdb/testsuite/gdb.dwarf2/graalvm-data-loc2.c
+@@ -0,0 +1,63 @@
++/* Copyright 2014-2020 Free Software Foundation, Inc.
++
++ This file is part of GDB.
++
++ This program 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 of the License, or
++ (at your option) any later version.
++
++ This program 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 this program. If not, see <http://www.gnu.org/licenses/>. */
++
++/* This C file simulates the implementation of object pointers in
++ GraalVM Java native images where the object data is not addressed
++ directly. It serves as a regression test for a bug where printing
++ of such redirected data structures suffers from a gdb exception.
++
++ Debugging information on how to decode an object pointer to
++ identify the address of the underlying data will be generated
++ separately by the testcase using that file. */
++
++#include <stdlib.h>
++#include <string.h>
++
++struct Object {
++ struct Object *next;
++ int val;
++};
++
++struct Object *testOop;
++
++extern int debugMe() {
++ return 0;
++}
++
++struct Object *newObject() {
++ char *bytes = malloc(sizeof(struct Object));
++ return (struct Object *)bytes;
++}
++
++int
++main (void)
++{
++ struct Object *obj1 = newObject();
++ struct Object *obj2 = newObject();
++ struct Object *obj3 = newObject();
++ obj1->val = 0;
++ obj2->val = 1;
++ obj3->val = 2;
++
++ obj1->next = obj2;
++ obj2->next = obj3;
++ obj3->next = obj1;
++
++ testOop = obj1;
++
++ return debugMe();
++}
+diff --git a/gdb/testsuite/gdb.dwarf2/graalvm-data-loc2.exp b/gdb/testsuite/gdb.dwarf2/graalvm-data-loc2.exp
+new file mode 100644
+--- /dev/null
++++ b/gdb/testsuite/gdb.dwarf2/graalvm-data-loc2.exp
+@@ -0,0 +1,122 @@
++# Copyright 2014-2020 Free Software Foundation, Inc.
++
++# This program 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 of the License, or
++# (at your option) any later version.
++#
++# This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
++load_lib dwarf.exp
++
++# This test can only be run on targets which support DWARF-2 and use gas.
++if {![dwarf2_support]} {
++ return 0
++}
++
++standard_testfile .c -dw.S
++
++if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
++ return -1
++}
++
++# Make some DWARF for the test.
++set asm_file [standard_output_file $srcfile2]
++Dwarf::assemble $asm_file {
++
++ cu {} {
++ DW_TAG_compile_unit {
++ {DW_AT_language @DW_LANG_C99}
++ {DW_AT_name data-loc2.c}
++ {DW_AT_comp_dir /tmp}
++ } {
++ declare_labels integer_label struct_label pointer_label
++
++ integer_label: DW_TAG_base_type {
++ {DW_AT_byte_size 4 DW_FORM_sdata}
++ {DW_AT_encoding @DW_ATE_signed}
++ {DW_AT_name integer}
++ }
++
++ struct_label: DW_TAG_structure_type {
++ {DW_AT_name "Object"}
++ {DW_AT_byte_size 20 DW_FORM_sdata}
++ {DW_AT_data_location {
++ DW_OP_push_object_address
++ } SPECIAL_expr}
++ } {
++ member {
++ {name next}
++ {type :$pointer_label}
++ {data_member_location 0 data1}
++ }
++ member {
++ {name val}
++ {type :$integer_label}
++ {data_member_location 8 data1}
++ }
++ }
++ pointer_label: DW_TAG_pointer_type {
++ {DW_AT_byte_size 4 DW_FORM_sdata}
++ {DW_AT_type :$struct_label}
++ }
++ DW_TAG_variable {
++ {DW_AT_name testOop}
++ {DW_AT_type :$pointer_label}
++ {DW_AT_location {
++ DW_OP_addr [gdb_target_symbol testOop]
++ } SPECIAL_expr}
++ {external 1 flag}
++ }
++ }
++ }
++}
++
++# Now that we've generated the DWARF debugging info, rebuild our
++# program using our debug info instead of the info generated by
++# the compiler.
++
++if { [prepare_for_testing "failed to prepare" ${testfile} \
++ [list $srcfile $asm_file] {nodebug}] } {
++ return -1
++}
++
++if ![runto_main] {
++ return -1
++}
++
++# ensure the object network is set up as expected and check that
++# printing of structs which employ the data_location does not
++# fail with a gdb exception
++
++gdb_test "break debugMe" \
++ "Breakpoint .*" \
++ "set breakpoint at debugMe"
++
++gdb_continue_to_breakpoint "continue to debugMe"
++
++gdb_test "print testOop->val" \
++ ".* = 0"
++
++gdb_test "print testOop->next->val" \
++ ".* = 1"
++
++gdb_test "print testOop->next->next->val" \
++ ".* = 2"
++
++gdb_test "print *testOop" \
++ ".* = {next = .*, val = 0}" \
++ "print contents of struct"
++
++gdb_test "print *testOop->next" \
++ ".* = {next = .*, val = 1}" \
++ "print contents of an indirect struct"
++
++gdb_test "print *testOop->next->next" \
++ ".* = {next = .*, val = 2}" \
++ "print contents of a double indirect struct"
+diff --git a/gdb/testsuite/gdb.fortran/class-allocatable-array.exp b/gdb/testsuite/gdb.fortran/class-allocatable-array.exp
+new file mode 100644
+--- /dev/null
++++ b/gdb/testsuite/gdb.fortran/class-allocatable-array.exp
+@@ -0,0 +1,43 @@
++# Copyright 2020 Free Software Foundation, Inc.
++
++# This program 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 of the License, or
++# (at your option) any later version.
++#
++# This program 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 this program. If not, see <http://www.gnu.org/licenses/> .
++
++# Test that GDB can print an allocatable array that is a data field
++# within a class like type.
++
++if {[skip_fortran_tests]} { return -1 }
++
++standard_testfile ".f90"
++load_lib fortran.exp
++
++if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
++ {debug f90}]} {
++ return -1
++}
++
++if {![runto MAIN__]} {
++ untested main"could not run to main"
++ return -1
++}
++
++gdb_breakpoint [gdb_get_line_number "Break Here"]
++gdb_continue_to_breakpoint "Break Here"
++
++# If this first test fails then the Fortran compiler being used uses
++# different names, or maybe a completely different approach, for
++# representing class like structures. The following tests are
++# cetainly going to fail.
++gdb_test "print this" " = \\( _data = \[^\r\n\]+, _vptr = \[^\r\n\]+\\)"
++gdb_test "print this%_data" " = \\(PTR TO -> \\( Type test_type \\)\\) \[^\r\n\]+"
++gdb_test "print this%_data%b" " = \\(\\( 1, 2, 3\\) \\( 4, 5, 6\\) \\)"
+diff --git a/gdb/testsuite/gdb.fortran/class-allocatable-array.f90 b/gdb/testsuite/gdb.fortran/class-allocatable-array.f90
+new file mode 100644
+--- /dev/null
++++ b/gdb/testsuite/gdb.fortran/class-allocatable-array.f90
+@@ -0,0 +1,54 @@
++! Copyright 2020 Free Software Foundation, Inc.
++!
++! This program 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 of the License, or
++! (at your option) any later version.
++!
++! This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
++
++module test_module
++ type test_type
++ integer a
++ real, allocatable :: b (:, :)
++ contains
++ procedure :: test_proc
++ end type test_type
++
++contains
++
++ subroutine test_proc (this)
++ class(test_type), intent (inout) :: this
++ allocate (this%b (3, 2))
++ call fill_array_2d (this%b)
++ print *, "" ! Break Here
++ contains
++ ! Helper subroutine to fill 2-dimensional array with unique
++ ! values.
++ subroutine fill_array_2d (array)
++ real, dimension (:,:) :: array
++ real :: counter
++
++ counter = 1.0
++ do i=LBOUND (array, 2), UBOUND (array, 2), 1
++ do j=LBOUND (array, 1), UBOUND (array, 1), 1
++ array (j,i) = counter
++ counter = counter + 1
++ end do
++ end do
++ end subroutine fill_array_2d
++ end subroutine test_proc
++end module
++
++program test
++ use test_module
++ implicit none
++ type(test_type) :: t
++ call t%test_proc ()
++end program test
+diff --git a/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp b/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
+new file mode 100644
+--- /dev/null
++++ b/gdb/testsuite/gdb.fortran/pointer-to-pointer.exp
+@@ -0,0 +1,46 @@
++# Copyright 2020 Free Software Foundation, Inc.
++
++# This program 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 of the License, or
++# (at your option) any later version.
++#
++# This program 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 this program. If not, see <http://www.gnu.org/licenses/> .
++
++# Test for GDB printing a pointer to a type containing a buffer.
++
++if {[skip_fortran_tests]} { return -1 }
++
++standard_testfile ".f90"
++load_lib fortran.exp
++
++if {[prepare_for_testing ${testfile}.exp ${testfile} ${srcfile} \
++ {debug f90}]} {
++ return -1
++}
++
++if {![runto MAIN__]} {
++ untested "could not run to main"
++ return -1
++}
++
++gdb_breakpoint [gdb_get_line_number "Break Here"]
++gdb_continue_to_breakpoint "Break Here"
++
++gdb_test "print *buffer" \
++ " = \\( alpha = \\(1\\.5, 2\\.5, 3\\.5, 4\\.5, 5\\.5\\) \\)"
++
++set l_buffer_type [multi_line \
++ "Type l_buffer" \
++ " real\\(kind=4\\) :: alpha\\(.\\)" \
++ "End Type l_buffer" ]
++
++gdb_test "ptype buffer" "type = PTR TO -> \\( ${l_buffer_type} \\)"
++gdb_test "ptype *buffer" "type = ${l_buffer_type}"
++gdb_test "ptype buffer%alpha" "type = real\\(kind=4\\) \\(5\\)"
+diff --git a/gdb/testsuite/gdb.fortran/pointer-to-pointer.f90 b/gdb/testsuite/gdb.fortran/pointer-to-pointer.f90
+new file mode 100644
+--- /dev/null
++++ b/gdb/testsuite/gdb.fortran/pointer-to-pointer.f90
+@@ -0,0 +1,34 @@
++! Copyright 2020 Free Software Foundation, Inc.
++!
++! This program 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 of the License, or
++! (at your option) any later version.
++!
++! This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
++
++program allocate_array
++
++ type l_buffer
++ real, dimension(:), pointer :: alpha
++ end type l_buffer
++ type(l_buffer), pointer :: buffer
++
++ allocate (buffer)
++ allocate (buffer%alpha (5))
++
++ buffer%alpha (1) = 1.5
++ buffer%alpha (2) = 2.5
++ buffer%alpha (3) = 3.5
++ buffer%alpha (4) = 4.5
++ buffer%alpha (5) = 5.5
++
++ print *, buffer%alpha ! Break Here.
++
++end program allocate_array
+diff --git a/gdb/valops.c b/gdb/valops.c
+--- a/gdb/valops.c
++++ b/gdb/valops.c
+@@ -1573,42 +1573,34 @@ value_ind (struct value *arg1)
+ if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
+ {
+ struct type *enc_type;
+- CORE_ADDR addr;
+-
+- if (type_not_associated (base_type))
+- error (_("Attempt to take contents of a not associated pointer."));
+-
+- if (NULL != TYPE_DATA_LOCATION (TYPE_TARGET_TYPE (base_type)))
+- addr = value_address (arg1);
+- else
+- addr = value_as_address (arg1);
+-
+- if (addr != 0)
+- TYPE_TARGET_TYPE (base_type) =
+- resolve_dynamic_type (TYPE_TARGET_TYPE (base_type), NULL, addr);
+
+ /* We may be pointing to something embedded in a larger object.
+ Get the real type of the enclosing object. */
+ enc_type = check_typedef (value_enclosing_type (arg1));
+ enc_type = TYPE_TARGET_TYPE (enc_type);
+
++ CORE_ADDR base_addr;
+ if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
+ || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
+- /* For functions, go through find_function_addr, which knows
+- how to handle function descriptors. */
+- arg2 = value_at_lazy (enc_type,
+- find_function_addr (arg1, NULL));
++ {
++ /* For functions, go through find_function_addr, which knows
++ how to handle function descriptors. */
++ base_addr = find_function_addr (arg1, NULL);
++ }
+ else
+- /* Retrieve the enclosing object pointed to. */
+- arg2 = value_at_lazy (enc_type,
+- (addr - value_pointed_to_offset (arg1)));
++ {
++ /* Retrieve the enclosing object pointed to. */
++ base_addr = (value_as_address (arg1)
++ - value_pointed_to_offset (arg1));
++ }
+
++ arg2 = value_at_lazy (enc_type, base_addr);
+ enc_type = value_type (arg2);
+- return readjust_indirect_value_type (arg2, enc_type, base_type, arg1);
++ return readjust_indirect_value_type (arg2, enc_type, base_type,
++ arg1, base_addr);
+ }
+
+ error (_("Attempt to take contents of a non-pointer value."));
+- return 0; /* For lint -- never reached. */
+ }
+
+ /* Create a value for an array by allocating space in GDB, copying the
+diff --git a/gdb/value.c b/gdb/value.c
+--- a/gdb/value.c
++++ b/gdb/value.c
+@@ -3611,10 +3611,19 @@ coerce_ref_if_computed (const struct value *arg)
+ struct value *
+ readjust_indirect_value_type (struct value *value, struct type *enc_type,
+ const struct type *original_type,
+- const struct value *original_value)
++ struct value *original_value,
++ CORE_ADDR original_value_address)
+ {
++ gdb_assert (TYPE_CODE (original_type) == TYPE_CODE_PTR
++ || TYPE_IS_REFERENCE (original_type));
++
++ struct type *original_target_type = TYPE_TARGET_TYPE (original_type);
++ struct type *resolved_original_target_type
++ = resolve_dynamic_type (original_target_type, NULL,
++ original_value_address);
++
+ /* Re-adjust type. */
+- deprecated_set_value_type (value, TYPE_TARGET_TYPE (original_type));
++ deprecated_set_value_type (value, resolved_original_target_type);
+
+ /* Add embedding info. */
+ set_value_enclosing_type (value, enc_type);
+@@ -3641,12 +3650,11 @@ coerce_ref (struct value *arg)
+ enc_type = check_typedef (value_enclosing_type (arg));
+ enc_type = TYPE_TARGET_TYPE (enc_type);
+
+- retval = value_at_lazy (enc_type,
+- unpack_pointer (value_type (arg),
+- value_contents (arg)));
++ CORE_ADDR addr = unpack_pointer (value_type (arg), value_contents (arg));
++ retval = value_at_lazy (enc_type, addr);
+ enc_type = value_type (retval);
+- return readjust_indirect_value_type (retval, enc_type,
+- value_type_arg_tmp, arg);
++ return readjust_indirect_value_type (retval, enc_type, value_type_arg_tmp,
++ arg, addr);
+ }
+
+ struct value *
+diff --git a/gdb/value.h b/gdb/value.h
+--- a/gdb/value.h
++++ b/gdb/value.h
+@@ -487,7 +487,9 @@ extern struct value *coerce_ref_if_computed (const struct value *arg);
+
+ /* Setup a new value type and enclosing value type for dereferenced value VALUE.
+ ENC_TYPE is the new enclosing type that should be set. ORIGINAL_TYPE and
+- ORIGINAL_VAL are the type and value of the original reference or pointer.
++ ORIGINAL_VAL are the type and value of the original reference or
++ pointer. ORIGINAL_VALUE_ADDRESS is the address within VALUE, that is
++ the address that was dereferenced.
+
+ Note, that VALUE is modified by this function.
+
+@@ -496,7 +498,8 @@ extern struct value *coerce_ref_if_computed (const struct value *arg);
+ extern struct value * readjust_indirect_value_type (struct value *value,
+ struct type *enc_type,
+ const struct type *original_type,
+- const struct value *original_val);
++ struct value *original_val,
++ CORE_ADDR original_value_address);
+
+ /* Convert a REF to the object referenced. */
+
diff --git a/SPECS/gdb.spec b/SPECS/gdb.spec
index bb6b4e6..ed26b1e 100644
--- a/SPECS/gdb.spec
+++ b/SPECS/gdb.spec
@@ -26,7 +26,7 @@ Version: 8.2
# The release always contains a leading reserved number, start it at 1.
# `upstream' is not a part of `name' to stay fully rpm dependencies compatible for the testing.
-Release: 14%{?dist}
+Release: 15%{?dist}
License: GPLv3+ and GPLv3+ with exceptions and GPLv2+ and GPLv2+ with exceptions and GPL+ and LGPLv2+ and LGPLv3+ and BSD and Public Domain and GFDL
Group: Development/Debuggers
@@ -1062,6 +1062,12 @@ fi
%endif
%changelog
+* Fri Dec 11 2020 Keith Seitz <keiths@redhat.com> - 8.2-15.el8
+- Backport "Correct recording of 'store on condition' insns"
+ (Andreas Arnaz, RH BZ 1903374)
+- Backport "Fortran dynamic type related fixes"
+ (Andrew Burgess, RH BZ 1905701)
+
* Fri Nov 13 2020 Keith Seitz <keiths@redhat.com> - 8.2-14.el8
- Obsolete earlier versions on x86_64 and conflict with 64-bit
glibc on ix86. (Keith Seitz, RH BZ 1853140)