GNU bug report logs - #22149
stack overflow in regexp matcher

Previous Next

Package: emacs;

Reported by: Cheng-An Yang <rhymer123 <at> gmail.com>

Date: Sat, 12 Dec 2015 06:32:01 UTC

Severity: normal

Tags: confirmed

Found in versions 24.4, 25.0.95

Fixed in version 28.1

Done: Mattias Engdegård <mattiase <at> acm.org>

Bug is archived. No further changes may be made.

To add a comment to this bug, you must first unarchive it, by sending
a message to control AT debbugs.gnu.org, with unarchive 22149 in the body.
You can then email your comments to 22149 AT debbugs.gnu.org in the normal way.

Toggle the display of automated, internal messages from the tracker.

View this report as an mbox folder, status mbox, maintainer mbox


Report forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Sat, 12 Dec 2015 06:32:01 GMT) Full text and rfc822 format available.

Acknowledgement sent to Cheng-An Yang <rhymer123 <at> gmail.com>:
New bug report received and forwarded. Copy sent to bug-gnu-emacs <at> gnu.org. (Sat, 12 Dec 2015 06:32:01 GMT) Full text and rfc822 format available.

Message #5 received at submit <at> debbugs.gnu.org (full text, mbox):

From: Cheng-An Yang <rhymer123 <at> gmail.com>
To: bug-gnu-emacs <at> gnu.org
Subject: 24.4; gdb stack overflow in regexp matcher
Date: Fri, 11 Dec 2015 22:16:35 -0800
[Message part 1 (text/plain, inline)]
From: Rhymer Yang <rhymer123 <at> gmail.com>
To: bug-gnu-emacs <at> gnu.org
Subject: 24.4; gdb stack overflow in regexp matcher
--text follows this line--

Hello,

I am using Emacs GDB Graphical Interface to debug a large C++ project.
When I stop at certain functions, it breaks the GDB interface with the
error message "Stack overflow in regexp matcher".

I did some google search and found that quite a few people also have
this problem. However, it's not clear how to solve the problem. Any
suggestions? Thanks!

Best,
Rhymer

Here are the output from backtrace:

Debugger entered--Lisp error: (error "Stack overflow in regexp matcher")
  string-match("\\([~@&]\\)\\(\"\\(?:[^\\\"]\\|\\\\.\\)*\"\\)\n" "~\"5
  breakpoint     keep y   0x00002aaac4d594fa in
SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&, std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > >,
std::allocator<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > > > >*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&,
std::vector<std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >,
std::allocator<std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::vector<finite::Finite, std::allocator<finite::Finite> >,
unsigned int, bool, std::vector<int, std::allocator<int> >,
std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > >, std::vector<int,
std::allocator<int> >, std::vector<unsigned int, std::allocator<unsigned
int> > const&, std::vector<unsigned int, std::allocator<unsigned int> >
const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >,
finite::Finite, std::vector<bool, std::allocator<bool> >, unsigned int,
unsigned int, bool, bool, std::vector<bool, std::allocator<bool> > const*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > const*, unsigned int, bool,
std::vector<std::vector<std::vector<unsigned int, std::allocator<unsigned
int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned
int> > > >, std::allocator<std::vector<std::vector<unsigned int,
std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int,
std::allocator<unsigned int> > > > > > const*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const*) at
points/apple/rx_hw/VP/ETC_VP_Frontend.cpp:4520\\n\"\n^done\n(gdb)
\n146^done,frame={level=\"0\",addr=\"0x00002aaabc5d80ff\",func=\"ETC_EU::EU_PSD::scheduleAllDecode\",file=\"points/apple/psd/eu_psd.cpp\",fullname=\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/psd/eu_psd.cpp\",line=\"13346\"}\n(gdb)
\n147^done,threads=[{id=\"1\",target-id=\"Thread 0x2aaad0e72a20 (LWP
590)\",name=\"sim_apple.LGD.\",frame={level=\"0\",addr=\"0x00002aaabc5d80ff\",func=\"ETC_EU::EU_PSD::scheduleAllDecode\",args=[{name=\"this\",value=\"0x55560d500e40\"}],file=\"points/apple/psd/eu_psd.cpp\",fullname=\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/psd/eu_psd.cpp\",line=\"13346\"},state=\"stopped\",core=\"7\"}],current-thread-id=\"1\"\n(gdb)
\n148^done,BreakpointTable={nr_rows=\"1\",nr_cols=\"6\",hdr=[{width=\"7\",alignment=\"-1\",col_name=\"number\",colhdr=\"Num\"},{width=\"14\",alignment=\"-1\",col_name=\"type\",colhdr=\"Type\"},{width=\"4\",alignment=\"-1\",col_name=\"disp\",colhdr=\"Disp\"},{width=\"3\",alignment=\"-1\",col_name=\"enabled\",colhdr=\"Enb\"},{width=\"18\",alignment=\"-1\",col_name=\"addr\",colhdr=\"Address\"},{width=\"40\",alignment=\"2\",col_name=\"what\",colhdr=\"What\"}],body=[bkpt={number=\"5\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0x00002aaac4d594fa\",func=\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&, std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > >,
std::allocator<std::vector<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > >,
std::allocator<std::vector<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> >,
std::allocator<std::vector<BlockCEParameter_class,
std::allocator<BlockCEParameter_class> > > > > > > >*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&,
std::vector<std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > >,
std::allocator<std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > > >&,
std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::vector<finite::Finite, std::allocator<finite::Finite> >,
unsigned int, bool, std::vector<int, std::allocator<int> >,
std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > >, std::vector<int,
std::allocator<int> >, std::vector<unsigned int, std::allocator<unsigned
int> > const&, std::vector<unsigned int, std::allocator<unsigned int> >
const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > > > > const&,
std::vector<std::vector<bool, std::allocator<bool> >,
std::allocator<std::vector<bool, std::allocator<bool> > > >,
finite::Finite, std::vector<bool, std::allocator<bool> >, unsigned int,
unsigned int, bool, bool, std::vector<bool, std::allocator<bool> > const*,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > const*, unsigned int, bool,
std::vector<std::vector<std::vector<unsigned int, std::allocator<unsigned
int> >, std::allocator<std::vector<unsigned int, std::allocator<unsigned
int> > > >, std::allocator<std::vector<std::vector<unsigned int,
std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int,
std::allocator<unsigned int> > > > > > const*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >
const*)\",file=\"points/apple/rx_hw/VP/ETC_VP_Frontend.cpp\",fullname=\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/rx_hw/VP/ETC_VP_Frontend.cpp\",line=\"4520\",times=\"0\",original-location=\"ETC_VP_Frontend.cpp:4520\"}]}\n(gdb)
\n149^done,locals=[{name=\"pucch_reporting_type\",type=\"std::vector<unsigned
int, std::allocator<unsigned int>
>\"},{name=\"rnnBias_DualDecode\",type=\"double\",value=\"6.9533558070642619e-310\"},{name=\"subframeNumMod\",type=\"const
int\",value=\"10922\"},{name=\"CSF_CON_printed\",type=\"bool\",value=\"true\"},{name=\"CSF_report_exist\",type=\"std::vector<bool,
std::allocator<bool> >\"},{name=\"useCSF_L0\",type=\"const
bool\",value=\"true\"},{name=\"enforceTM10Schedule\",type=\"bool\",value=\"false\"},{name=\"NumSymbPerSlot\",type=\"uint\",value=\"32767\"},{name=\"__PRETTY_FUNCTION__\",type=\"const
char [40]\"},{name=\"chan_type\",type=\"std::vector<unsigned int,
std::allocator<unsigned int>
>\"},{name=\"doCSF_Proc_DualDecode\",type=\"bool\",value=\"false\"},{name=\"scheduledCSF\",type=\"std::vector<std::vector<std::vector<bool,
std::allocator<bool> >, std::allocator<std::vector<bool,
std::allocator<bool> > > >, std::allocator<std::vector<std::vector<bool,
std::allocator<bool> >, std::allocator<std::vector<bool,
std::allocator<bool> > > > >
>\"},{name=\"isDLSubframe\",type=\"bool\",value=\"208\"},{name=\"total_subframe_num\",type=\"std::vector<unsigned
long long, std::allocator<unsigned long long>
>\"},{name=\"bwp_index\",type=\"std::vector<std::vector<unsigned int,
std::allocator<unsigned int> >, std::allocator<std::vector<unsigned int,
std::allocator<unsigned int> > >
>\"},{name=\"sched_pusch_csf\",type=\"std::vector<bool,
std::allocator<bool>
>\"},{name=\"issue_SCHED_MSG\",type=\"std::vector<bool,
std::allocator<bool>
>\"},{name=\"interfBias_DualDecode\",type=\"std::vector<double,
std::allocator<double>
>\"},{name=\"pmchEnabledThisSF\",type=\"bool\",value=\"181\"},{name=\"lastSyminSF\",type=\"bool\",value=\"110\"}]\n(gdb)
\n150^done,stack=[frame={level=\"0\",addr=\"0x00002aaabc5d80ff\",func=\"ETC_EU::EU_PSD::scheduleAllDecode\",file=\"points/apple/psd/eu_psd.cpp\",fullname=\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/psd/eu_psd.cpp\",line=\"13346\"},frame={level=\"1\",addr=\"0x00002aaabc59696f\",func=\"ETC_EU::EU_PSD::Update\",file=\"points/apple/psd/eu_psd.cpp\",fullname=\"/prj/qct/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/psd/eu_psd.cpp\",line=\"5530\"},frame={level=\"2\",addr=\"0x00002aaac7b3ea55\",func=\"ETC_EU::EU::RxxRUpdate\",file=\"points/apple/top/ue.cpp\",fullname=\"/apple/users/usery/Simu/sim_apple/points/apple/top/ue.cpp\",line=\"1273\"},frame={level=\"3\",addr=\"0x00002aaac7b3ce40\",func=\"ETC_EU::EU::Update\",file=\"points/apple/top/ue.cpp\",fullname=\"/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/top/ue.cpp\",line=\"1036\"},frame={level=\"4\",addr=\"0x00002aaacf258e96\",func=\"wiltsim::WiltSimTop_class::AdvanceSim\",file=\"wiltsim/sim/top/WiltSimTop.cpp\",fullname=\"/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/wiltsim/sim/top/WiltSimTop.cpp\",line=\"168\"},frame={level=\"5\",addr=\"0x00002aaacf97834e\",func=\"main\",file=\"wiltsim/sim/main/main.cpp\",fullname=\"/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/wiltsim/sim/main/main.cpp\",line=\"45\"},frame={level=\"6\",addr=\"0x00002aaad07fdc36\",func=\"__libc_start_main\",from=\"/lib64/libc.so.6\"},frame={level=\"7\",addr=\"0x000055555556b2e9\",func=\"_start\",file=\"../sysdeps/x86_64/elf/start.S\",line=\"103\"}]\n(gdb)
\n^running\n*running,thread-id=\"1\"\n(gdb)
\n*stopped,reason=\"end-stepping-range\",frame={addr=\"0x00002aaabc5d8121\",func=\"ETC_EU::EU_PSD::scheduleAllDecode\",args=[{name=\"this\",value=\"0x55560d500e40\"}],file=\"points/apple/psd/eu_psd.cpp\",fullname=\"/abc/def/etc-sys/apple/users/usery/Simu/sim_apple/points/apple/psd/eu_psd.cpp\",line=\"13348\"},thread-id=\"1\",stopped-threads=[\"1\"],core=\"5\"\n~\"Continuing.\\n\"\n^running\n*running,thread-id=\"1\"\n(gdb)
\n=breakpoint-modified,bkpt={number=\"5\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0x00002aaac4d594fa\",func=\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve" 0)
  gdbmi-bnf-stream-record()
  gdbmi-bnf-out-of-band-record()
  gdbmi-bnf-output()
  #[0 " \300W\205 \n \205 \202  \207" [42969 gdbmi-bnf-offset
gdbmi-bnf-state] 2 "\n\n(fn)"]()
  funcall(#[0 " \300W\205 \n \205 \202  \207" [42969 gdbmi-bnf-offset
gdbmi-bnf-state] 2 "\n\n(fn)"])

gud-gdbmi-marker-fietcr("=breakpoint-modified,bkpt={number=\"5\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0x00002aaac4d594fa\",func=\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")
  apply(gud-gdbmi-marker-fietcr
"=breakpoint-modified,bkpt={number=\"5\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0x00002aaac4d594fa\",func=\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")

gud-marker-fietcr("=breakpoint-modified,bkpt={number=\"5\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0x00002aaac4d594fa\",func=\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")
  gud-fietcr(#<process gud-sim_apple.LGD.bin>
"=breakpoint-modified,bkpt={number=\"5\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0x00002aaac4d594fa\",func=\"SIMULATION_VP::ETC_VP_Frontend::chanDecodeComputing(boost::shared_ptr<SIMULATION_VP::ETC_V1_DEC_CON>,
std::vector<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > > >*,
std::vector<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > >,
std::allocator<std::vector<std::vector<finite::complexx,
std::allocator<finite::complexx> >,
std::allocator<std::vector<finite::complexx,
std::allocator<finite::complexx> > > > > > const&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >&,
std::vector<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > >, std::allocator<std::vector<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> >, std::allocator<std::vector<std::vector<finite::Finite,
std::allocator<finite::Finite> >,
std::allocator<std::vector<finite::Finite, std::allocator<finite::Finite> >
> > > > > >&, std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >&,
std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >&, std::vector<unsigned int,
std::allocator<unsigned int> >, std::vector<std::vector<std::vector<int,
std::allocator<int> >, std::allocator<std::vector<int, std::allocator<int>
> > >, std::allocator<std::vector<std::vector<int, std::allocator<int> >,
std::allocator<std::vector<int, std::allocator<int> > > > > >,
std::vector<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > >,
std::allocator<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >,
std::allocator<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> > > > > >,
std::allocator<std::vector<std::vector<std::vector<finite::complexFinite,
std::allocator<finite::complexFinite> >, std::allocator<std::ve")




In GNU Emacs 24.4.1 (x86_64-unknown-linux-gnu, GTK+ Version 2.18.9)
 of 2014-11-15 on vl-nbharadw-gridsdca
Windowing system distributor `The X.Org Foundation', version 11.0.11202000
System Description: SUSE Linux Enterprise Server 11 (x86_64)

Configured using:
 `configure --prefix=/pkg/software/emacs/24.4/sles11 --without-rsvg'

Important settings:
  value of $LANG: en_US.UTF-8
  value of $XMODIFIERS: @im=local
  locale-coding-system: utf-8-unix

Major mode: Debugger

Minor modes in effect:
  global-semanticdb-minor-mode: t
  global-semantic-idle-scheduler-mode: t
  global-semantic-idle-summary-mode: t
  global-semantic-stickyfunc-mode: t
  semantic-mode: t
  clean-aindent-mode: t
  show-smartparens-global-mode: t
  yas-global-mode: t
  yas-minor-mode: t
  gdb-many-windows: t
  projectile-global-mode: t
  projectile-mode: t
  helm-descbinds-mode: t
  helm-mode: t
  shell-dirtrack-mode: t
  recentf-mode: t
  winner-mode: t
  window-numbering-mode: t
  volatile-highlights-mode: t
  global-vi-tilde-fringe-mode: t
  vi-tilde-fringe-mode: t
  global-undo-tree-mode: t
  undo-tree-mode: t
  savehist-mode: t
  popwin-mode: t
  global-page-break-lines-mode: t
  Info-breadcrumbs-in-mode-line-mode: t
  ido-vertical-mode: t
  flx-ido-mode: t
  eyebrowse-mode: t
  global-evil-surround-mode: t
  evil-surround-mode: t
  global-evil-search-highlight-persist: t
  evil-search-highlight-persist: t
  evil-jumper-mode: t
  evil-escape-mode: t
  global-anzu-mode: t
  anzu-mode: t
  eval-sexp-fu-flash-mode: t
  global-diff-hl-mode: t
  diff-auto-refine-mode: t
  global-hl-line-mode: t
  xterm-mouse-mode: t
  global-auto-revert-mode: t
  evil-leader-mode: t
  evil-mode: t
  evil-local-mode: t
  which-key-mode: t
  override-global-mode: t
  spacemacs-additional-leader-mode: t
  electric-indent-mode: t
  mouse-wheel-mode: t
  file-name-shadow-mode: t
  global-font-lock-mode: t
  font-lock-mode: t
  auto-composition-mode: t
  auto-encryption-mode: t
  auto-compression-mode: t
  buffer-read-only: t
  column-number-mode: t
  line-number-mode: t
  transient-mark-mode: t

Recent messages:
error in process fietcr: gdbmi-bnf-stream-record: Stack overflow in regexp
matcher
error in process fietcr: Stack overflow in regexp matcher
Mark set
Debug on Error enabled globally
debug-on-error enabled.
Entering debugger...
debugger-frame-number: This line is not a function call
command-execute: Buffer is read-only: #<buffer *Backtrace*> [2 times]
debugger-frame-number: This line is not a function call
Quit

Memory information:
((conses 16 2563016 1021331)
 (symbols 48 64059 16)
 (miscs 40 12883 3188)
 (strings 32 349590 287677)
 (string-bytes 1 17342091)
 (vectors 16 152172)
 (vector-slots 8 4020213 1448882)
 (floats 8 15298 10001)
 (intervals 56 28898 15957)
 (buffers 960 44)
 (heap 1024 184239 72761))
[Message part 2 (text/html, inline)]

Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Sat, 12 Dec 2015 10:14:02 GMT) Full text and rfc822 format available.

Message #8 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Andreas Schwab <schwab <at> linux-m68k.org>
To: Cheng-An Yang <rhymer123 <at> gmail.com>
Cc: 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Sat, 12 Dec 2015 11:13:13 +0100
Cheng-An Yang <rhymer123 <at> gmail.com> writes:

> I am using Emacs GDB Graphical Interface to debug a large C++ project.
> When I stop at certain functions, it breaks the GDB interface with the
> error message "Stack overflow in regexp matcher".

I cannot reproduce that error with Emacs 24.5 when evaluating the
string-match from the backtrace.

Andreas.

-- 
Andreas Schwab, schwab <at> linux-m68k.org
GPG Key fingerprint = 58CA 54C7 6D53 942B 1756  01D3 44D5 214B 8276 4ED5
"And now for something completely different."




Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Fri, 01 Jul 2016 03:17:01 GMT) Full text and rfc822 format available.

Message #11 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: npostavs <at> users.sourceforge.net
To: Andreas Schwab <schwab <at> linux-m68k.org>
Cc: Cheng-An Yang <rhymer123 <at> gmail.com>, 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Thu, 30 Jun 2016 23:16:38 -0400
[Message part 1 (text/plain, inline)]
tags 22149 confirmed
found 22149 25.0.95
retitle 22149 stack overflow in regexp matcher
quit

Andreas Schwab <schwab <at> linux-m68k.org> writes:

> Cheng-An Yang <rhymer123 <at> gmail.com> writes:
>
>> I am using Emacs GDB Graphical Interface to debug a large C++ project.
>> When I stop at certain functions, it breaks the GDB interface with the
>> error message "Stack overflow in regexp matcher".
>
> I cannot reproduce that error with Emacs 24.5 when evaluating the
> string-match from the backtrace.

I'm able to reproduce with both 24.5 and 25.0.95.  Attaching testcase as
el file to avoid ambiguity.  Run as

    emacs -Q -l bug-22149-regexp-overflow.el

I'm entirely sure why this regexp triggers an overflow, but one that
doesn't trigger overflow, and I think should match the same is:

    "\\([~@&]\\)\\(\"\\(?:\\\\\"\\|[^\"]\\)*\"\\)\n"

[bug-22149-regexp-overflow.el (application/emacs-lisp, attachment)]

Added tag(s) confirmed. Request was from npostavs <at> users.sourceforge.net to control <at> debbugs.gnu.org. (Fri, 01 Jul 2016 03:17:02 GMT) Full text and rfc822 format available.

bug Marked as found in versions 25.0.95. Request was from npostavs <at> users.sourceforge.net to control <at> debbugs.gnu.org. (Fri, 01 Jul 2016 03:17:02 GMT) Full text and rfc822 format available.

Changed bug title to 'stack overflow in regexp matcher' from '24.4; gdb stack overflow in regexp matcher' Request was from npostavs <at> users.sourceforge.net to control <at> debbugs.gnu.org. (Fri, 01 Jul 2016 03:17:02 GMT) Full text and rfc822 format available.

Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Fri, 13 Mar 2020 18:59:01 GMT) Full text and rfc822 format available.

Message #20 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Mattias Engdegård <mattiase <at> acm.org>
To: Noam Postavsky <npostavs <at> gmail.com>
Cc: Andreas Schwab <schwab <at> suse.de>, Cheng-An Yang <rhymer123 <at> gmail.com>,
 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Fri, 13 Mar 2020 19:58:23 +0100
[Message part 1 (text/plain, inline)]
This was a while ago, but the effect can still be observed in current master (28.0.50). The exact reproduction no longer works but it's probably just a quantitive change; perhaps the regexp stack has become bigger.

Simplified, and with some character renaming for clarity, the test case is essentially

(string-match (rx "t"
                  (* (or (not (any "bq"))
                         (: "b" nonl)))
                  "q")
              (concat "t" (make-string 160000 ?a)))

where the number 160000 can be lowered a bit to avoid the stack overflow.

One way of dodging the error regardless of string size is to swap the two 'or' operands, so that the (: "b" nonl) part, which usually fails, is attempted first. This is because the NFA matcher implements a kind of TCO: no backtrack point on the stack is needed for the last or-clause.

In fact, Noam's proposed workaround, equivalent to

(string-match (rx "t"
                  (* (or "bq" (not "b")))
                  "q")
              (concat "t" (make-string 160000 ?a)))

works precisely for this reason -- swapping the or-clauses here gives a stack overflow again.

What about this patch for Emacs 27?

[0001-Avoid-regexp-stack-overflow-in-GDB-string-matching-b.patch (application/octet-stream, attachment)]

Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Fri, 13 Mar 2020 19:40:02 GMT) Full text and rfc822 format available.

Message #23 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Mattias Engdegård <mattiase <at> acm.org>
Cc: schwab <at> suse.de, rhymer123 <at> gmail.com, npostavs <at> gmail.com,
 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Fri, 13 Mar 2020 21:39:21 +0200
> From: Mattias Engdegård <mattiase <at> acm.org>
> Date: Fri, 13 Mar 2020 19:58:23 +0100
> Cc: Andreas Schwab <schwab <at> suse.de>, Cheng-An Yang <rhymer123 <at> gmail.com>,
>  22149 <at> debbugs.gnu.org
> 
> What about this patch for Emacs 27?

I don't understand what that does to fix the problem, and don't really
see why it would be urgent to fix in Emacs 27.  Can you explain?




Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Fri, 13 Mar 2020 20:12:02 GMT) Full text and rfc822 format available.

Message #26 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Mattias Engdegård <mattiase <at> acm.org>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: schwab <at> suse.de, rhymer123 <at> gmail.com, npostavs <at> gmail.com,
 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Fri, 13 Mar 2020 21:11:05 +0100
13 mars 2020 kl. 20.39 skrev Eli Zaretskii <eliz <at> gnu.org>:

> I don't understand what that does to fix the problem, and don't really
> see why it would be urgent to fix in Emacs 27.  Can you explain?

It's not urgent, but it is a bug that gdb-mi crashes with a regexp stack overflow for certain strings.
What the patch does is replacing the regexp fragment

 (* (or (not (any ?\" ?\\))
        (seq ?\\ nonl)))

with

 (* (or (seq ?\\ nonl)
        (not (any ?\" ?\\))))

Ie, try the least likely branch first (backslash-escaped char) in the inner loop, so that the successful branch is last and won't grow the regexp stack.

The effect is readily seen in an even simpler example:

 (string-match "^\\(?:a\\|b\\)*c" (make-string 160000 ?a))

crashes, but

 (string-match "^\\(?:b\\|a\\)*c" (make-string 160000 ?a))

works (ie, fails to match).

It was suggested for Emacs 27 since it's a known bug with a simple solution. Then again, it's not a regression from a recent release.





Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Sat, 14 Mar 2020 07:59:02 GMT) Full text and rfc822 format available.

Message #29 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Mattias Engdegård <mattiase <at> acm.org>
Cc: schwab <at> suse.de, rhymer123 <at> gmail.com, npostavs <at> gmail.com,
 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Sat, 14 Mar 2020 09:58:39 +0200
> From: Mattias Engdegård <mattiase <at> acm.org>
> Date: Fri, 13 Mar 2020 21:11:05 +0100
> Cc: npostavs <at> gmail.com, schwab <at> suse.de, rhymer123 <at> gmail.com,
>         22149 <at> debbugs.gnu.org
> 
> It was suggested for Emacs 27 since it's a known bug with a simple solution. Then again, it's not a regression from a recent release.

Let's install this this on master, then.  The use cases which trigger
the problem are rare enough to not be too urgent to fix.  Moreover, we
might decide, for different reasons, to bump up the stack size of the
Emacs binary, which will indirectly fix this problem by making it less
probable.

Thanks.




Reply sent to Mattias Engdegård <mattiase <at> acm.org>:
You have taken responsibility. (Sat, 14 Mar 2020 09:05:01 GMT) Full text and rfc822 format available.

Notification sent to Cheng-An Yang <rhymer123 <at> gmail.com>:
bug acknowledged by developer. (Sat, 14 Mar 2020 09:05:02 GMT) Full text and rfc822 format available.

Message #34 received at 22149-done <at> debbugs.gnu.org (full text, mbox):

From: Mattias Engdegård <mattiase <at> acm.org>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: 22149-done <at> debbugs.gnu.org, Cheng-An Yang <rhymer123 <at> gmail.com>,
 Noam Postavsky <npostavs <at> gmail.com>, Andreas Schwab <schwab <at> suse.de>
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Sat, 14 Mar 2020 10:04:38 +0100
14 mars 2020 kl. 08.58 skrev Eli Zaretskii <eliz <at> gnu.org>:

> Let's install this this on master, then.  The use cases which trigger
> the problem are rare enough to not be too urgent to fix.

All right, master it is!

>  Moreover, we
> might decide, for different reasons, to bump up the stack size of the
> Emacs binary, which will indirectly fix this problem by making it less
> probable.

I'm not sure how the C and regexp engine stacks relate to each other in practice -- main() attempts to grow the C stack to accommodate the maximal regexp stack, but SAFE_ALLOCA is set up to use the heap when necessary. Surely we could decouple them more or less entirely, since the extra cost for malloc is bound to be small when a lot of regexp stack is needed.






Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Sat, 14 Mar 2020 10:15:02 GMT) Full text and rfc822 format available.

Message #37 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Eli Zaretskii <eliz <at> gnu.org>
To: Mattias Engdegård <mattiase <at> acm.org>
Cc: schwab <at> suse.de, rhymer123 <at> gmail.com, npostavs <at> gmail.com,
 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Sat, 14 Mar 2020 12:14:24 +0200
> From: Mattias Engdegård <mattiase <at> acm.org>
> Date: Sat, 14 Mar 2020 10:04:38 +0100
> Cc: Noam Postavsky <npostavs <at> gmail.com>, 22149-done <at> debbugs.gnu.org,
>         Andreas Schwab <schwab <at> suse.de>, Cheng-An Yang <rhymer123 <at> gmail.com>
> 
> 14 mars 2020 kl. 08.58 skrev Eli Zaretskii <eliz <at> gnu.org>:
> 
> >  Moreover, we
> > might decide, for different reasons, to bump up the stack size of the
> > Emacs binary, which will indirectly fix this problem by making it less
> > probable.
> 
> I'm not sure how the C and regexp engine stacks relate to each other in practice -- main() attempts to grow the C stack to accommodate the maximal regexp stack, but SAFE_ALLOCA is set up to use the heap when necessary. Surely we could decouple them more or less entirely, since the extra cost for malloc is bound to be small when a lot of regexp stack is needed.

I think regex-emacs.c already overrides some of the SAFE_ALLOCA
machinery to that effect, does it not?




Information forwarded to bug-gnu-emacs <at> gnu.org:
bug#22149; Package emacs. (Sat, 14 Mar 2020 10:44:02 GMT) Full text and rfc822 format available.

Message #40 received at 22149 <at> debbugs.gnu.org (full text, mbox):

From: Mattias Engdegård <mattiase <at> acm.org>
To: Eli Zaretskii <eliz <at> gnu.org>
Cc: schwab <at> suse.de, rhymer123 <at> gmail.com, npostavs <at> gmail.com,
 22149 <at> debbugs.gnu.org
Subject: Re: bug#22149: 24.4; gdb stack overflow in regexp matcher
Date: Sat, 14 Mar 2020 11:43:38 +0100
14 mars 2020 kl. 11.14 skrev Eli Zaretskii <eliz <at> gnu.org>:

> I think regex-emacs.c already overrides some of the SAFE_ALLOCA
> machinery to that effect, does it not?

It uses its own limits, but the mechanism appears to be unchanged. I wonder how important the stack-growing effort in main() really is for regexp performance.





bug Marked as fixed in versions 28.1. Request was from Noam Postavsky <npostavs <at> gmail.com> to control <at> debbugs.gnu.org. (Sun, 22 Mar 2020 15:00:03 GMT) Full text and rfc822 format available.

bug archived. Request was from Debbugs Internal Request <help-debbugs <at> gnu.org> to internal_control <at> debbugs.gnu.org. (Mon, 20 Apr 2020 11:24:07 GMT) Full text and rfc822 format available.

This bug report was last modified 5 years and 59 days ago.

Previous Next


GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997,2003 nCipher Corporation Ltd, 1994-97 Ian Jackson.