search for: rvalu

...value, false); } void *visit(symbolic_variable_c *symbol) { std::string varName; AllocaInst *alloc; varName = get_var_name_c::get_name(symbol->var_name)->value; alloc = locals[varName]; return (void *)alloc; } void *visit(equ_expression_c *symbol) { Value *lValue; Value *rValue; lValue = (Value *)symbol->l_exp->accept(*this); rValue = (Value *)symbol->r_exp->accept(*this); return Builder.CreateICmpEQ (lValue, rValue, "cond"); } Cheers, Manuele

...e of the variable, as opposed to its memory address, or the value that it points to. Within LLVM, where we don't have DW_OP_reg/DW_OP_breg but instead simply refer to a generic SSA value, this could mean either a register location or stack value. > At the moment we don't make the lvalue/rvalue distinction in LLVM at all. We make an educated guess in AsmPrinter. But that's wrong and something we should strive to fix during this redesigning. I think the opposite; I don't believe there's any reason we need to make the explicit lvalue/rvalue distinction until we're writing...

...ging out such an old thread. You stated that '(signed char) 999' is perfectly well defined in C/C++. I just looked into the C++ standard [1] and could not find this. The section that seems to apply is: ---------------------------------------------------- 4.7 Integral conversions 1) An rvalue of an integer type can be converted to an rvalue of another integer type. An rvalue of an enumeration type can be converted to an rvalue of an integer type. 2) If the destination type is unsigned, the resulting value is the least unsigned integer congruent to the source intege...

Sorry, always end up not replying to the list: The main issue with dealing with next this way is that people adding new uses of next will probably not be using c++0x and therefore won't know it's ambiguous and that it needs to be qualified. There are also two issues with rvalue references and the STL: 1. EquivalenceClasses, in the insert and findLeader functions, it uses map functions which have versions taking rvalue references. This results in a compiler error because the private constructor of ECValue is inaccessible. The easiest fix is to explicitly call the constru...

...on, which operate on different kinds of arguments. I think "location operands" is probably the best description for them, since they are operands to a DIExpression which is used to compute the variable location. > I don't think that's correct, because a DW_OP_stack_value is an rvalue. But maybe I misunderstood what you were trying to say. > We should start be defining what DW_OP_stack_value really means in LLVM debug info metadata. I believe it should just mean "r-value". Having given it some more thought, I've changed my mind - I agree that we shouldn't...

...AllocaInst *alloc; > > varName = get_var_name_c::get_name(symbol->var_name)->value; > alloc = locals[varName]; > > return (void *)alloc; > } > > void *visit(equ_expression_c *symbol) { > Value *lValue; > Value *rValue; > > lValue = (Value *)symbol->l_exp->accept(*this); > rValue = (Value *)symbol->r_exp->accept(*this); > > return Builder.CreateICmpEQ (lValue, rValue, "cond"); > > } > > Cheers, > Manuele > &gt...

...std::string varName; > AllocaInst *alloc; > > varName = get_var_name_c::get_name(**symbol->var_name)->value; > alloc = locals[varName]; > > return (void *)alloc; > } > > void *visit(equ_expression_c *symbol) { > Value *lValue; > Value *rValue; > > lValue = (Value *)symbol->l_exp->accept(*this)**; > rValue = (Value *)symbol->r_exp->accept(*this)**; > > return Builder.CreateICmpEQ (lValue, rValue, "cond"); > > } > > Cheers, > Manuele > > > > > ___...

...uto increases readability by decreasing the amount of "pattern discarding" I have to do before spotting the things I'm going to pay attention to. If the actual type is something that the reader is going to think about, then IMO auto shouldn't be used as a coding style issue. > rvalue-refs | It is not very helpful when compiler can do return value optimization. I thought the motivation for adding rvalue-refs in C++11 was that in practice compilers can almost never do enough analysis to do RVO on real-world code? Regards, Dave -- IMPORTANT NOTICE: The contents of this email...

...s can I use stimulate(model) to generate values that I can then use to do parametric bootstrap analysis and generate the confidence intervals? Something like this: n<-length(A) niter<-1000 y<-matrix(nrow=n,ncol=niter*2) for (i in 1:niter) { y[,I(i*2-1):I(i*2)]<-simulate(model)[,1] } rvalues<-numeric() for (i in 1:niter) { yboot<-cbind(y[,I(i*2-1)],y[,I(i*2)]) mboot<-lmer(y~A+B+(1|C/D)+(1|E),binomial) rvalues[i]<- attr(lme4::VarCorr(mboot)$E, "stddev")^2/(1*(pi^2)/3 + attr(lme4::VarCorr(mboot)$E, "stddev")^2 + attr(lme4::VarCorr(mboot)$C, "stddev...

...ion::codeGen() { Value *l = left->codeGen(); Value *r = right->codeGen(); Value *result = new TempValue; // get unique temporary emit(result->str() + " add " + l->str() + ", " r-str()); return result; } Value *assignExpression::codeGen() { Value *rval = rvalue->codeGen(); Value *lval = new NameValue(ident); emit(lval->str() + " = " + rval->str()); // emit (silly) copy instruction return lval; } What I have suggested to my students is to omit the (non-existent) copy instruction and use the "rval" above as a replacem...

...t *alloc; >> >> varName = get_var_name_c::get_name(symbol->var_name)->value; >> alloc = locals[varName]; >> >> return (void *)alloc; >> } >> >> void *visit(equ_expression_c *symbol) { >> Value *lValue; >> Value *rValue; >> >> lValue = (Value *)symbol->l_exp->accept(*this); >> rValue = (Value *)symbol->r_exp->accept(*this); >> >> return Builder.CreateICmpEQ (lValue, rValue, "cond"); >> >> } >> >> Cheers, >>...

...), there is a large potential for name clashes even when namespaces are judiciously used. The carefully crafted C++ library should be aware of ADL issues. It should know when ADL is being used, and when it isn't, and use ADL purposefully, not accidentally. > There are also two issues with rvalue references and the STL: > > 1. EquivalenceClasses, in the insert and findLeader functions, it uses map functions which have versions taking rvalue references. This results in a compiler error because the private constructor of ECValue is inaccessible. The easiest fix is to explicitly call t...

...way, I'm excited about a new library. Plus, it looks a little easier to read (from the tiny amount of code that I've looked at). > > libc++: > > 5 seconds > > libstdc++: > > 22 seconds > > (smaller is better) > > Is this libstdc++ with or without rvalue references? This was compiled with g++-4.-2 -O3 (without rvalue references, which would have no effect on sorting ints anyway). -Howard

...erived from the name of the function that Puppet is trying to run." Is this still true? I ask because I currently write a set of math functions (min,max, plus, minus and so). My first try was to create a math.rb, where I had: module Puppet::Parser::Functions newfunction(:min, :type => :rvalue) do |args| .... end newfunction(:max, :type => :rvalue) do |args| .... end ....and so on... end This of course did not work, so I split the whole thing up in multiple: min.rb, max.rb, .... files. This works now quite well. Nevertheless it would be somewhat nicer to have these functi...

...u stated that > '(signed char) 999' is perfectly well defined in C/C++. I just looked > into the C++ standard [1] and could not find this. The section that > seems to apply is: > > ---------------------------------------------------- > 4.7 Integral conversions >   1) An rvalue of an integer type can be converted to an rvalue of >      another integer type. An rvalue of an enumeration type can >      be converted to an rvalue of an integer type. >   2) If the destination type is unsigned, the resulting value is the >      least unsigned integer congruent to t...

...row away the value. clang and llvm-gcc do this, as do most other good C compilers. However, clang++ and llvm-g++ also load from x and this does not appear to be supported by the 1998 C++ standard. In 6.2, it is explicitly stated that for an expression statement, no conversion from lvalue to rvalue occurs. If there's no rvalue, there should not be a load from x. Anyway, I'm curious: is the C-like interpretation of a volatile expression statement considered to be a feature by the LLVM maintainers? If so, what is the rationale? I haven't done extensive testing, but there do...

...cluded from /usr/local/include/llvm/IR/Type.h:19: In file included from /usr/local/include/llvm/ADT/APFloat.h:20: In file included from /usr/local/include/llvm/ADT/APInt.h:19: In file included from /usr/local/include/llvm/ADT/ArrayRef.h:14: /usr/local/include/llvm/ADT/SmallVector.h:232:20: warning: rvalue references are a C++11 extension [-Wc++11-extensions] void push_back(T &&Elt) { ^ /usr/local/include/llvm/ADT/SmallVector.h:476:33: warning: rvalue references are a C++11 extension [-Wc++11-extensions] iterator insert(iterator I, T &&Elt) { In file include...

...39;dsyevr'? Especially I am interested about the meaning and handling of error codes 1 and 2. In Lapack.c I only see the reference to the variable info in certain Fortran code: F77_CALL(dsyevr)(jobv, range, uplo, &n, rx, &n, &vl, &vu, &il, &iu, &abstol, &m, rvalues, rz, &n, isuppz, &tmp, &lwork, &itmp, &liwork, &info); if (info != 0) error(_("error code %d from Lapack routine '%s'"), info, "dsyevr"); lwork = (int) tmp; liwork = itmp; work = (double *) R_alloc(lwork, sizeof(double))...

...->codeGen(); >  Value *r = right->codeGen(); >  Value *result = new TempValue;  // get unique temporary >  emit(result->str() + " add " + l->str() + ", " r-str()); >  return result; > } > > Value *assignExpression::codeGen() { >  Value *rval = rvalue->codeGen(); >  Value *lval = new NameValue(ident); >  emit(lval->str() + " = " + rval->str());    // emit (silly) copy instruction >  return lval; > } > > What I have suggested to my students is to omit the (non-existent) copy instruction > and use the &quot...

...->codeGen(); >  Value *r = right->codeGen(); >  Value *result = new TempValue;  // get unique temporary >  emit(result->str() + " add " + l->str() + ", " r-str()); >  return result; > } > > Value *assignExpression::codeGen() { >  Value *rval = rvalue->codeGen(); >  Value *lval = new NameValue(ident); >  emit(lval->str() + " = " + rval->str());    // emit (silly) copy instruction >  return lval; > } > > What I have suggested to my students is to omit the (non-existent) copy instruction > and use the &quot...