I only have a workaround: set a break (or continue to the point) where %hash is initialized. Then create a reference to that hash with $href = \%hash, and watch with w $href->{'myEntry'}.

The variables you define in the debugger don't go out of scope. But note that the behavior of your code will change if you want %hash to go out of scope and maybe be re-initialized later: As long as the reference lives, %hash will stick around.

I didn't like the idea of having an extra reference count, because this smells like Heisenbug.

So I thought weakening it might be a good idea, but then I realized that the reference might change and the global var will fail.

Tricky. I could think of some approaches to solve this, but I'm AFK right now.

And the OP didn't show us any code...

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

w $hash{key} ne "unexpected"
[download]

Note that if the value is changed on the last line of a subroutine, the debugger won't show it, instead it will notice the change the next time you enter the scope.

Example:

#!/usr/bin/perl
use warnings;
use strict;
use feature qw{ say };

{   my %hash;
    sub set {
        %hash = (a => 12, b => 14);
    }
    sub get {
        my ($key) = @_;
        return $hash{$key}
    }
    sub change {
        $hash{b} = 'Boo';
    }
}

set();

say get('b');

change();

say get('b');
[download]

Thanks, I tested the tip from stackoverflow using a watch with a hash reference in a global variable, and it seemed to work!
BTW: I think this useful technique should be known more!

Another way to find out where the hash is being changed is to use Hash::Util 'lock_hash'; and then lock_hash( %hash ); once it has been set up. This turns any attempt to assign to the hash into a fatal exception.

%hash=(1,2,3,4);
while (1) {
  print "Something...\n";
  ===cut===
}
[download]

The global one would only be visible outside the scope and produce no value changes when watched.