I can't remember what it's called, but there's a module that wraps a function call with pre and post handlers. Sounds perfect if you want to do this for a few functions.

Update: I found Hook::PrePostCall, but I think there's another one. I haven't used either.

...but I think there's another one...

There is Hook::LexWrap:

use Hook::LexWrap;

wrap( $_,
      pre  => sub { print "$_ begin\n" },
      post => sub { print "$_ end\n"   },
    ) for @subs_to_wrap;
[download]

Updated example to be more inline with OP's requirements.

... I think there's another one.

There's also Hook::WrapSub:

use Hook::WrapSub qw( wrap_subs );

wrap_subs(
  sub { print "before $Hook::WrapSub::name (@_)\n" },
  @subs_to_wrap,
  sub { print "after $Hook::WrapSub::name (@Hook::WrapSub::result)\n" 
+}
);
[download]

We're building the house of the future together.

#!/usr/bin/perl

use warnings;
use strict;
package SubLog;

sub new
{
  my $class = shift;
  my $self = {
    name => (caller(1))[3],
  };
  warn "ENTERING SUB: $self->{name}\n";
  bless $self, $class;
}

sub DESTROY 
{
  my $self = shift;
  warn "EXITED SUB: $self->{name}\n";
}
package main;

sub blahblah
{
  my $sublog = SubLog->new;
  return 5;
}

sub blahsub
{
  my $sublog = SubLog->new;
  blahblah();
  return 3;
}

blahsub();
[download]

Thanks sgifford, this is just what I needed. I also pulled the line from caller to make things more exact. :)

It's conceivable that you could (though I'm somewhat doubtful), but it might be easier, if this is for debugging, to wrap your subroutines, roughly thus (largely untested):

sub dosomething {print "in dosomething\n" }

sub wrappit {
    no strict 'refs';
    my ($subname) = @_;
    my $oldsub = \&{$subname};
    *{$subname} = sub {
        print "entering $subname\n";
        my @rv = wantarray ? $oldsub->(@_) : scalar $oldsub->(@_);
        print "leaving $subname\n";
        return wantarray ? @rv : $rv[0];
    };
}
wrappit('dosomething');
dosomething(1..5);
[download]

# This is the custom debugger:
{ package DB;
  sub DB {}
  sub sub {
    print STDERR "== Entering sub $sub\n";
    &$sub; # Call the sub
    print STDERR "=== Leaving sub $sub\n";
  }
}

# Now some example code to test it with:
sub hello {
  print "Hello, ";
  world();
}

sub world {
  print "World!\n";
}

$|++;   # Turn off buffering, to make the control flow clearer
hello();
[download]

$ perl d.pl
Hello, World!
$ perl -d d.pl

Loading DB routines from perl5db.pl version 1.28
Editor support available.

Enter h or `h h' for help, or `man perldebug' for more help.

== Entering sub main::hello
Hello, == Entering sub main::world
World!
=== Leaving sub main::world
=== Leaving sub main::hello
[download]

Update: As a (probably better) alternative to running perl -d, you can use

  BEGIN {$^P = 1}
[download]

BEGIN {
  return if $^P;  # If the debugger is running, leave well alone
  $^P = 1;        # Enable subroutine tracing
  package DB;
  *sub = sub {
    print STDERR "== Entering sub $sub\n";
    &$sub;
    print STDERR "=== Leaving sub $sub\n";
  };
}
[download]

HTH, --traveler

You might consider using only a single return, and directing your flow to it. If you are returning values, then set a variable to the appropriate value in your conditionals, and return from the same point (with the print subroutine just before). If you're only returning based on conditionals, consider setting a flag.