28731245268

Committed 05 Jul 2026 05:54AM UTC coverage: 18.611%. First build

Build # 28731245268

Build Type

Pull #367

github

Committed by

web-flow

Commit Message

Merge 117a42ffe into 193c94037

Pull Request Pull Request #367: Feature for ByPass

Coverage Stats

7339 of 53706 branches covered (13.67%)

Branch coverage included in aggregate %.

108 of 129 new or added lines in 9 files covered. (83.72%)

4861 of 11845 relevant lines covered (41.04%)

1103.74 hits per line

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

15.97

/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>
#include <dftracer/core/utils/stdio_bypass.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;
}

// See the comment on these four overrides' declarations in stdio.h: unlike
// every other override in this class, they call
// dftracer::STDIOBypass::get_instance() for the "real function" step
// instead of BRAHMA_MAP_OR_FAIL/__real_*, to avoid GOTCHA's broken
// gotcha_get_wrappee() resolution for these specific symbols.
void brahma::STDIODFTracer::flockfile(FILE* fp) {
  DFT_LOGGER_START(fp);
  dftracer::STDIOBypass::get_instance().flockfile(fp);
  DFT_LOGGER_END();
}

void brahma::STDIODFTracer::funlockfile(FILE* fp) {
  DFT_LOGGER_START(fp);
  dftracer::STDIOBypass::get_instance().funlockfile(fp);
  DFT_LOGGER_END();
}

int brahma::STDIODFTracer::ftrylockfile(FILE* fp) {
  DFT_LOGGER_START(fp);
  int ret = dftracer::STDIOBypass::get_instance().ftrylockfile(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

int brahma::STDIODFTracer::fflush(FILE* fp) {
  DFT_LOGGER_START(fp);
  int ret = dftracer::STDIOBypass::get_instance().fflush(fp);
  DFT_LOGGER_UPDATE_TYPE(ret, MetadataType::MT_VALUE);
  DFT_LOGGER_END();
  return ret;
}

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

llnl / dftracer / 28731245268

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