Gdb में प्रोग्राम चलाने के लिए फ़ाइल से तर्क और पुनर्निर्देशन को कैसे पास करें?

Question

मैं आमतौर पर एक कार्यक्रम चलाता हूं:

./a.out arg1 arg2 <file

मैं इसे gdb का उपयोग करके डीबग करना चाहूंगा।

मुझे set argsकार्यक्षमता की जानकारी है , लेकिन यह केवल gdb प्रॉम्प्ट से काम करता है।

Answer 1

runकमांड को gdb के भीतर से पास करें ।

$ gdb ./a.out
(gdb) r < t
Starting program: /dir/a.out < t

Comments

rके लिए कम है runऔर आप किसी भी तर्क के साथ इसका पालन कर सकते हैं। इस प्रश्न की तरह, यह होगा: r arg1 arg2 <fileया यह हो सकता हैrun arg1 arg2 <file

— phyatt

मेरे लिए यह काम नहीं करता है। तब मैं करने की कोशिश की $ gdb ./a.outतो (gdb) r < t arg1 arg2जो मेरे लिए ठीक काम करता है। मेरे मामले में a.out = nft arg1 = import arg2 = json औरt = file containing json rules

— रहस्यमय

Answer 2

तुम यह केर सकते हो:

gdb --args path/to/executable -every -arg you can=think < of

जादू सा --args।

runडिबगिंग शुरू करने के लिए बस gdb कमांड कंसोल में टाइप करें ।

Comments

मुझे लगा कि मैं पहली बार में यह गलत पढ़ रहा था; अजीब है कि - शब्द निष्पादन योग्य होने से पहले चला जाता है। लेकिन ऐसा है!

— काओलिन फायर

@Kaolin - शब्द निष्पादन योग्य होने से पहले आना चाहिए क्योंकि यह gdb के लिए एक स्विच है। यदि यह बाद में आया, तो आप इसे डिबग करने वाले निष्पादन योग्य में पारित होने की इच्छा वाले तर्क से कैसे अलग होंगे?

— कोडिअप्पो

@codehippo: ठीक है, अगर आप निर्दिष्ट नहीं करते हैं --argsतो निष्पादन योग्य को पारित किए गए कोई तर्क नहीं हैं , इसलिए यह शायद ही अस्पष्ट है।

— ऑर्बिट

मैं यह अनुमान लगा रहा हूं, क्योंकि पारंपरिक रूप argv[0]से निष्पादन योग्य का नाम है

— क्लाउडियो

यह फ़ाइल में gdbस्वयं के इनपुट को रीडायरेक्ट करेगा ofऔर परिणाम देगा gdb इससे कमांड निष्पादित करने की कोशिश कर रहा है

— unkulunkulu

Answer 3

यदि आप अपने कार्यक्रम को पुनर्निर्देश और तर्कों के साथ निष्पादित करने के लिए नंगे runकमांड रखना चाहते हैं gdb, तो आप इसका उपयोग कर सकते हैं set args:

% gdb ./a.out
(gdb) set args arg1 arg2 <file
(gdb) run

मैं --argsपैरामीटर के साथ समान व्यवहार को प्राप्त करने में असमर्थ था , gdbजमकर पुनर्निर्देशन से बच जाता है, अर्थात

% gdb --args echo 1 2 "<file"
(gdb) show args
Argument list to give program being debugged when it is started is "1 2 \<file".
(gdb) run
...
1 2 <file
...

यह वास्तव में स्वयं gdb के इनपुट को पुनर्निर्देशित करता है, न कि हम वास्तव में यहाँ क्या चाहते हैं

% gdb --args echo 1 2 <file
zsh: no such file or directory: file

Answer 4

अपने प्रोजेक्ट पर GDB प्रारंभ करें।

1. प्रोजेक्ट डायरेक्टरी पर जाएं, जहां आपने पहले ही प्रोजेक्ट को एक्जीक्यूबल कर लिया है। आदेश gdb और निष्पादन योग्य का नाम नीचे के रूप में जारी करें:

   gdb projectExecutablename

यह gdb शुरू करता है, निम्नलिखित प्रिंट करता है: GNU gdb (Ubuntu 7.11.1-0ubuntu1 ~ 16.04) 7.11.1 कॉपीराइट (C) 2016 फ्री सॉफ्टवेयर फाउंडेशन, इंक। ............... .................................. "शब्द" से संबंधित आदेशों की खोज करने के लिए "एप्रोपोस शब्द" टाइप करें। पढ़ना। परियोजना से प्रतीक चिह्न। (Gdb)

2. इससे पहले कि आप अपना प्रोग्राम चालू करें, आप अपने ब्रेकप्वाइंट सेट करना चाहते हैं। ब्रेक कमांड आपको ऐसा करने की अनुमति देता है। मुख्य नाम के फ़ंक्शन की शुरुआत में एक ब्रेकपॉइंट सेट करने के लिए:

   (gdb) बी मुख्य

3. आपके पास (gdb) प्रॉम्प्ट होने के बाद, रन कमांड निष्पादन योग्य रनिंग शुरू करता है। यदि आप जिस प्रोग्राम में डिबगिंग कर रहे हैं, उसे किसी भी कमांड-लाइन तर्क की आवश्यकता होती है, तो आप उन्हें रन कमांड को निर्दिष्ट करते हैं। यदि आप "xfiles" फ़ाइल पर मेरा प्रोग्राम चलाना चाहते थे (जो कि प्रोजेक्ट डायरेक्टरी में "mulder" फ़ोल्डर में है), तो आप निम्नलिखित कार्य करेंगे:

   (gdb) r mulder / xfiles

उम्मीद है की यह मदद करेगा।

डिस्क्लेमर: यह समाधान मेरा नहीं है, यह https://web.stanford.edu/class/cs107/guide_gdb.html से अनुकूलित है। gdb के लिए यह संक्षिप्त मार्गदर्शिका थी, जो संभवतः स्टैनफोर्ड यूनिवर्सिटी में विकसित की गई थी।

Answer 5

debugकिसी भी कमांड के सामने टाइप करने के लिए अच्छा नहीं होगा कि इसके साथ डिबग किया जा सकेgdb शेल स्तर पर ?

इसके नीचे यह फ़ंक्शन है। यह निम्नलिखित के साथ भी काम करता है:

"$program" "$@" < <(in) 1> >(out) 2> >(two) 3> >(three)

यह एक ऐसी कॉल है जिसमें आप कुछ भी नियंत्रित नहीं कर सकते हैं, सब कुछ परिवर्तनशील है, इसमें रिक्त स्थान, लाइनफीड और शेल मेटाचैकर शामिल हो सकते हैं। इस उदाहरण में, in, out, two, औरthree मनमाने ढंग से अन्य आदेशों जो उपभोग या डेटा का उत्पादन जो नुकसान नहीं किया जाना चाहिए।

bashसमारोह के बाद gdbऐसे वातावरण में लगभग सफाई से आह्वान किया जाता है [ Gist ]:

debug()
{
  1000<&0 1001>&1 1002>&2 \
  0</dev/tty 1>/dev/tty 2>&0 \
  /usr/bin/gdb -q -nx -nw \
  -ex 'set exec-wrapper /bin/bash -c "exec 0<&1000 1>&1001 2>&1002 \"\$@\"" exec' \
  -ex r \
  --args "$@";
}

इसे लागू करने के तरीके पर उदाहरण: बस टाइप करें debug सामने :

इससे पहले:

p=($'\n' $'I\'am\'evil' "  yay  ")
"b u g" "${p[@]}" < <(in) 1> >(out) 2> >(two) 3> >(three)

उपरांत:

p=($'\n' $'I\'am\'evil' "  yay  ")
debug "b u g" "${p[@]}" < <(in) 1> >(out) 2> >(two) 3> >(three)

बस। अब इसके साथ डिबग करने के लिए एक निरपेक्ष नो-ब्रेनर है gdb। कुछ विवरण या अधिक को छोड़कर:

• gdbस्वचालित रूप से बाहर नहीं निकलता है और इसलिए IO पुनर्निर्देशन को तब तक खुला रखता है जब तक आप बाहर नहीं निकल जाते gdb। लेकिन मैं इसे एक सुविधा कहता हूं।

• आप आसानी argv0से इस तरह से कार्यक्रम को पास नहीं कर सकते exec -a arg0 command args। के बाद: इस चाल करना चाहिए के बाद exec-wrapperपरिवर्तन "execकरने के लिए"exec -a \"\${DEBUG_ARG0:-\$1}\" ।

• 1000 से ऊपर एफडी हैं, जो सामान्य रूप से बंद हैं। यदि यह एक समस्या है, तो 0<&1000 1>&1001 2>&1002पढ़ने के लिए बदलें0<&1000 1>&1001 2>&1002 1000<&- 1001>&- 1002>&-

• आप समानांतर में दो डीबगर नहीं चला सकते हैं। कुछ अन्य कमांड उपभोग /dev/tty(या STDIN) होने पर भी समस्याएँ हो सकती हैं । इसे ठीक करने के लिए, के /dev/ttyसाथ बदलें "${DEBUGTTY:-/dev/tty}"। किसी अन्य TTY प्रकार में tty; sleep infऔर फिर /dev/pts/60डीबगिंग के लिए मुद्रित TTY (i। E. ) का उपयोग करें , जैसे कि DEBUGTTY=/dev/pts/60 debug command arg..। यह पॉवर ऑफ शेल है, इसकी आदत डाल लें!

समझाया गया कार्य:

• 1000<&0 1001>&1 1002>&2 पहले 3 एफडी दूर ले जाता है
  • यह मानता है, कि एफडी 1000, 1001 और 1002 मुफ्त हैं
• 0</dev/tty 1>/dev/tty 2>&0अपने वर्तमान TTY को इंगित करने के लिए पहले 3 FD को पुनर्स्थापित करता है। तो आप नियंत्रण कर सकते हैं gdb।
• /usr/bin/gdb -q -nx -nwचलाता है gdbinvokes gdbखोल पर
• -ex 'set exec-wrapper /bin/bash -c "exec 0<&1000 1>&1001 2>&1002 \"\$@\"" एक स्टार्टअप रैपर बनाता है, जो पहले 3 एफडी को पुनर्स्थापित करता है जो 1000 और उससे अधिक बचाए गए थे
• -ex r का उपयोग कर कार्यक्रम शुरू करता है exec-wrapper
• --args "$@" दिए गए तर्कों को पारित करता है

यह इतना आसान नहीं था?