alpha-linux-gnu-gcov-5 - онлайн у хмарі

ПРОГРАМА:

ІМ'Я

gcov - інструмент тестування покриття

СИНТАКСИС

gcov [-v|-- версія] [-h|--допомога]
[-a|--усі блоки]
[-b|--гілля-ймовірності]
[-c|--підрахунки філій]
[-d|--display-progress]
[-f|--Зведення функцій]
[-i|--проміжний формат]
[-l|-- довгі імена файлів]
[-m|--демонтовані імена]
[-n|--без виведення]
[-o|--об'єктний каталог каталог|файл]
[-p|--охоронні шляхи]
[-r|--лише відносно]
[-s|-- вихідний префікс каталог]
[-u|--безумовні-відгалуження]
файли

ОПИС

gcov є тестовою програмою покриття. Використовуйте його разом із GCC для аналізу ваших програм
допоможіть створювати більш ефективний та швидший код і відкривати неперевірені частини вашого
програма. Ви можете використовувати gcov як інструмент профілювання, який допоможе визначити, де ваша оптимізація
зусилля найкраще вплинуть на ваш код. Ви також можете використовувати gcov разом з іншим профілюванням
інструмент, гпроф, щоб оцінити, які частини вашого коду використовують найбільшу кількість обчислювального часу.

Інструменти профілювання допомагають аналізувати ефективність коду. Використовуючи профайлер, наприклад gcov
or гпроф, ви можете дізнатися деякі основні статистичні дані про ефективність, наприклад:

* як часто виконується кожен рядок коду

* які рядки коду насправді виконуються

* скільки обчислювального часу використовує кожен розділ коду

Коли ви дізнаєтеся про те, як працює ваш код під час компіляції, ви можете переглянути кожну
модуль, щоб побачити, які модулі слід оптимізувати. gcov допомагає визначити, де працювати
на оптимізацію.

Розробники програмного забезпечення також використовують тестування покриття разом із наборами тестів, щоб переконатися
програмне забезпечення насправді досить добре для випуску. Тестувальники можуть перевірити, що програма
працює як очікується; програма охоплення перевіряє, наскільки реалізовано програму
тестовий. Потім розробники можуть визначити, до яких типів тестових випадків потрібно додати
набори тестів, щоб створити як краще тестування, так і кращий кінцевий продукт.

Вам слід скомпілювати свій код без оптимізації, якщо ви плануєте використовувати gcov тому
оптимізація, об’єднання деяких рядків коду в одну функцію, може не дати вам стільки
інформації, оскільки вам потрібно шукати "гарячі точки", де код використовує велику кількість
комп'ютерний час. Так само, тому що gcov накопичує статистику по рядках (найменше
роздільна здатність), він найкраще працює зі стилем програмування, який містить лише один оператор для кожного
лінія. Якщо ви використовуєте складні макроси, які розширюються на цикли або інші структури керування,
статистика менш корисна --- вона повідомляє лише про рядок, де виконується макровиклик
з'являється. Якщо ваші складні макроси поводяться як функції, ви можете замінити їх на вбудовані
функції для вирішення цієї проблеми.

gcov створює файл журналу під назвою вихідний файл.gcov яка вказує, скільки разів кожен рядок
вихідний файл sourcefile.c виконав. Ви можете використовувати ці файли журналу разом із гпроф до
допомогти у тонкому налаштуванні продуктивності ваших програм. гпроф надає інформацію про час
можна використовувати разом з інформацією, яку ви отримуєте gcov.

gcov працює тільки з кодом, скомпільованим за допомогою GCC. Він не сумісний з будь-яким іншим профілюванням
або механізм тестового покриття.

ВАРІАНТИ

-h
--допомога
Відобразити довідку щодо використання gcov (на стандартному виводі) і вийдіть, не роблячи нічого
подальша обробка.

-v
-- версія
Відобразити gcov номер версії (на стандартному виводі) і вийти, не роблячи нічого
подальша обробка.

-a
--усі блоки
Запишіть індивідуальні лічби виконання для кожного основного блоку. Зазвичай gcov виводить
виконання враховується лише для основних блоків рядка. За допомогою цієї опції можна
визначити, чи не виконуються блоки в межах одного рядка.

-b
--гілля-ймовірності
Запишіть частоти розгалужень у вихідний файл і запишіть підсумкову інформацію про гілки до
стандартний вихід. Цей параметр дозволяє побачити, як часто кожна гілка у вашій програмі
було прийнято. Безумовні гілки не відображатимуться, якщо не буде -u надається варіант.

-c
--підрахунки філій
Запишіть частоти розгалужень як кількість розгалужень, а не відсоток
відібраних гілок.

-n
--без виведення
Не створюйте gcov вихідний файл.

-l
-- довгі імена файлів
Створіть довгі імена файлів для включених вихідних файлів. Наприклад, якщо файл заголовка xh
містить код і був включений у файл змінного струму, потім біг gcov на файл змінного струму
створить вихідний файл під назвою ac##xhgcov замість xhgcov. Це може бути
корисно, якщо xh включено до кількох вихідних файлів, і ви хочете побачити окрему
внески. Якщо ви використовуєте -p параметр, як включені, так і включені імена файлів
будуть повні імена шляхів.

-p
--охоронні шляхи
Збережіть повну інформацію про шлях в іменах згенерованих .gcov файлів. Без
цей параметр, використовується лише компонент імені файлу. За допомогою цього параметра всі каталоги
використовуються, с / символи, перекладені на # символів, . компоненти каталогу видалено
і незнімні .. компоненти перейменовані на ^. Це корисно, якщо є вихідні файли
кілька різних каталогів.

-r
--лише відносно
Виводити інформацію про вихідні файли лише з відносним ім’ям шляху (після джерела
префікс elision). Абсолютними шляхами зазвичай є файли заголовків системи та покриття будь-яких
вбудовані функції в ньому зазвичай нецікаві.

-f
--Зведення функцій
Вивести підсумки для кожної функції на додаток до підсумку рівня файлу.

-o каталог|файл
--об'єктний каталог каталог
--об'єктний файл файл
Вкажіть або каталог, що містить файли даних gcov, або ім’я шляху до об’єкта.
Команда .gcno та .gcda файли даних шукаються за допомогою цієї опції. Якщо каталог є
вказано, файли даних знаходяться в цьому каталозі та названі за ім’ям вхідного файлу,
без його розширення. Якщо тут вказано файл, файли даних мають ім’я
цей файл без його розширення.

-s каталог
-- вихідний префікс каталог
Префікс для імен вихідних файлів, які потрібно видалити під час створення вихідних файлів покриття.
Цей параметр корисний під час створення окремого каталогу та імені шляху до
вихідний каталог не потрібен при визначенні імен вихідних файлів. Зауважте, що це
Визначення префікса застосовується до визначення того, чи є вихідний файл абсолютним.

-u
--безумовні-відгалуження
Коли наведено ймовірності розгалужень, включіть ймовірності безумовних розгалужень.
Безумовні гілки зазвичай не цікаві.

-d
--display-progress
Відображення прогресу на стандартному виводі.

-i
--проміжний формат
Виведіть файл gcov у легкому для аналізу проміжному текстовому форматі, який можна використовувати lcov
або інші інструменти. Вихід одиничний .gcov файл за .gcda файл. Немає вихідного коду
вимагається.

Формат проміжного .gcov файл є звичайним текстом з одним записом на рядок

файл:
функція: , ,
lcount: ,
відділення: ,

Де є
notexec (гілка не виконується)
прийнято (Відділення виконано і забрано)
nottaken (Відгалуження виконано, але не зайнято)

Їх може бути кілька записи в проміжному gcov
файл. Усі записи після a стосуються цього вихідного файлу
до наступного вхід.

Ось зразок, коли -i використовується разом з -b опції:

файл: масив.cc
функція:11,1,_Z3sumRKSt6vectorIPiSaIS0_EE
функція:22,1,основна
Кількість: 11,1
Кількість: 12,1
Кількість: 14,1
відділення: 14, взято
Кількість: 26,1
відділення:28,не взято

-m
--демонтовані імена
Відображати вилучені назви функцій у виводі. За замовчуванням відображається зіпсована функція
імена.

gcov має запускатися з поточним каталогом, таким же, як і під час виклику
компілятор. Інакше він не зможе знайти вихідні файли. gcov створює файли
званий спотворене ім'я.gcov у поточному каталозі. Вони містять інформацію про покриття
вихідного файлу, якому вони відповідають. один .gcov файл створюється для кожного джерела (або
заголовок) файл, що містить код, який був скомпільований для створення файлів даних. The
спотворене ім'я Частина імені вихідного файлу зазвичай є просто ім'ям вихідного файлу, але може
бути чимось складнішим, якщо -l or -p надаються варіанти. Зверніться до цих варіантів
for details.

Якщо ви викликаєте gcov з кількома вхідними файлами внески з кожного вхідного файлу є
підсумовано. Зазвичай ви викликаєте його з тим же списком файлів, що й останнє посилання
ваш виконуваний файл.

Команда .gcov файли містять : розділені поля разом із вихідним кодом програми. Формат
is

: :

Додаткова інформація про блок може йти після кожного рядка, якщо запитується параметром командного рядка.
Команда кількість_виконань is - для рядків, які не містять коду. Невиконані рядки позначені #####
or ====, залежно від того, чи доступні вони невиключними шляхами чи тільки
виняткові шляхи, такі як обробники винятків C++, відповідно.

Деякі рядки інформації на початку мають номер_рядка з нуля. Ці рядки преамбули є
форми

-:0: :

Порядок і кількість цих рядків преамбули буде збільшено як gcov розробка
прогресує --- не покладайтеся на те, що вони залишаться незмінними. Використовуйте тег щоб знайти конкретне
рядок преамбули.

Додаткова інформація блоку має вигляд



Команда інформація читається людиною, але розроблено, щоб бути достатньо простим для машинного аналізу
теж.

Під час друку у відсотках 0% і 100% друкуються лише тоді, коли значення є точно 0% і
100% відповідно. Інші значення, які зазвичай округлюються до 0% або 100%.
натомість надруковано як найближче неграничне значення.

При використанні gcov, ви повинні спочатку скомпілювати вашу програму з двома спеціальними параметрами GCC:
-fprofile-arcs -ftest-покриття. Це повідомляє компілятору генерувати додаткові
інформацію, необхідну для gcov (в основному, блок-граф програми), а також включає
додатковий код в об’єктних файлах для створення необхідної додаткової інформації профілювання
від gcov. Ці додаткові файли розміщуються в каталозі, де знаходиться об’єктний файл
розташований.

Запуск програми призведе до створення виводу профілю. Для кожного вихідного файлу
складено з -fprofile-arcs, супровідний .gcda файл буде розміщено в об’єктному файлі
каталог.

Робота gcov з іменами вихідних файлів вашої програми в якості аргументів тепер буде створено список
коду разом із частотою виконання для кожного рядка. Наприклад, якщо ваша програма
це називається tmp.c, це те, що ви бачите, коли використовуєте основний gcov заклад:

$ gcc -fprofile-arcs -ftest-coverage tmp.c
$ a.out
$ gcov tmp.c
90.00% з 10 вихідних рядків виконано у файлі tmp.c
Створення tmp.c.gcov.

Файл tmp.c.gcov містить вихідні дані з gcov. Ось приклад:

-: 0: Джерело: tmp.c
-: 0: Графік: tmp.gcno
-: 0:Дані:tmp.gcda
-: 0: Виконує: 1
-: 0: Програми: 1
-: 1:#включати
-: 2:
-: 3:int main (недійсний)
1: 4: {
1: 5: int i, всього;
-: 6:
1: 7: всього = 0;
-: 8:
11: 9: для (i = 0; i < 10; i++)
10: 10: всього += i;
-: 11:
1: 12: якщо (всього != 45)
#####: 13: printf ("Збій\n");
-: 14: ще
1: 15: printf ("Успіх\n");
1: 16: повернення 0;
-: 17:}

При використанні -a опції, ви отримаєте кількість окремих блоків, а результат буде виглядати
подобається це:

-: 0: Джерело: tmp.c
-: 0: Графік: tmp.gcno
-: 0:Дані:tmp.gcda
-: 0: Виконує: 1
-: 0: Програми: 1
-: 1:#включати
-: 2:
-: 3:int main (недійсний)
1: 4: {
1: 4-блок 0
1: 5: int i, всього;
-: 6:
1: 7: всього = 0;
-: 8:
11: 9: для (i = 0; i < 10; i++)
11: 9-блок 0
10: 10: всього += i;
10: 10-блок 0
-: 11:
1: 12: якщо (всього != 45)
1: 12-блок 0
#####: 13: printf ("Збій\n");
$$$$$: 13-блок 0
-: 14: ще
1: 15: printf ("Успіх\n");
1: 15-блок 0
1: 16: повернення 0;
1: 16-блок 0
-: 17:}

У цьому режимі кожен основний блок відображається лише в одному рядку - останньому рядку блоку. А
багаторядковий блок сприятиме лише кількості виконання останнього рядка та інших
не буде показано, що рядки містять код, якщо попередні блоки не закінчуються на цих рядках. The
відображається загальна кількість виконання рядка, а наступні рядки показують кількість виконання
для окремих блоків, які закінчуються на цій лінії. Після кожного блоку зараховується розгалуження та виклик
блоку буде показано, якщо -b надається варіант.

Через те, як GCC інструментує виклики, кількість викликів може відображатися після рядка з номером
окремі блоки. Як бачите, рядок 13 містить базовий блок, який не був виконаний.

При використанні -b варіант, ваш вихід виглядає так:

$ gcov -b tmp.c
90.00% з 10 вихідних рядків виконано у файлі tmp.c
80.00% з 5 гілок виконано у файлі tmp.c
80.00% з 5 гілок, взятих хоча б один раз у файл tmp.c
50.00% з 2 викликів виконано у файлі tmp.c
Створення tmp.c.gcov.

Ось зразок отриманого tmp.c.gcov Файл:

-: 0: Джерело: tmp.c
-: 0: Графік: tmp.gcno
-: 0:Дані:tmp.gcda
-: 0: Виконує: 1
-: 0: Програми: 1
-: 1:#включати
-: 2:
-: 3:int main (недійсний)
функція main викликана 1 повернула 1 блоки виконано 75%
1: 4: {
1: 5: int i, всього;
-: 6:
1: 7: всього = 0;
-: 8:
11: 9: для (i = 0; i < 10; i++)
гілка 0 зайнято 91% (провал)
філія 1 взяла 9%
10: 10: всього += i;
-: 11:
1: 12: якщо (всього != 45)
гілка 0 зайнято 0% (провал)
філія 1 взяла 100%
#####: 13: printf ("Збій\n");
виклик 0 ніколи не виконувався
-: 14: ще
1: 15: printf ("Успіх\n");
дзвінок 0 дзвонив 1 повернув 100%
1: 16: повернення 0;
-: 17:}

Для кожної функції друкується рядок, який показує, скільки разів функція викликається, як
багато разів він повертає і який відсоток блоків функції було виконано.

Для кожного основного блоку рядок друкується після останнього рядка опису базового блоку
гілка або виклик, який завершує основний блок. Може бути кілька відділень і дзвінків
вказано для одного вихідного рядка, якщо є кілька основних блоків, які закінчуються на цьому рядку.
У цьому випадку кожному відділенням і викликам присвоюється номер. Немає простого способу
зіставте ці гілки та звернетеся до вихідних конструкцій. Загалом, правда, найнижчий
пронумерована гілка або виклик відповідатиме крайній лівій конструкції у вихідному рядку.

Для гілки, якщо вона була виконана хоча б один раз, то відсоток із зазначенням кількості
кількість разів, коли гілка була зайнята, поділена на кількість виконання гілки
друкований. В іншому випадку друкується повідомлення «ніколи не виконано».

Для виклику, якщо він був виконаний хоча б один раз, то відсоток із зазначенням кількості
поділено на кількість разів, коли виклик було виконано
друкований. Зазвичай це 100%, але може бути менше для функцій, які викликають "exit" або
"longjmp", і, таким чином, може не повертатися кожен раз, коли вони викликаються.

Кількість виконання кумулятивна. Якщо програма прикладу була повторно виконана без
видалення .gcda файл, кількість разів, коли кожен рядок у вихідному коді був
executed буде додано до результатів попереднього(их) запуску(ів). Це потенційно корисно
кількома способами. Наприклад, його можна використовувати для накопичення даних про декілька
Програма працює як частина набору тестової перевірки або для забезпечення більш точної довгострокової перевірки
інформацію про велику кількість запусків програми.

Дані в .gcda файли зберігаються безпосередньо перед закриттям програми. Для кожного
вихідний файл, скомпільований з -fprofile-arcs, код профілювання спочатку намагається прочитати файл
існуючий .gcda файл; якщо файл не відповідає виконуваному файлу (відрізняється кількість основних
кількість блоків) він ігнорує вміст файлу. Потім він додає нове виконання
підраховує і, нарешті, записує дані у файл.

використання gcov з GCC Оптимізація

Якщо ви плануєте використовувати gcov щоб допомогти оптимізувати свій код, ви повинні спочатку скомпілювати свою програму
з двома спеціальними параметрами GCC: -fprofile-arcs -ftest-покриття. Крім того, ви можете
використовувати будь-які інші параметри GCC; але якщо ви хочете довести, що кожен рядок у вашій програмі
було виконано, не слід компілювати з оптимізацією одночасно. На деяких машинах
оптимізатор може усунути деякі прості рядки коду, об'єднавши їх з іншими рядками.
Наприклад, такий код:

якщо (a != b)
c = 1;
ще
c = 0;

на деяких машинах можна зібрати в одну інструкцію. У цьому випадку немає можливості
gcov для обчислення окремої кількості виконання для кожного рядка, оскільки окремого немає
код для кожного рядка. Звідси gcov вихід виглядає так, якщо ви зібрали програму
з оптимізацією:

100: 12: якщо (a != b)
100: 13: c = 1;
100: 14: ще
100: 15: c = 0;

Вихід показує, що цей блок коду, об’єднаний оптимізацією, виконано 100 разів.
У певному сенсі цей результат правильний, оскільки була лише одна інструкція, що представляє
всі чотири ці рядки. Однак вихідні дані не вказують, у скільки разів результат
було 0 і скільки разів результат був 1.

Вбудовані функції можуть створювати неочікуваний підрахунок рядків. Кількість рядків показано для
вихідний код функції inlineable, але те, що буде показано, залежить від того, де знаходиться функція
inlined, або якщо він не вбудований взагалі.

Якщо функція не вбудована, компілятор повинен створити позарядкову копію
функцію у будь-якому об’єктному файлі, який потребує цього. Якщо файл A.o та fileB.o обидва містять з
тіла рядків певної функції, що не вбудовується, вони також будуть містити покриття
враховується для цієї функції. Коли файл A.o та fileB.o пов'язані разом, компонувальник буде,
у багатьох системах виберіть один із тих поза лінійних тіл для всіх викликів цієї функції,
і видалити або ігнорувати інше. На жаль, це не видалить лічильники покриття
для невикористаного тіла функції. Таким чином, коли інструментують, усі, крім одного, використовують цю функцію
покаже нульове значення.

Якщо функція вбудована в кількох місцях, структура блоків у кожному місці може
не бути таким же. Наприклад, умова тепер може бути обчислена під час компіляції в
деякі випадки. Тому що буде показано охоплення всіх видів використання вбудованої функції
для тих самих вихідних рядків самі підрахунки рядків можуть здаватися неузгодженими.

Довготривалі програми можуть використовувати засоби "_gcov_reset" і "_gcov_dump", щоб
обмежити збір профілів цікавим регіоном програми. Виклик "_gcov_reset(void)"
очищає всі лічильники профілю до нуля, а виклик "_gcov_dump(void)" призведе до
інформація профілю, зібрана в цей момент, щоб бути скинута .gcda вихідні файли.

Використовуйте alpha-linux-gnu-gcov-5 онлайн за допомогою служб onworks.net