When you present us with just a snippet (which we are not able to test ourselves), you run the risk of leaving out relevant details, and it would be more effective to show us a fully self-contained and runnable script (with suitable sample data) to demonstrate the problem. (Usually, in the process of trying to distill the problem into a stand-alone demonstration, you will figure out what the problem is and how to fix it on your own. It generally improves your ability to diagnose problems.)

In the present case, we don't know if maybe you set $/ to undef, and maybe the input file is really big -- in which case, it's probably not the regex that's stalling, but the attempt to read the entire file into a single scalar variable.

Apart from that (or something like that), I don't see anything to indicate a problem with the code as posted, except that there are "cosmetic" issues that could be improved (and cosmetic improvements can be worthwhile) -- e.g.:

use strict;

open( FILE, '<', "whatever.filename' ) or die "whatever... $!\n";

my $container;
my ( %SIR, %SFR );

while (<FILE>){
    chomp;
    if ( /SPECint_base/ ) {
        $container = \%SIR;
    }
    elsif ( /SPECfp_base/ ) {
        $container = \%SFR ;
    }
    elsif ( $container ) {
        $container->{$_} = undef;  # no need to repeat hash key as has
+h value
    }
}
[download]

(Oh, by the way, are you sure that everything following one or the other "header" string should be included in the corresponding container?)

What exactly are you trying to accomplish?

Your code is probably not doing what you want it to do, but there is no looping of any kind except for the file processing. Once that's done your code would finish.

How exactly are you trying to process the file? I could point out probable flaws in your current code, but it would be more effective if you explained your goal before we start trying to decipher your intent.

The file is a list. SPECint_base and SPECfp_base are headers. When it finds one or the other, its respective valid variable becomes true. It should not store the header in its respective hash. When it loops through, unless $_ is one of the headers, it should be put in whichever hash.

I might understand what you want, but try making an example. Show us a fake data file in the format that your using and then state what should be the resultant data structures after processing.

I know what I mean. Why don't you?

Because $SIRtrue is true whenever /SPECint_base/ matches, this line:

is equivalent to:

That "if" statement can never be true. A similar argument applies to the final "if" statement. No assignment will ever be made to the %SIR or %SFR hashes.

You might also wish to note that regex matches in Perl are performed by default on the $_ variable. See perlretut. So you can replace:

with this:

Update: of course limzz's reply is correct. But we still have not heard from the OP exactly what the behaviour of the program is. There is nothing in the code shown to cause an infinite loop.

Your code, for the most part, seems to do what you want. I don't see how you can end up in a loop. The only portion that seems very suspect is this:

    if ($SIRtrue && !($_ =~ /SPECint_base/)){
    $SIR{$_}=$_;
    }
    if ($SFRtrue && !($_ =~ /SPECfp_base/)){
    $SFR{$_}=$_;
    }
[download]

You're stuffing the line you find into a hash key named the same as the line value. This is likely not what you want.

This may be closer to what you want (assuming my data below somewhat resembles your file), but it's honestly hard to say:

use strict;
use warnings;

use Data::Dumper;

my $str = <<END;
SPECint_base
1
2
3
SPECfp_base
4
5
6
END

open my $fh, '<', \$str or die "Could not open for read:$!\n";

my $SIRtrue;
my $SFRtrue;
my %SIR = ();
my %SFR = ();

while (<$fh>){
    chomp;
    if (/SPECint_base/){
        $SIRtrue = 1;
        $SFRtrue = 0;
        next;
    }
    elsif (/SPECfp_base/){
        $SIRtrue = 0;
        $SFRtrue = 1;
        next;
    }
    if ($SIRtrue)){
        push( @{$SIR{SPECint_base}}, $_ );
    }
    elsif ($SFRtrue){
        push( @{$SFR{SPECfp_base}}, $_ );
    }
}

print Dumper(\%SIR);
print Dumper(\%SFR);
[download]

Output:

$VAR1 = {
          'SPECint_base' => [
                              '1',
                              '2',
                              '3'
                            ]
        };
$VAR1 = {
          'SPECfp_base' => [
                             '4',
                             '5',
                             '6'
                           ]
        };
[download]

Nope, maybe I should have explained what the code does. Think of SPECint_base and SPECfp_base as headers, then any elements beneath them will be put into the hash, but not the headers themselves.