Exception handling overhead?

["Peter C. Chapin" <pcc482719@gmail.com>]

Hello!

I'm creating a type intended to represent lines of editable text. It 
will provide some specialized services and is not intended to be a 
general purpose string type. At the moment I'm wrapping the type 
Ada.Strings.Unbounded.Unbounded_String (I'm really using Wide_Strings, 
but I don't think that's important right now). I may want to change that 
underlying implementation in the future so I don't want to directly 
expose my current choice to my clients. Thus I'm providing some 
subprograms that do some minor things and then just forward to 
subprograms in Ada.Strings.Unbounded.

My question is about exceptions. To avoid exposing my implementation 
choice and to give me more control in the long run I've defined my own 
exception for (as an example) an out of bounds access:

Bad_Index : exception;

Naturally I want to raise this exception if the client tries to access a 
character not in my buffer. This leads to two possibilities.

function Element(B : Buffer; Index : Positive) return Character is
begin
  if Index > Ada.Strings.Unbounded.Length(B.Internal_String) then
    raise Bad_Index;
  end if;
  return Ada.Strings.Unbounded.Element(B.Internal_String, Index);
end Element;

This entails two checks on the index value: the one I'm doing and the 
one being done inside Ada.Strings.Unbounded.Element. Another approach is

function Element(B : Buffer; Index : Positive) return Character is
begin
  return Ada.Strings.Unbounded.Element(B.Internal_String, Index);
exception
  when Ada.Strings.Index_Error =>
    raise Bad_Index;
end Element;

This lets the check exist in only one place but it invokes the machinery 
of exception handling.

Now I know that in C++ there are implementation methods that allow zero 
execution time overhead in the case when an exception is not thrown (at 
the expense of increasing executable size and making thrown exceptions 
slower). Compilers are not required to use such methods, of course, but 
I know of at least one that does... or that can if the right options are 
selected. I'm wondering about how this might work in Ada. Does Ada admit 
such implementation methods? If so, do compilers commonly use them? From 
a raw performance point of view which of the two approaches above would 
be "better?"

For the record... I understand that in my application it probably 
doesn't matter much either way. I also understand that the answer is 
likely to be very compiler specific. This is mostly a question of 
academic interest.

Thanks!

Peter