void deserialize(MemoryBuffer & buff) { buff.read(mjr).read(mnr); }
void VariableSizeBokehBlurOperation::executePixel(float output[4], int x, int y, void *data)
{
VariableSizeBokehBlurTileData *tileData = (VariableSizeBokehBlurTileData *)data;
MemoryBuffer *inputProgramBuffer = tileData->color;
MemoryBuffer *inputBokehBuffer = tileData->bokeh;
MemoryBuffer *inputSizeBuffer = tileData->size;
float *inputSizeFloatBuffer = inputSizeBuffer->getBuffer();
float *inputProgramFloatBuffer = inputProgramBuffer->getBuffer();
float readColor[4];
float bokeh[4];
float tempSize[4];
float multiplier_accum[4];
float color_accum[4];
const float max_dim = max(m_width, m_height);
const float scalar = this->m_do_size_scale ? (max_dim / 100.0f) : 1.0f;
int maxBlurScalar = tileData->maxBlurScalar;
BLI_assert(inputBokehBuffer->getWidth() == COM_BLUR_BOKEH_PIXELS);
BLI_assert(inputBokehBuffer->getHeight() == COM_BLUR_BOKEH_PIXELS);
#ifdef COM_DEFOCUS_SEARCH
float search[4];
this->m_inputSearchProgram->read(search, x / InverseSearchRadiusOperation::DIVIDER, y / InverseSearchRadiusOperation::DIVIDER, NULL);
int minx = search[0];
int miny = search[1];
int maxx = search[2];
int maxy = search[3];
#else
int minx = max(x - maxBlurScalar, 0);
int miny = max(y - maxBlurScalar, 0);
int maxx = min(x + maxBlurScalar, (int)m_width);
int maxy = min(y + maxBlurScalar, (int)m_height);
#endif
{
inputSizeBuffer->readNoCheck(tempSize, x, y);
inputProgramBuffer->readNoCheck(readColor, x, y);
copy_v4_v4(color_accum, readColor);
copy_v4_fl(multiplier_accum, 1.0f);
float size_center = tempSize[0] * scalar;
const int addXStepValue = QualityStepHelper::getStep();
const int addYStepValue = addXStepValue;
const int addXStepColor = addXStepValue * COM_NUM_CHANNELS_COLOR;
if (size_center > this->m_threshold) {
for (int ny = miny; ny < maxy; ny += addYStepValue) {
float dy = ny - y;
int offsetValueNy = ny * inputSizeBuffer->getWidth();
int offsetValueNxNy = offsetValueNy + (minx);
int offsetColorNxNy = offsetValueNxNy * COM_NUM_CHANNELS_COLOR;
for (int nx = minx; nx < maxx; nx += addXStepValue) {
if (nx != x || ny != y) {
float size = min(inputSizeFloatBuffer[offsetValueNxNy] * scalar, size_center);
if (size > this->m_threshold) {
float dx = nx - x;
if (size > fabsf(dx) && size > fabsf(dy)) {
float uv[2] = {
(float)(COM_BLUR_BOKEH_PIXELS / 2) + (dx / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1),
(float)(COM_BLUR_BOKEH_PIXELS / 2) + (dy / size) * (float)((COM_BLUR_BOKEH_PIXELS / 2) - 1)};
inputBokehBuffer->read(bokeh, uv[0], uv[1]);
madd_v4_v4v4(color_accum, bokeh, &inputProgramFloatBuffer[offsetColorNxNy]);
add_v4_v4(multiplier_accum, bokeh);
}
}
}
offsetColorNxNy += addXStepColor;
offsetValueNxNy += addXStepValue; }
}
}
output[0] = color_accum[0] / multiplier_accum[0];
output[1] = color_accum[1] / multiplier_accum[1];
output[2] = color_accum[2] / multiplier_accum[2];
output[3] = color_accum[3] / multiplier_accum[3];
/* blend in out values over the threshold, otherwise we get sharp, ugly transitions */
if ((size_center > this->m_threshold) &&
(size_center < this->m_threshold * 2.0f))
{
/* factor from 0-1 */
float fac = (size_center - this->m_threshold) / this->m_threshold;
interp_v4_v4v4(output, readColor, output, fac);
}
}
}
void serialize(MemoryBuffer & buff) const { buff.append(mjr).append(mnr); }
void serializeSlaveData(MemoryBuffer &dst, unsigned slave)
{
dst.append(replyTag);
}
void InverseSearchRadiusOperation::executePixelChunk(float output[4], int x, int y, void *data)
{
MemoryBuffer *buffer = (MemoryBuffer *)data;
buffer->readNoCheck(output, x, y);
}
void init(MemoryBuffer &data, MemoryBuffer &slaveData)
{
isLocal = 0 != (TIWlocal & helper->getFlags());
mpTag = container.queryJob().deserializeMPTag(data);
mpTag2 = container.queryJob().deserializeMPTag(data);
data.read(active);
if (active)
{
data.read(logicalFilename);
partDesc.setown(deserializePartFileDescriptor(data));
}
data.read(fileSize);
data.read(singlePartKey);
data.read(refactor);
if (singlePartKey)
buildTlk = false;
else
{
data.read(buildTlk);
if (firstNode())
{
if (buildTlk)
tlkDesc.setown(deserializePartFileDescriptor(data));
else if (!isLocal) // exising tlk then..
{
OwnedRoxieString diName(helper->getDistributeIndexName());
assertex(diName.get());
tlkDesc.setown(deserializePartFileDescriptor(data));
unsigned c;
data.read(c);
while (c--)
{
RemoteFilename rf;
rf.deserialize(data);
if (!existingTlkIFile)
{
Owned<IFile> iFile = createIFile(rf);
if (iFile->exists())
existingTlkIFile.set(iFile);
}
}
if (!existingTlkIFile)
throw MakeThorException(TE_FileNotFound, "Top level key part does not exist, for key: %s", diName.get());
}
}
}
IOutputMetaData * diskSize = helper->queryDiskRecordSize();
assertex(!(diskSize->getMetaFlags() & MDFneedserializedisk));
if (diskSize->isVariableSize())
{
if (TIWmaxlength & helper->getFlags())
maxDiskRecordSize = helper->getMaxKeySize();
else
maxDiskRecordSize = KEYBUILD_MAXLENGTH; //Current default behaviour, could be improved in the future
}
else
maxDiskRecordSize = diskSize->getFixedSize();
reportOverflow = false;
}
void DataSourceSetItem::serialize(MemoryBuffer & out) const
{
out.append(flags);
record.serialize(out);
out.append(name);
}
void *FastGaussianBlurValueOperation::initializeTileData(rcti *rect)
{
lockMutex();
if (!this->m_iirgaus) {
MemoryBuffer *newBuf = (MemoryBuffer *)this->m_inputprogram->initializeTileData(rect);
MemoryBuffer *copy = newBuf->duplicate();
FastGaussianBlurOperation::IIR_gauss(copy, this->m_sigma, 0, 3);
if (this->m_overlay == FAST_GAUSS_OVERLAY_MIN) {
float *src = newBuf->getBuffer();
float *dst = copy->getBuffer();
for (int i = copy->getWidth() * copy->getHeight(); i != 0; i--, src += COM_NUMBER_OF_CHANNELS, dst += COM_NUMBER_OF_CHANNELS) {
if (*src < *dst) {
*dst = *src;
}
}
}
else if (this->m_overlay == FAST_GAUSS_OVERLAY_MAX) {
float *src = newBuf->getBuffer();
float *dst = copy->getBuffer();
for (int i = copy->getWidth() * copy->getHeight(); i != 0; i--, src += COM_NUMBER_OF_CHANNELS, dst += COM_NUMBER_OF_CHANNELS) {
if (*src > *dst) {
*dst = *src;
}
}
}
// newBuf->
this->m_iirgaus = copy;
}
unlockMutex();
return this->m_iirgaus;
}
void FastGaussianBlurOperation::executePixel(float output[4], int x, int y, void *data)
{
MemoryBuffer *newData = (MemoryBuffer *)data;
newData->read(output, x, y);
}
/// ReadCheckFile - Read the check file, which specifies the sequence of
/// expected strings. The strings are added to the CheckStrings vector.
/// Returns true in case of an error, false otherwise.
static bool ReadCheckFile(SourceMgr &SM,
std::vector<CheckString> &CheckStrings) {
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
MemoryBuffer::getFileOrSTDIN(CheckFilename);
if (std::error_code EC = FileOrErr.getError()) {
errs() << "Could not open check file '" << CheckFilename
<< "': " << EC.message() << '\n';
return true;
}
// If we want to canonicalize whitespace, strip excess whitespace from the
// buffer containing the CHECK lines. Remove DOS style line endings.
MemoryBuffer *F = CanonicalizeInputFile(FileOrErr.get().release(),
NoCanonicalizeWhiteSpace);
SM.AddNewSourceBuffer(F, SMLoc());
// Find all instances of CheckPrefix followed by : in the file.
StringRef Buffer = F->getBuffer();
std::vector<Pattern> DagNotMatches;
// LineNumber keeps track of the line on which CheckPrefix instances are
// found.
unsigned LineNumber = 1;
while (1) {
Check::CheckType CheckTy;
size_t PrefixLoc;
// See if a prefix occurs in the memory buffer.
StringRef UsedPrefix = FindFirstMatchingPrefix(Buffer,
LineNumber,
CheckTy,
PrefixLoc);
if (UsedPrefix.empty())
break;
Buffer = Buffer.drop_front(PrefixLoc);
// Location to use for error messages.
const char *UsedPrefixStart = Buffer.data() + (PrefixLoc == 0 ? 0 : 1);
// PrefixLoc is to the start of the prefix. Skip to the end.
Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize(CheckTy));
// Okay, we found the prefix, yay. Remember the rest of the line, but ignore
// leading and trailing whitespace.
Buffer = Buffer.substr(Buffer.find_first_not_of(" \t"));
// Scan ahead to the end of line.
size_t EOL = Buffer.find_first_of("\n\r");
// Remember the location of the start of the pattern, for diagnostics.
SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data());
// Parse the pattern.
Pattern P(CheckTy);
if (P.ParsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, LineNumber))
return true;
// Verify that CHECK-LABEL lines do not define or use variables
if ((CheckTy == Check::CheckLabel) && P.hasVariable()) {
SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
SourceMgr::DK_Error,
"found '" + UsedPrefix + "-LABEL:'"
" with variable definition or use");
return true;
}
Buffer = Buffer.substr(EOL);
// Verify that CHECK-NEXT lines have at least one CHECK line before them.
if ((CheckTy == Check::CheckNext) && CheckStrings.empty()) {
SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
SourceMgr::DK_Error,
"found '" + UsedPrefix + "-NEXT:' without previous '"
+ UsedPrefix + ": line");
return true;
}
// Handle CHECK-DAG/-NOT.
if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) {
DagNotMatches.push_back(P);
continue;
}
// Okay, add the string we captured to the output vector and move on.
CheckStrings.push_back(CheckString(P,
UsedPrefix,
PatternLoc,
CheckTy));
std::swap(DagNotMatches, CheckStrings.back().DagNotStrings);
}
// Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first
// prefix as a filler for the error message.
if (!DagNotMatches.empty()) {
CheckStrings.push_back(CheckString(Pattern(Check::CheckEOF),
CheckPrefixes[0],
SMLoc::getFromPointer(Buffer.data()),
Check::CheckEOF));
std::swap(DagNotMatches, CheckStrings.back().DagNotStrings);
}
if (CheckStrings.empty()) {
errs() << "error: no check strings found with prefix"
<< (CheckPrefixes.size() > 1 ? "es " : " ");
for (size_t I = 0, N = CheckPrefixes.size(); I != N; ++I) {
StringRef Prefix(CheckPrefixes[I]);
errs() << '\'' << Prefix << ":'";
if (I != N - 1)
errs() << ", ";
}
errs() << '\n';
return true;
}
return false;
}
/// getNewMemBuffer - Allocate a new MemoryBuffer of the specified size that
/// is completely initialized to zeros. Note that the caller should
/// initialize the memory allocated by this method. The memory is owned by
/// the MemoryBuffer object.
MemoryBuffer *MemoryBuffer::getNewMemBuffer(size_t Size, StringRef BufferName) {
MemoryBuffer *SB = getNewUninitMemBuffer(Size, BufferName);
if (!SB) return 0;
memset(const_cast<char*>(SB->getBufferStart()), 0, Size);
return SB;
}
int main(int argc, char **argv) {
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
cl::ParseCommandLineOptions(argc, argv);
if (!ValidateCheckPrefixes()) {
errs() << "Supplied check-prefix is invalid! Prefixes must be unique and "
"start with a letter and contain only alphanumeric characters, "
"hyphens and underscores\n";
return 2;
}
AddCheckPrefixIfNeeded();
SourceMgr SM;
// Read the expected strings from the check file.
std::vector<CheckString> CheckStrings;
if (ReadCheckFile(SM, CheckStrings))
return 2;
// Open the file to check and add it to SourceMgr.
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
MemoryBuffer::getFileOrSTDIN(InputFilename);
if (std::error_code EC = FileOrErr.getError()) {
errs() << "Could not open input file '" << InputFilename
<< "': " << EC.message() << '\n';
return 2;
}
std::unique_ptr<MemoryBuffer> File = std::move(FileOrErr.get());
if (File->getBufferSize() == 0) {
errs() << "FileCheck error: '" << InputFilename << "' is empty.\n";
return 2;
}
// Remove duplicate spaces in the input file if requested.
// Remove DOS style line endings.
MemoryBuffer *F =
CanonicalizeInputFile(File.release(), NoCanonicalizeWhiteSpace);
SM.AddNewSourceBuffer(F, SMLoc());
/// VariableTable - This holds all the current filecheck variables.
StringMap<StringRef> VariableTable;
// Check that we have all of the expected strings, in order, in the input
// file.
StringRef Buffer = F->getBuffer();
bool hasError = false;
unsigned i = 0, j = 0, e = CheckStrings.size();
while (true) {
StringRef CheckRegion;
if (j == e) {
CheckRegion = Buffer;
} else {
const CheckString &CheckLabelStr = CheckStrings[j];
if (CheckLabelStr.CheckTy != Check::CheckLabel) {
++j;
continue;
}
// Scan to next CHECK-LABEL match, ignoring CHECK-NOT and CHECK-DAG
size_t MatchLabelLen = 0;
size_t MatchLabelPos = CheckLabelStr.Check(SM, Buffer, true,
MatchLabelLen, VariableTable);
if (MatchLabelPos == StringRef::npos) {
hasError = true;
break;
}
CheckRegion = Buffer.substr(0, MatchLabelPos + MatchLabelLen);
Buffer = Buffer.substr(MatchLabelPos + MatchLabelLen);
++j;
}
for ( ; i != j; ++i) {
const CheckString &CheckStr = CheckStrings[i];
// Check each string within the scanned region, including a second check
// of any final CHECK-LABEL (to verify CHECK-NOT and CHECK-DAG)
size_t MatchLen = 0;
size_t MatchPos = CheckStr.Check(SM, CheckRegion, false, MatchLen,
VariableTable);
if (MatchPos == StringRef::npos) {
hasError = true;
i = j;
break;
}
CheckRegion = CheckRegion.substr(MatchPos + MatchLen);
}
if (j == e)
break;
}
return hasError ? 1 : 0;
}
virtual void serializeSlaveData(MemoryBuffer &dst, unsigned slave)
{
dst.append((int)mpTagRPC);
dst.append((int)barrier->queryTag());
}
inline RemoteActivityId(MemoryBuffer &in)
{
in.read(activityId);
in.read(queryHash);
}
virtual void serialize(MemoryBuffer &out) { out.append(sizeof(counts), &counts); }
DataSourceDatasetItem::DataSourceDatasetItem(unsigned flags, MemoryBuffer & in) : DataSourceMetaItem(FVFFdataset, NULL, NULL, NULL), record(in)
{
type.setown(makeTableType(NULL));
in.read(name);
}
void CSlavePartMapping::serializeNullMap(MemoryBuffer &mb)
{
mb.append((unsigned)0);
}
int Disassembler::disassembleEnhanced(const std::string &TS,
MemoryBuffer &Buffer) {
ByteArrayTy ByteArray;
StringRef Str = Buffer.getBuffer();
SourceMgr SM;
SM.AddNewSourceBuffer(&Buffer, SMLoc());
if (ByteArrayFromString(ByteArray, Str, SM)) {
return -1;
}
EDDisassemblerRef disassembler;
Triple T(TS);
EDAssemblySyntax_t AS;
switch (T.getArch()) {
default:
errs() << "error: no default assembly syntax for " << TS.c_str() << "\n";
return -1;
case Triple::arm:
case Triple::thumb:
AS = kEDAssemblySyntaxARMUAL;
break;
case Triple::x86:
case Triple::x86_64:
AS = kEDAssemblySyntaxX86ATT;
break;
}
if (EDGetDisassembler(&disassembler,
TS.c_str(),
AS)) {
errs() << "error: couldn't get disassembler for " << TS.c_str() << "\n";
return -1;
}
EDInstRef inst;
if (EDCreateInsts(&inst, 1, disassembler, byteArrayReader, 0,&ByteArray)
!= 1) {
errs() << "error: Didn't get an instruction\n";
return -1;
}
int numTokens = EDNumTokens(inst);
if (numTokens < 0) {
errs() << "error: Couldn't count the instruction's tokens\n";
return -1;
}
int tokenIndex;
for (tokenIndex = 0; tokenIndex < numTokens; ++tokenIndex) {
EDTokenRef token;
if (EDGetToken(&token, inst, tokenIndex)) {
errs() << "error: Couldn't get token\n";
return -1;
}
const char *buf;
if (EDGetTokenString(&buf, token)) {
errs() << "error: Couldn't get string for token\n";
return -1;
}
outs() << "[";
int operandIndex = EDOperandIndexForToken(token);
if (operandIndex >= 0)
outs() << operandIndex << "-";
if (EDTokenIsWhitespace(token)) {
outs() << "w";
} else if (EDTokenIsPunctuation(token)) {
outs() << "p";
} else if (EDTokenIsOpcode(token)) {
outs() << "o";
} else if (EDTokenIsLiteral(token)) {
outs() << "l";
} else if (EDTokenIsRegister(token)) {
outs() << "r";
} else {
outs() << "?";
}
outs() << ":" << buf;
if (EDTokenIsLiteral(token)) {
outs() << "=";
if (EDTokenIsNegativeLiteral(token))
outs() << "-";
uint64_t absoluteValue;
if (EDLiteralTokenAbsoluteValue(&absoluteValue, token)) {
errs() << "error: Couldn't get the value of a literal token\n";
return -1;
}
outs() << absoluteValue;
} else if (EDTokenIsRegister(token)) {
outs() << "=";
unsigned regID;
if (EDRegisterTokenValue(®ID, token)) {
errs() << "error: Couldn't get the ID of a register token\n";
return -1;
}
outs() << "r" << regID;
}
outs() << "]";
}
outs() << " ";
if (EDInstIsBranch(inst))
outs() << "<br> ";
if (EDInstIsMove(inst))
outs() << "<mov> ";
int numOperands = EDNumOperands(inst);
if (numOperands < 0) {
errs() << "error: Couldn't count operands\n";
return -1;
}
int operandIndex;
for (operandIndex = 0; operandIndex < numOperands; ++operandIndex) {
outs() << operandIndex << ":";
EDOperandRef operand;
if (EDGetOperand(&operand,
inst,
operandIndex)) {
errs() << "error: Couldn't get operand\n";
return -1;
}
uint64_t evaluatedResult;
EDEvaluateOperand(&evaluatedResult,
operand,
verboseEvaluator,
&disassembler);
outs() << "=" << evaluatedResult;
outs() << " ";
}
outs() << "\n";
return 0;
}
