Fixed merge-related test failure

src/jsregexp.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 166 matching lines @@
         break;
       case 'm':
         flags |= JSRegExp::MULTILINE;
         break;
     }
   }
   return JSRegExp::Flags(flags);
 }
 
 
-static inline Handle<Object> CreateRegExpException(Handle<JSRegExp> re,
-                                                   Handle<String> pattern,
-                                                   Handle<String> error_text,
-                                                   const char* message) {
+static inline void ThrowRegExpException(Handle<JSRegExp> re,
+                                        Handle<String> pattern,
+                                        Handle<String> error_text,
+                                        const char* message) {
   Handle<JSArray> array = Factory::NewJSArray(2);
   SetElement(array, 0, pattern);
   SetElement(array, 1, error_text);
   Handle<Object> regexp_err = Factory::NewSyntaxError(message, array);
-  return Handle<Object>(Top::Throw(*regexp_err));
+  Top::Throw(*regexp_err);
 }
 
 
 Handle<Object> RegExpImpl::Compile(Handle<JSRegExp> re,
                                    Handle<String> pattern,
                                    Handle<String> flag_str) {
   JSRegExp::Flags flags = RegExpFlagsFromString(flag_str);
   Handle<FixedArray> cached = CompilationCache::LookupRegExp(pattern, flags);
   bool in_cache = !cached.is_null();
   Handle<Object> result;
   StringShape shape(*pattern);
   if (in_cache) {
     re->set_data(*cached);
     result = re;
   } else {
     SafeStringInputBuffer buffer(pattern.location());
     RegExpParseResult parse_result;
     if (!ParseRegExp(&buffer, &parse_result)) {
       // Throw an exception if we fail to parse the pattern.
-      return CreateRegExpException(re,
-                                   pattern,
-                                   parse_result.error,
-                                   "malformed_regexp");
+      ThrowRegExpException(re,
+                           pattern,
+                           parse_result.error,
+                           "malformed_regexp");
+      return Handle<Object>();
     }
     RegExpAtom* atom = parse_result.tree->AsAtom();
     if (atom != NULL && !flags.is_ignore_case()) {
       if (parse_result.has_character_escapes) {
         Vector<const uc16> atom_pattern = atom->data();
         Handle<String> atom_string =
             Factory::NewStringFromTwoByte(atom_pattern);
         result = AtomCompile(re, pattern, flags, atom_string);
       } else {
         result = AtomCompile(re, pattern, flags, pattern);
@@ skipping 1368 matching lines @@
   analysis.Analyze(node);
   return node;
 }
 
 
 RegExpMacroAssembler::~RegExpMacroAssembler() {
 }
 
 
 }}  // namespace v8::internal