/* constants that do not change during successive pe calculations */ void prepareSfbPe(PE_CHANNEL_DATA *peChanData, const float *sfbEnergy, const float *sfbThreshold, const float *sfbFormFactor, const int *sfbOffset, const int sfbCnt, const int sfbPerGroup, const int maxSfbPerGroup) { int sfbGrp,sfb; int sfbWidth; float avgFormFactor; COUNT_sub_start("prepareSfbPe"); LOOP(1); for(sfbGrp = 0;sfbGrp < sfbCnt;sfbGrp+=sfbPerGroup){ PTR_INIT(6); /* pointers for sfbEnergy[], sfbThreshold[], sfbOffset[], sfbFormFactor[], peChanData->sfbNLines[], peChanData->sfbLdEnergy[] */ LOOP(1); for (sfb=0; sfb<maxSfbPerGroup; sfb++) { ADD(1); BRANCH(1); if (sfbEnergy[sfbGrp+sfb] > sfbThreshold[sfbGrp+sfb]) { ADD(1); sfbWidth = sfbOffset[sfbGrp+sfb+1] - sfbOffset[sfbGrp+sfb]; /* estimate number of active lines */ DIV(1); TRANS(1); avgFormFactor = (float) pow(sfbEnergy[sfbGrp+sfb]/(float)sfbWidth, 0.25f); DIV(1); STORE(1); peChanData->sfbNLines[sfbGrp+sfb] = sfbFormFactor[sfbGrp+sfb]/avgFormFactor; /* ld(sfbEn) */ TRANS(1); MULT(1); STORE(1); peChanData->sfbLdEnergy[sfbGrp+sfb] = (float) (log(sfbEnergy[sfbGrp+sfb]) * LOG2_1); } else { MOVE(2); peChanData->sfbNLines[sfbGrp+sfb] = 0.0f; peChanData->sfbLdEnergy[sfbGrp+sfb] = 0.0f; } } } COUNT_sub_end(); }
int xavs_cqm_init (xavs_t * h) { int def_quant8[64][64]; int def_dequant8[64][64]; int q, i, i_list; int pos; int deadzone[4] = { h->param.analyse.i_luma_deadzone[0], h->param.analyse.i_luma_deadzone[1], 32 - 11, 32 - 21 }; /*intra Y; inter Y; intra C; inter C */ int max_qp_err = -1; //initial the dequant and quant table with q for 8x8 for (q = 0; q < 64; q++) { for (i = 0; i < 64; i++) { def_dequant8[q][i] = dequant8_table[q]; def_quant8[q][i] = quant8_scale[i]; } } //i_list =0 Intra Y ; i_list = 1 inter Y ; i_list =2 Intra C ; i_list =3 Inter C; for (i_list = 0; i_list < 4; i_list++) { for (q = 0; q < 64; q++) { for (pos = 0; pos < 64; pos++) { int xx = pos % 8; int yy = pos / 8; int mf; h->dequant8_mf[i_list][q][yy][xx] = DIV (def_dequant8[q][pos] * 16, h->pps->scaling_list[i_list][pos]); h->quant8_mf[i_list][q][pos] = mf = DIV (def_quant8[q][pos] * 16, h->pps->scaling_list[i_list][pos]); //here the deadzone is a value from 0~32 2~5 //deadzone 1/2, deadzone should be 0.5 * 1<<15 = (1<<5) * (1<<9) //typical value intra f=(1<<15)*10/31 inter f=(1<<15)*10/62 if (i_list % 2 == 0) /*intra */ h->quant8_bias[i_list][q][pos] = XAVS_MIN (deadzone[i_list] << 9, (1 << 15) * 10 / 31); else /*inter */ h->quant8_bias[i_list][q][pos] = XAVS_MIN (deadzone[i_list] << 9, (1 << 15) * 10 / 62); } } } if (!h->mb.b_lossless && max_qp_err >= h->param.rc.i_qp_min) { xavs_log (h, XAVS_LOG_ERROR, "Quantization overflow.\n"); xavs_log (h, XAVS_LOG_ERROR, "Your CQM is incompatible with QP < %d, but min QP is set to %d\n", max_qp_err + 1, h->param.rc.i_qp_min); return -1; } return 0; }
static void reducec(NUM_TYPE* l1,NUM_TYPE * l2) { NUM_TYPE c, i1, i2; i1 = ABS(*l1); i2 = ABS(*l2); if (i2 > i1) { c = i1; i1 = i2; i2 = c; } while (i2 != 0) { c = i2; i2 = REST(i1,i2); i1 = c; } (*l1) = DIV(*l1,i1); (*l2) = DIV(*l2,i1); }
ulong get_timer_raw(void) { ulong now = DIV(READ_TIMER); if (now >= lastinc) { /* normal mode */ timestamp += now - lastinc; } else { /* overflow ... */ timestamp += now + DIV(TIMER_LOAD_VAL) - lastinc; } lastinc = now; return timestamp; }
aravdebug(const char * userfile, int lineno, const char *PATH) { dataPath = getenv("DLOG_OUTPUT_FOLDER") + std::string(PATH); //llvm::errs()<<"Data path ::"<<dataPath; datatempPath = dataPath + ".temp"; // tagPath = dataPath + ".tag"; std::string syscall = "rm -f " + dataPath; int status = system(syscall.c_str()); if (status < 0) std::cout << "DLOG Error: " << strerror(errno) << '\n'; OS.reset((new llvm::raw_fd_ostream(datatempPath.c_str(), ErrorInfo))); llvm::errs() << ErrorInfo; id = gid++; //llvm::errs()<<"created DLOG with id "<<id<<"\n"; tagset.insert("SYSTEM"); (*OS) << DIV("SYSTEM")<< "Created Debugger " << GREEN(id) << CALLINFO << EDIV; tagset.insert("CALLINFO"); (*OS).flush(); }
void tmr0_init(void) { // Select asynchronous timer 0 operation to use external 32.768 kHz crystal BIT_SET_HI(ASSR,AS0); // Reset time TCNT0 = 0; // Calculate and set period OCR0 = (uint16)DIV(((F_RTC/8)*TMR0_PERIOD_MS),1000) - 1; /* Start timer 0 with clock prescaler CLK/8 and CTC Mode ("Clear Timer on Compare")*/ /* Resolution is 244.14 us */ /* Maximum period is 62.5 ms */ TCCR0 = TMR0_TCCR0_VALUE; // Wait for "update busy" flags to clear while(ASSR&((1<<TCN0UB)|(1<<OCR0UB)|(1<<TCR0UB))) { ; } // Enable interrupt on compare match BIT_SET_HI(TIMSK,OCIE0); }
static void calcPeCorrection(float *correctionFac, const float peAct, const float peLast, const int bitsLast) { COUNT_sub_start("calcPeCorrection"); ADD(4); FUNC(1); FUNC(1); MULT(4); LOGIC(4); BRANCH(1); if ((bitsLast > 0) && (peAct < (float)1.5f*peLast) && (peAct > (float)0.7f*peLast) && ((float)1.2f*bits2pe((float)bitsLast) > peLast) && ((float)0.65f*bits2pe((float)bitsLast) < peLast)) { float newFac = peLast / bits2pe((float)bitsLast); FUNC(1); DIV(1); /* counting previous operation */ /* dead zone */ ADD(1); BRANCH(1); if (newFac < (float)1.0f) { MULT(1); ADD(1); BRANCH(1); MOVE(1); newFac = min((float)1.1f*newFac, (float)1.0f); ADD(1); BRANCH(1); MOVE(1); newFac = max(newFac, (float)0.85f); } else { MULT(1); ADD(1); BRANCH(1); MOVE(1); newFac = max((float)0.9f*newFac, (float)1.0f); ADD(1); BRANCH(1); MOVE(1); newFac = min(newFac, (float)1.15f); } ADD(4); LOGIC(3); BRANCH(1); if (((newFac > (float)1.0f) && (*correctionFac < (float)1.0f)) || ((newFac < (float)1.0f) && (*correctionFac > (float)1.0f))) { MOVE(1); *correctionFac = (float)1.0f; } /* faster adaptation towards 1.0, slower in the other direction */ ADD(3); LOGIC(3); BRANCH(1); /* if() */ MULT(1); MAC(1); STORE(1); if ((*correctionFac < (float)1.0f && newFac < *correctionFac) || (*correctionFac > (float)1.0f && newFac > *correctionFac)) *correctionFac = (float)0.85f * (*correctionFac) + (float)0.15f * newFac; else *correctionFac = (float)0.7f * (*correctionFac) + (float)0.3f * newFac; ADD(2); BRANCH(2); MOVE(2); *correctionFac = min(*correctionFac, (float)1.15f); *correctionFac = max(*correctionFac, (float)0.85f); } else { MOVE(1); *correctionFac = (float)1.0f; } COUNT_sub_end(); }
void llvm_print(const char *userfile, int lineno, T &obj, const char* tag, ADDON addon = ADDON()) { std::string unformatted = llvm_to_str(obj); std::string formatted = dlog_format_string_to_html(unformatted); if (outputmode == DLOG_OUTPUT_BOTH || outputmode == DLOG_OUTPUT_FILE) { tag_handler(tag); fdata << DIV( tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << br << CALLINFO << BROWN(addon.getString()) << NBSP << NBSP << BOLD(" Data : <br>") << formatted << EDIV; } if (outputmode == DLOG_OUTPUT_BOTH || outputmode == DLOG_OUTPUT_STDOUT) { std::cout << "Tag : " << tag << "\t"; if (addon.getString().length() != 0) std::cout << "\t Addon: " << addon.getString() << "\n"; std::cout << unformatted << "\n"; } fdata.flush(); }
// skipped some of the special handling in here - if we get crashes, let the interpreter handle this // op void JitILBase::divwux(UGeckoInstruction inst) { // FIXME FALLBACK_IF(true); #if 0 int a = inst.RA, b = inst.RB, d = inst.RD; gpr.FlushLockX(RSCRATCH1); gpr.Lock(a, b, d); if (d != a && d != b) { gpr.LoadToX64(d, false, true); } else { gpr.LoadToX64(d, true, true); } MOV(32, R(RSCRATCH), gpr.R(a)); XOR(32, R(RSCRATCH2), R(RSCRATCH)); gpr.KillImmediate(b); DIV(32, gpr.R(b)); MOV(32, gpr.R(d), R(RSCRATCH)); gpr.UnlockAll(); gpr.UnlockAllX(); if (inst.Rc) { CALL((u8*)asm_routines.computeRc); } #endif }
/* The function creates the interpolated spectral data according to the energy of the last good frame and the current (good) frame. */ void CConcealment_InterpolateBuffer (float *spectrum, float *enPrev, float *enAct, int sfbCnt, const short *pSfbOffset) { int sfb, line = 0; float multiplier; FLC_sub_start("CConcealment_InterpolateBuffer"); MOVE(1); /* counting previous operation */ PTR_INIT(3); /* enAct[] enPrev[] spectrum[] */ LOOP(1); for(sfb = 0; sfb < sfbCnt; sfb++) { DIV(1); TRANS(1); multiplier = (float) pow(enAct[sfb] / enPrev[sfb], 0.25f); LOOP(1); for(; line < pSfbOffset[sfb+1]; line++) { MULT(1); STORE(1); spectrum [line] = spectrum[line] * multiplier; } } FLC_sub_end(); }
static Value *binaryExprInterp(Node *node, void *parser) { #ifndef NDEBUG assert(node->type == NT_BINARY_EXPR); #endif BinaryExpr *e = (BinaryExpr *)node; #ifdef LOG_INTERP logInterpPrefix(parser); rawlog("binaryExprInterp\n"); ((Parser *)parser)->interpDepth++; #endif assert(e->lhs && e->rhs); Value *lhs = e->lhs->interp(e->lhs, parser); Value *rhs = e->rhs->interp(e->rhs, parser); switch (e->op) { case TK_ADD: e->value = ADD(lhs, rhs, e->value); break; /* + */ case TK_SUB: e->value = SUB(lhs, rhs, e->value); break; /* - */ case TK_MUL: e->value = MUL(lhs, rhs, e->value); break; /* * */ case TK_DIV: e->value = DIV(lhs, rhs, e->value); break; /* / */ default: assert(0); break; } #ifdef LOG_INTERP logInterpPrefix(parser); rawlog("%s\n", token2str(e->op)); ((Parser *)parser)->interpDepth--; #endif return e->value; }
/*! \brief Is SBR setting available. \return a flag indicating success: yes (1) or no (0) ****************************************************************************/ unsigned int IsSbrSettingAvail (unsigned int bitrate, unsigned int numOutputChannels, unsigned int sampleRateInput, unsigned int *sampleRateCore ) { int idx = INVALID_TABLE_IDX; COUNT_sub_start("IsSbrSettingAvail"); MOVE(1); /* counting previous operation */ ADD(1); BRANCH(1); if (sampleRateInput < 32000) { COUNT_sub_end(); return 0; } DIV(1); STORE(1); *sampleRateCore = sampleRateInput/2; FUNC(3); idx = getSbrTuningTableIndex(bitrate,numOutputChannels, *sampleRateCore); ADD(1); BRANCH(1); /* counting post-operation */ COUNT_sub_end(); return (idx == INVALID_TABLE_IDX) ? 0 : 1; }
void print_to_file(const char * userfile, int lineno, T obj, ADDON addon = ADDON()) { tagset.insert("notag"); (*OS) << DIV("notag") << br << BLUE( obj) << NBSP << CALLINFO << NBSP << BROWN(addon.getString()) << NBSP << EDIV; (*OS).flush(); }
/** * Generates a sequence of nbits random bits */ int srslte_binsource_cache_gen(srslte_binsource_t* q, int nbits) { if (gen_seq_buff(q,DIV(nbits,32))) { return -1; } q->seq_cache_nbits = nbits; q->seq_cache_rp = 0; return 0; }
/** * Stores in the bits buffer a sequence of nbits pseudo-random bits. * Overwrites the bits generated using srslte_binsource_cache_gen. */ int srslte_binsource_generate(srslte_binsource_t* q, uint8_t *bits, int nbits) { if (gen_seq_buff(q,DIV(nbits,32))) { return -1; } int_2_bits(q->seq_buff,bits,nbits); return 0; }
/** * Stores in the bits buffer a sequence of nbits pseudo-random bits. * Overwrites the bits generated using binsource_cache_gen. */ int binsource_generate(binsource_t* q, char *bits, int nbits) { if (gen_seq_buff(q,DIV(nbits,32))) { return -1; } int_2_bits(q->seq_buff,bits,nbits); return 0; }
int is_abs_walkable(Entity** entities, int x, int y) { int walkable = is_walkable(entities[DIV(x)][DIV(y)]); if(MOD(x) != 0 && MOD(y) != 0) walkable = walkable && is_walkable(entities[DIV(x) + 1][DIV(y) + 1]); if(MOD(x) != 0) walkable = walkable && is_walkable(entities[DIV(x) + 1][DIV(y)]); if(MOD(y) != 0) walkable = walkable && is_walkable(entities[DIV(x)][DIV(y) + 1]); return walkable; }
struct LongNumber DEGREE(struct LongNumber a, struct LongNumber b, struct LongNumber c) { struct LongNumber res; if(a.size < c.size) res.size = c.size + c.size; else res.size = a.size + a.size; res = allocate(res, res.size); res = zero(res, res.size); res.pointer[0] = 1; struct LongNumber com; com.size = 1; com = allocate(com, com.size); com.pointer[0] = 0; struct LongNumber value; value.size = res.size; value = allocate(value, value.size); value = zero(value, value.size); memcpy(value.pointer, a.pointer, a.size * sizeof(unsigned int)); struct LongNumber pow = copy(b); while((compare(pow,com)) > 0) { if((pow.pointer[0] & 1)==1) { res = MUL(res, value); res = DIV(res, c, 2); } value = MUL(value, value); value = DIV(value, c, 2); pow = SmallDIV(pow, 2); } com = clear(com); pow = clear(pow); value = clear(value); return res; }
void print_to_default_file(const char * userfile, int lineno, S tag, unsigned int obj, ADDON addon = ADDON()) { tagset.insert(tag); (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO << NBSP << BROWN(addon.getString()) << NBSP << BOLD(" Data : <br>") << obj << EDIV; (*OS).flush(); }
void print_to_file(const char * userfile, int lineno, const char* tag, const char* objS) { //llvm::errs()<<"I am called in line no"<<__LINE__; tagset.insert(tag); (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO << NBSP << BOLD(" Data : <br>") << objS << EDIV; (*OS).flush(); }
/***************************************************************************** functionname: atan_approx description: Calculates atan , val >=0 returns: approx of atan(val), error is less then 0.5 % input: output: *****************************************************************************/ static float atan_approx(float val) { COUNT_sub_start("atan_approx"); ADD(1); BRANCH(1); if(val < (float)1.0) { DIV(1); MULT(2); ADD(1); /* counting post-operations */ COUNT_sub_end(); return(val/((float)1.0f+(float)0.280872f*val*val)); } else { DIV(1); MULT(1); ADD(2); /* counting post-operations */ COUNT_sub_end(); return((float)1.57079633f-val/((float)0.280872f +val*val)); } }
int main(void) { printf("ADDITION:\t %f + %f = %f\n", WERT1, WERT2, ADD(WERT1,WERT2)); printf("SUBTRAKTION:\t %f - %f = %f\n", WERT1, WERT2, SUB(WERT1,WERT2)); printf("MULTIPLIKATION:\t %f * %f = %f\n", WERT1, WERT2, MUL(WERT1,WERT2)); printf("DIVISION:\t %f / %f = %f\n", WERT1, WERT2, DIV(WERT1,WERT2)); return 0; }
int main() { printf("%d",p); int num1, num2, mod; printf("\nEnter two integers\n"); scanf("%d%d",&num1,&num2); printf("\nThe result of division is %d\n", DIV(num1,num2)); mod = MOD(num1,num2); printf("\nThe result of modulus is %d\n", mod); }
int moduloExprCodegen(c_tree tree, int *registerNo, int topLevel, int getAddress, const char *breakLabel, const char *continueLabel) { c_tree op2 = TREE_EXPR_OPERAND(tree,1); c_tree op1 = TREE_EXPR_OPERAND(tree,0); if (!topLevel) { int op1Register = c_codegen_recurse(op1, registerNo, topLevel, getAddress, breakLabel, continueLabel); if (TREE_CODE(op2) == TREE_INTEGER_CST) { int divReg = (*registerNo)++; int mulReg = (*registerNo)++; int resReg = (*registerNo)++; int immiValue = INTEGER_CST(op2)->val; DIVi(divReg, op1Register, immiValue, "modulo", NULL); MULi(mulReg, divReg, immiValue, "modulo", NULL); SUB(resReg, op1Register, mulReg, "modulo", NULL); return resReg; } else { int op2Register = c_codegen_recurse(op2, registerNo, topLevel, getAddress, breakLabel, continueLabel); int divReg = (*registerNo)++; int mulReg = (*registerNo)++; int resReg = (*registerNo)++; DIV(divReg, op1Register, op2Register, "modulo", NULL); MUL(mulReg, divReg, op2Register, "modulo", NULL); SUB(resReg, op1Register, mulReg, "modulo", NULL); return resReg; } } else { c_codegen_recurse(op1, registerNo, topLevel, getAddress, breakLabel, continueLabel); c_codegen_recurse(op2, registerNo, topLevel, getAddress, breakLabel, continueLabel); return *registerNo; } }
static void test_div_basic(void) { TB_INFO(" Testing basic cases"); DEF_BIGINT(n, 2048); DEF_BIGINT(d, 2048); DEF_BIGINT(q, 2048); DEF_BIGINT(r, 2048); DEF_BIGINT(v, 2048); SELF_VERIFY_DIV("8111_1110_0000_0001_12345678", "8000000012345678"); DIV("0", "1", "0"); DIV("1", "1", "1"); DIV("b7fb", "5", "24CB"); DIV("124378912734891273894712890347102358129034789120374", "1984086C15FA011154C86FA68", "B73D14EC7205D3311F6E78411D"); SELF_VERIFY_DIV("124378912734891273894712890347102358129034789120374", "1984086C15FA011154C86FA68"); SELF_VERIFY_DIV("-124378912734891273894712890347102358129034789120374", "1984086C15FA011154C86FA68"); SELF_VERIFY_DIV("124378912734891273894712890347102358129034789120374", "-1984086C15FA011154C86FA68"); SELF_VERIFY_DIV("-124378912734891273894712890347102358129034789120374", "-1984086C15FA011154C86FA68"); SELF_VERIFY_DIV("12345678", "10"); SELF_VERIFY_DIV("-12345678", "10"); SELF_VERIFY_DIV("12345678", "-10"); SELF_VERIFY_DIV("-12345678", "-10"); SELF_VERIFY_DIV("12345678901234567890123456789012345678901", "10"); SELF_VERIFY_DIV("1234567890123456789012345678901234567890", "10"); SELF_VERIFY_DIV("123456789012345678901234567890123456789", "10"); DEL_BIGINT(n); DEL_BIGINT(d); DEL_BIGINT(q); DEL_BIGINT(r); DEL_BIGINT(v); }
Byte Processor::execInstruction() { #ifdef R_UM_OPT_ENABLE_LOGGING #ifdef R_UM_OPT_PRC_DEBUG ic_ ++; #endif #endif Word instr = (*mm_)(0, pc_ ++); switch (decodeInstruction(instr)) { case IC_CNDMOV: return CNDMOV(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_ARRIDX: return ARRIDX(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_ARRAMD: return ARRAMD(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_ADD: return ADD(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_MUL: return MUL(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_DIV: return DIV(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_NOTAND: return NOTAND(decodeAreg(instr), decodeBreg(instr), decodeCreg(instr)); case IC_HLT: return HLT(); case IC_ALLOC: return ALLOC(decodeBreg(instr), decodeCreg(instr)); case IC_ABAND: return ABAND(decodeCreg(instr)); case IC_OUTP: return OUTP(decodeCreg(instr)); case IC_INP: return INP(decodeCreg(instr)); case IC_LDPRG: return LDPRG(decodeBreg(instr), decodeCreg(instr)); case IC_ORTHO: return ORTHO(decodeOreg(instr), decodeVal(instr)); default: assert(false); return HLT(); } }
int main (void) { double *x, *f; int i; x = aCy (n, -1., 1. ); SV (n, x); f = DIV (n); for (i = 0; i < n; i++) f[i] = fun (x[i]); difdiv (n, x, f); /* generat el polinomi */ writeFile (n, 0.001, -1, 1, x, f); return 0; }
int timer_init(void) { /* We are using timer34 in unchained 32-bit mode, full speed */ timer->tcr = 0x0; timer->tgcr = 0x0; timer->tgcr = 0x06; timer->tim34 = 0x0; timer->prd34 = DIV(TIMER_LOAD_VAL); lastinc = 0; timer->tcr = 0x80 << 16; timestamp = 0; return(0); }
int dynBitCount(const short *quantSpectrum, const unsigned short *maxValueInSfb, const signed short *scalefac, const int blockType, const int sfbCnt, const int maxSfbPerGroup, const int sfbPerGroup, const int *sfbOffset, SECTION_DATA *sectionData) { int bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1]; int mergeGainLookUp[MAX_SFB_LONG]; COUNT_sub_start("dynBitCount"); INDIRECT(3); MOVE(3); sectionData->blockType = blockType; sectionData->sfbCnt = sfbCnt; sectionData->sfbPerGroup = sfbPerGroup; INDIRECT(1); DIV(1); STORE(1); sectionData->noOfGroups = sfbCnt / sfbPerGroup; MOVE(1); sectionData->maxSfbPerGroup = maxSfbPerGroup; FUNC(7); noiselessCounter(sectionData, mergeGainLookUp, bitLookUp, quantSpectrum, maxValueInSfb, sfbOffset, blockType); FUNC(3); scfCount(scalefac, maxValueInSfb, sectionData); INDIRECT(3); ADD(2); /* counting post-operations */ COUNT_sub_end(); return (sectionData->huffmanBits + sectionData->sideInfoBits + sectionData->scalefacBits); }
void print_to_file(const char * userfile, int lineno, const char* tag, T &obj) { std::string msg; //llvm::errs()<<"I am called in line no"<<__LINE__; llvm::raw_string_ostream Msg(msg); Msg << obj; std::string objS = Msg.str(); replaceAll(objS, "\n", mendl); tagset.insert(tag); (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO << NBSP << BOLD(" Data : <br>") << objS << EDIV; (*OS).flush(); }