27009203599

Committed 05 Jun 2026 10:17AM UTC coverage: 18.437%. First build

Build # 27009203599

Build Type

Pull #352

github

Committed by

web-flow

Commit Message

Merge 93add864a into a4a7a5cb6

Pull Request Pull Request #352: fix: update logger types and improve error logging messages

Coverage Stats

7268 of 53566 branches covered (13.57%)

Branch coverage included in aggregate %.

380 of 702 new or added lines in 31 files covered. (54.13%)

4776 of 11760 relevant lines covered (40.61%)

1107.23 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

14.72

/src/dftracer/core/brahma/stdio.cpp

//
// Created by hariharan on 8/16/22.
//
#include <cpp-logger/logger.h>
#include <dftracer/core/brahma/stdio.h>
#include <dftracer/core/df_logger.h>

static ConstEventNameType CATEGORY = "STDIO";

std::shared_ptr<brahma::STDIODFTracer> brahma::STDIODFTracer::instance =
    nullptr;
bool brahma::STDIODFTracer::stop_trace = false;

FILE* brahma::STDIODFTracer::fopen64(const char* path, const char* mode) {
  BRAHMA_MAP_OR_FAIL(fopen64);
  DFT_LOGGER_START(path);
  DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);
  FILE* ret = __real_fopen64(path, mode);
  DFT_LOGGER_END();
  if (trace) this->trace(ret, fhash);
  return ret;
}

FILE* brahma::STDIODFTracer::fopen(const char* path, const char* mode) {
  BRAHMA_MAP_OR_FAIL(fopen);
  DFT_LOGGER_START(path);
  DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);
  FILE* ret = __real_fopen(path, mode);
  DFT_LOGGER_END();
  if (trace) this->trace(ret, fhash);
  return ret;
}

int brahma::STDIODFTracer::fclose(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(fclose);
  DFT_LOGGER_START(fp);
  int ret = __real_fclose(fp);
  DFT_LOGGER_END();
  if (trace) this->remove_trace(fp);
  return ret;
}

size_t brahma::STDIODFTracer::fread(void* ptr, size_t size, size_t count,
                                    FILE* fp) {
  BRAHMA_MAP_OR_FAIL(fread);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(size, MetadataType::MT_VALUE);
  DFT_LOGGER_UPDATE_TYPE(count, MetadataType::MT_VALUE);
  size_t ret = __real_fread(ptr, size, count, fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

size_t brahma::STDIODFTracer::fwrite(const void* ptr, size_t size, size_t count,
                                     FILE* fp) {
  auto handle = fwrite_brahma_handle;
  (void)handle;
  BRAHMA_MAP_OR_FAIL(fwrite);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(size, MetadataType::MT_VALUE);
  DFT_LOGGER_UPDATE_TYPE(count, MetadataType::MT_VALUE);
  size_t ret = __real_fwrite(ptr, size, count, fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

long brahma::STDIODFTracer::ftell(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(ftell);
  DFT_LOGGER_START(fp);
  long ret = __real_ftell(fp);
  DFT_LOGGER_UPDATE(ret);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::fseek(FILE* fp, long offset, int whence) {
  BRAHMA_MAP_OR_FAIL(fseek);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(offset, MetadataType::MT_VALUE);
  DFT_LOGGER_UPDATE_TYPE(whence, MetadataType::MT_VALUE);
  int ret = __real_fseek(fp, offset, whence);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

void brahma::STDIODFTracer::clearerr(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(clearerr);
  DFT_LOGGER_START(fp);
  __real_clearerr(fp);
  DFT_LOGGER_END();
}

int brahma::STDIODFTracer::feof(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(feof);
  DFT_LOGGER_START(fp);
  int ret = __real_feof(fp);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::ferror(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(ferror);
  DFT_LOGGER_START(fp);
  int ret = __real_ferror(fp);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::fgetc(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(fgetc);
  DFT_LOGGER_START(fp);
  int ret = __real_fgetc(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::fgetpos(FILE* fp, fpos_t* pos) {
  BRAHMA_MAP_OR_FAIL(fgetpos);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(pos, MetadataType::MT_VALUE);
  int ret = __real_fgetpos(fp, pos);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

char* brahma::STDIODFTracer::fgets(char* str, int num, FILE* fp) {
  BRAHMA_MAP_OR_FAIL(fgets);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(num, MetadataType::MT_VALUE);
  char* ret = __real_fgets(str, num, fp);
  if (ret != nullptr) {
    size_t ret_len = strlen(ret);
    DFT_LOGGER_UPDATE_TYPE(ret_len, MetadataType::MT_VALUE);
  }
  DFT_LOGGER_END();
  return ret;
}

void brahma::STDIODFTracer::flockfile(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(flockfile);
  DFT_LOGGER_START(fp);
  __real_flockfile(fp);
  DFT_LOGGER_END();
}

int brahma::STDIODFTracer::fputc(int c, FILE* fp) {
  BRAHMA_MAP_OR_FAIL(fputc);
  DFT_LOGGER_START(fp);
  int ret = __real_fputc(c, fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::fputs(const char* str, FILE* fp) {
  BRAHMA_MAP_OR_FAIL(fputs);
  DFT_LOGGER_START(fp);
  if (str != nullptr) {
    size_t str_len = strlen(str);
    DFT_LOGGER_UPDATE_TYPE(str_len, MetadataType::MT_VALUE);
  }
  int ret = __real_fputs(str, fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

FILE* brahma::STDIODFTracer::freopen(const char* path, const char* mode,
                                     FILE* fp) {
  BRAHMA_MAP_OR_FAIL(freopen);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_HASH(path);
  DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);
  FILE* ret = __real_freopen(path, mode, fp);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::fsetpos(FILE* fp, const fpos_t* pos) {
  BRAHMA_MAP_OR_FAIL(fsetpos);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(pos, MetadataType::MT_VALUE);
  int ret = __real_fsetpos(fp, pos);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::ftrylockfile(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(ftrylockfile);
  DFT_LOGGER_START(fp);
  int ret = __real_ftrylockfile(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

void brahma::STDIODFTracer::funlockfile(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(funlockfile);
  DFT_LOGGER_START(fp);
  __real_funlockfile(fp);
  DFT_LOGGER_END();
}

int brahma::STDIODFTracer::getc(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(getc);
  DFT_LOGGER_START(fp);
  int ret = __real_getc(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::getc_unlocked(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(getc_unlocked);
  DFT_LOGGER_START(fp);
  int ret = __real_getc_unlocked(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::getw(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(getw);
  DFT_LOGGER_START(fp);
  int ret = __real_getw(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::pclose(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(pclose);
  DFT_LOGGER_START(fp);
  int ret = __real_pclose(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::putw(int w, FILE* fp) {
  BRAHMA_MAP_OR_FAIL(putw);
  DFT_LOGGER_START(fp);
  int ret = __real_putw(w, fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

void brahma::STDIODFTracer::rewind(FILE* fp) {
  BRAHMA_MAP_OR_FAIL(rewind);
  DFT_LOGGER_START(fp);
  __real_rewind(fp);
  DFT_LOGGER_END();
}

int brahma::STDIODFTracer::setvbuf(FILE* fp, char* buf, int mode, size_t size) {
  BRAHMA_MAP_OR_FAIL(setvbuf);
  DFT_LOGGER_START(fp);
  DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);
  DFT_LOGGER_UPDATE_TYPE(size, MetadataType::MT_VALUE);
  int ret = __real_setvbuf(fp, buf, mode, size);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::ungetc(int c, FILE* fp) {
  BRAHMA_MAP_OR_FAIL(ungetc);
  DFT_LOGGER_START(fp);
  int ret = __real_ungetc(c, fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

1	//
2	// Created by hariharan on 8/16/22.
3	//
4	#include <cpp-logger/logger.h>
5	#include <dftracer/core/brahma/stdio.h>
6	#include <dftracer/core/df_logger.h>
7
8	static ConstEventNameType CATEGORY = "STDIO";
9
10	std::shared_ptr<brahma::STDIODFTracer> brahma::STDIODFTracer::instance =
11	nullptr;
12	bool brahma::STDIODFTracer::stop_trace = false;
13
14	FILE* brahma::STDIODFTracer::fopen64(const char* path, const char* mode) {	12✔
15	BRAHMA_MAP_OR_FAIL(fopen64);	12!
16	DFT_LOGGER_START(path);	12!
17	DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);	12!
18	FILE* ret = __real_fopen64(path, mode);	12!
19	DFT_LOGGER_END();	12!
20	if (trace) this->trace(ret, fhash);	12!
21	return ret;	12✔
22	}
23
24	FILE* brahma::STDIODFTracer::fopen(const char* path, const char* mode) {	278✔
25	BRAHMA_MAP_OR_FAIL(fopen);	278!
26	DFT_LOGGER_START(path);	278!
27	DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);	278!
28	FILE* ret = __real_fopen(path, mode);	278!
29	DFT_LOGGER_END();	278!
30	if (trace) this->trace(ret, fhash);	278!
31	return ret;	278✔
32	}
33
34	int brahma::STDIODFTracer::fclose(FILE* fp) {	313✔
35	BRAHMA_MAP_OR_FAIL(fclose);	313!
36	DFT_LOGGER_START(fp);	313!
37	int ret = __real_fclose(fp);	313!
38	DFT_LOGGER_END();	313!
39	if (trace) this->remove_trace(fp);	313!
40	return ret;	313✔
41	}
42
43	size_t brahma::STDIODFTracer::fread(void* ptr, size_t size, size_t count,	32✔
44	FILE* fp) {
45	BRAHMA_MAP_OR_FAIL(fread);	32!
46	DFT_LOGGER_START(fp);	32!
47	DFT_LOGGER_UPDATE_TYPE(size, MetadataType::MT_VALUE);	32!
48	DFT_LOGGER_UPDATE_TYPE(count, MetadataType::MT_VALUE);	32!
49	size_t ret = __real_fread(ptr, size, count, fp);	32!
50	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	32!
51	DFT_LOGGER_END();	32!
52	return ret;	32✔
53	}
54
55	size_t brahma::STDIODFTracer::fwrite(const void* ptr, size_t size, size_t count,	25✔
56	FILE* fp) {
57	auto handle = fwrite_brahma_handle;	25✔
58	(void)handle;
59	BRAHMA_MAP_OR_FAIL(fwrite);	25!
60	DFT_LOGGER_START(fp);	25!
61	DFT_LOGGER_UPDATE_TYPE(size, MetadataType::MT_VALUE);	25!
62	DFT_LOGGER_UPDATE_TYPE(count, MetadataType::MT_VALUE);	25!
63	size_t ret = __real_fwrite(ptr, size, count, fp);	25✔
64	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	25!
65	DFT_LOGGER_END();	25!
66	return ret;	25✔
67	}
68
NEW 69	long brahma::STDIODFTracer::ftell(FILE* fp) {	×
70	BRAHMA_MAP_OR_FAIL(ftell);	×
71	DFT_LOGGER_START(fp);	×
72	long ret = __real_ftell(fp);	×
73	DFT_LOGGER_UPDATE(ret);	×
74	DFT_LOGGER_END();	×
75	return ret;	×
76	}
77
78	int brahma::STDIODFTracer::fseek(FILE* fp, long offset, int whence) {	18✔
79	BRAHMA_MAP_OR_FAIL(fseek);	18!
80	DFT_LOGGER_START(fp);	18!
81	DFT_LOGGER_UPDATE_TYPE(offset, MetadataType::MT_VALUE);	18!
82	DFT_LOGGER_UPDATE_TYPE(whence, MetadataType::MT_VALUE);	18!
83	int ret = __real_fseek(fp, offset, whence);	18!
84	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	18!
85	DFT_LOGGER_END();	18!
86	return ret;	18✔
87	}
88
NEW 89	void brahma::STDIODFTracer::clearerr(FILE* fp) {	×
90	BRAHMA_MAP_OR_FAIL(clearerr);	×
91	DFT_LOGGER_START(fp);	×
92	__real_clearerr(fp);	×
93	DFT_LOGGER_END();	×
94	}	×
95
96	int brahma::STDIODFTracer::feof(FILE* fp) {	12✔
97	BRAHMA_MAP_OR_FAIL(feof);	12!
98	DFT_LOGGER_START(fp);	12!
99	int ret = __real_feof(fp);	12!
100	DFT_LOGGER_END();	12!
101	return ret;	12✔
102	}
103
104	int brahma::STDIODFTracer::ferror(FILE* fp) {	12✔
105	BRAHMA_MAP_OR_FAIL(ferror);	12!
106	DFT_LOGGER_START(fp);	12!
107	int ret = __real_ferror(fp);	12!
108	DFT_LOGGER_END();	12!
109	return ret;	12✔
110	}
111
NEW 112	int brahma::STDIODFTracer::fgetc(FILE* fp) {	×
113	BRAHMA_MAP_OR_FAIL(fgetc);	×
114	DFT_LOGGER_START(fp);	×
115	int ret = __real_fgetc(fp);	×
116	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
117	DFT_LOGGER_END();	×
118	return ret;	×
119	}
120
NEW 121	int brahma::STDIODFTracer::fgetpos(FILE* fp, fpos_t* pos) {	×
122	BRAHMA_MAP_OR_FAIL(fgetpos);	×
123	DFT_LOGGER_START(fp);	×
124	DFT_LOGGER_UPDATE_TYPE(pos, MetadataType::MT_VALUE);	×
125	int ret = __real_fgetpos(fp, pos);	×
126	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
127	DFT_LOGGER_END();	×
128	return ret;	×
129	}
130
131	char* brahma::STDIODFTracer::fgets(char* str, int num, FILE* fp) {	7,740✔
132	BRAHMA_MAP_OR_FAIL(fgets);	7,740!
133	DFT_LOGGER_START(fp);	7,740!
134	DFT_LOGGER_UPDATE_TYPE(num, MetadataType::MT_VALUE);	7,740!
135	char* ret = __real_fgets(str, num, fp);	7,740!
136	if (ret != nullptr) {	7,740✔
137	size_t ret_len = strlen(ret);	7,680✔
138	DFT_LOGGER_UPDATE_TYPE(ret_len, MetadataType::MT_VALUE);	7,680!
139	}
140	DFT_LOGGER_END();	7,740!
141	return ret;	7,740✔
142	}
143
NEW 144	void brahma::STDIODFTracer::flockfile(FILE* fp) {	×
145	BRAHMA_MAP_OR_FAIL(flockfile);	×
146	DFT_LOGGER_START(fp);	×
147	__real_flockfile(fp);	×
148	DFT_LOGGER_END();	×
149	}	×
150
NEW 151	int brahma::STDIODFTracer::fputc(int c, FILE* fp) {	×
152	BRAHMA_MAP_OR_FAIL(fputc);	×
153	DFT_LOGGER_START(fp);	×
154	int ret = __real_fputc(c, fp);	×
155	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
156	DFT_LOGGER_END();	×
157	return ret;	×
158	}
159
NEW 160	int brahma::STDIODFTracer::fputs(const char* str, FILE* fp) {	×
161	BRAHMA_MAP_OR_FAIL(fputs);	×
162	DFT_LOGGER_START(fp);	×
163	if (str != nullptr) {	×
164	size_t str_len = strlen(str);	×
165	DFT_LOGGER_UPDATE_TYPE(str_len, MetadataType::MT_VALUE);	×
166	}
167	int ret = __real_fputs(str, fp);	×
168	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
169	DFT_LOGGER_END();	×
170	return ret;	×
171	}
172
NEW 173	FILE* brahma::STDIODFTracer::freopen(const char* path, const char* mode,	×
174	FILE* fp) {
175	BRAHMA_MAP_OR_FAIL(freopen);	×
176	DFT_LOGGER_START(fp);	×
177	DFT_LOGGER_UPDATE_HASH(path);	×
178	DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);	×
NEW 179	FILE* ret = __real_freopen(path, mode, fp);	×
180	DFT_LOGGER_END();	×
181	return ret;	×
182	}
183
NEW 184	int brahma::STDIODFTracer::fsetpos(FILE* fp, const fpos_t* pos) {	×
185	BRAHMA_MAP_OR_FAIL(fsetpos);	×
186	DFT_LOGGER_START(fp);	×
187	DFT_LOGGER_UPDATE_TYPE(pos, MetadataType::MT_VALUE);	×
188	int ret = __real_fsetpos(fp, pos);	×
189	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
190	DFT_LOGGER_END();	×
191	return ret;	×
192	}
193
NEW 194	int brahma::STDIODFTracer::ftrylockfile(FILE* fp) {	×
195	BRAHMA_MAP_OR_FAIL(ftrylockfile);	×
196	DFT_LOGGER_START(fp);	×
197	int ret = __real_ftrylockfile(fp);	×
198	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
199	DFT_LOGGER_END();	×
200	return ret;	×
201	}
202
NEW 203	void brahma::STDIODFTracer::funlockfile(FILE* fp) {	×
204	BRAHMA_MAP_OR_FAIL(funlockfile);	×
205	DFT_LOGGER_START(fp);	×
206	__real_funlockfile(fp);	×
207	DFT_LOGGER_END();	×
208	}	×
209
210	int brahma::STDIODFTracer::getc(FILE* fp) {	48✔
211	BRAHMA_MAP_OR_FAIL(getc);	48!
212	DFT_LOGGER_START(fp);	48!
213	int ret = __real_getc(fp);	48!
214	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	48!
215	DFT_LOGGER_END();	48!
216	return ret;	48✔
217	}
218
NEW 219	int brahma::STDIODFTracer::getc_unlocked(FILE* fp) {	×
220	BRAHMA_MAP_OR_FAIL(getc_unlocked);	×
221	DFT_LOGGER_START(fp);	×
222	int ret = __real_getc_unlocked(fp);	×
223	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
224	DFT_LOGGER_END();	×
225	return ret;	×
226	}
227
NEW 228	int brahma::STDIODFTracer::getw(FILE* fp) {	×
229	BRAHMA_MAP_OR_FAIL(getw);	×
230	DFT_LOGGER_START(fp);	×
231	int ret = __real_getw(fp);	×
232	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
233	DFT_LOGGER_END();	×
234	return ret;	×
235	}
236
NEW 237	int brahma::STDIODFTracer::pclose(FILE* fp) {	×
238	BRAHMA_MAP_OR_FAIL(pclose);	×
239	DFT_LOGGER_START(fp);	×
240	int ret = __real_pclose(fp);	×
241	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
242	DFT_LOGGER_END();	×
243	return ret;	×
244	}
245
NEW 246	int brahma::STDIODFTracer::putw(int w, FILE* fp) {	×
247	BRAHMA_MAP_OR_FAIL(putw);	×
248	DFT_LOGGER_START(fp);	×
249	int ret = __real_putw(w, fp);	×
250	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
251	DFT_LOGGER_END();	×
252	return ret;	×
253	}
254
NEW 255	void brahma::STDIODFTracer::rewind(FILE* fp) {	×
256	BRAHMA_MAP_OR_FAIL(rewind);	×
257	DFT_LOGGER_START(fp);	×
258	__real_rewind(fp);	×
259	DFT_LOGGER_END();	×
260	}	×
261
NEW 262	int brahma::STDIODFTracer::setvbuf(FILE* fp, char* buf, int mode, size_t size) {	×
263	BRAHMA_MAP_OR_FAIL(setvbuf);	×
264	DFT_LOGGER_START(fp);	×
265	DFT_LOGGER_UPDATE_TYPE(mode, MetadataType::MT_VALUE);	×
266	DFT_LOGGER_UPDATE_TYPE(size, MetadataType::MT_VALUE);	×
267	int ret = __real_setvbuf(fp, buf, mode, size);	×
268	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
269	DFT_LOGGER_END();	×
270	return ret;	×
271	}
272
NEW 273	int brahma::STDIODFTracer::ungetc(int c, FILE* fp) {	×
274	BRAHMA_MAP_OR_FAIL(ungetc);	×
275	DFT_LOGGER_START(fp);	×
276	int ret = __real_ungetc(c, fp);	×
277	DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);	×
278	DFT_LOGGER_END();	×
279	return ret;	×
280	}

llnl / dftracer / 27009203599

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous