ErrVal CabaEncoder::writeExGolombLevel( UInt uiSymbol, CabacContextModel& rcCCModel )
{
if( uiSymbol )
{
RNOK( writeSymbol( 1, rcCCModel ) );
UInt uiCount = 0;
Bool bNoExGo = (uiSymbol < 13);
while( --uiSymbol && ++uiCount < 13 )
{
RNOK( writeSymbol( 1, rcCCModel ) );
}
if( bNoExGo )
{
RNOK( writeSymbol( 0, rcCCModel ) );
}
else
{
RNOK( writeEpExGolomb( uiSymbol, 0 ) );
}
}
else
{
RNOK( writeSymbol( 0, rcCCModel ) );
}
return Err::m_nOK;
}
ErrVal CabaEncoder::writeUnarySymbol( UInt uiSymbol, CabacContextModel* pcCCModel, Int iOffset )
{
RNOK( writeSymbol( uiSymbol ? 1 : 0, pcCCModel[0] ) );
ROTRS( 0 == uiSymbol, Err::m_nOK );
while( uiSymbol-- )
{
RNOK( writeSymbol( uiSymbol ? 1 : 0, pcCCModel[ iOffset ] ) );
}
return Err::m_nOK;
}
void U3DBitStreamWriter::writeCompressedU8(MLuint32 context, MLuint8 uValue)
{
if (context == U3DContext_StaticFull) // In this case a division by zero might occur in _writeSymbol() so we capture it here
{
writeU8(uValue);
}
else
{
_compressed = true;
bool escape = false;
if((context != 0) && (context < U3D_MaxRange))
{
writeSymbol(context, uValue, escape);
if(escape == true)
{
writeU8(uValue);
_contextManager.addSymbol(context, uValue + 1U);
}
}
else
{
writeU8(uValue);
}
}
}
//
// SymExpr
//
void AstDumpToHtml::visitSymExpr(SymExpr* node) {
Symbol* sym = node->var;
VarSymbol* var = toVarSymbol(sym);
if (isBlockStmt(node->parentExpr) == true) {
fprintf(mFP, "<DL>\n");
}
fprintf(mFP, " ");
if (var != 0 && var->immediate != 0) {
const size_t bufSize = 128;
char imm[bufSize];
snprint_imm(imm, bufSize, *var->immediate);
fprintf(mFP, "<i><FONT COLOR=\"blue\">%s%s</FONT></i>", imm, is_imag_type(var->type) ? "i" : "");
} else {
writeSymbol(sym, false);
}
if (isBlockStmt(node->parentExpr)) {
fprintf(mFP, "</DL>\n");
}
}
void MessageEncoder::writeProperties(const Properties& msg)
{
size_t fields(optimise ? optimisable(msg) : 13);
if (fields) {
void* token = startList32(&qpid::amqp::message::PROPERTIES);
if (msg.hasMessageId()) writeString(msg.getMessageId());
else writeNull();
if (msg.hasUserId()) writeBinary(msg.getUserId());
else if (fields > 1) writeNull();
if (msg.hasTo()) writeString(msg.getTo());
else if (fields > 2) writeNull();
if (msg.hasSubject()) writeString(msg.getSubject());
else if (fields > 3) writeNull();
if (msg.hasReplyTo()) writeString(msg.getReplyTo());
else if (fields > 4) writeNull();
if (msg.hasCorrelationId()) writeString(msg.getCorrelationId());
else if (fields > 5) writeNull();
if (msg.hasContentType()) writeSymbol(msg.getContentType());
else if (fields > 6) writeNull();
if (msg.hasContentEncoding()) writeSymbol(msg.getContentEncoding());
else if (fields > 7) writeNull();
if (msg.hasAbsoluteExpiryTime()) writeLong(msg.getAbsoluteExpiryTime());
else if (fields > 8) writeNull();
if (msg.hasCreationTime()) writeLong(msg.getCreationTime());
else if (fields > 9) writeNull();
if (msg.hasGroupId()) writeString(msg.getGroupId());
else if (fields > 10) writeNull();
if (msg.hasGroupSequence()) writeUInt(msg.getGroupSequence());
else if (fields > 11) writeNull();
if (msg.hasReplyToGroupId()) writeString(msg.getReplyToGroupId());
else if (fields > 12) writeNull();
endList32(fields, token);
}
}
ErrVal CabaEncoder::writeUnaryMaxSymbol( UInt uiSymbol, CabacContextModel* pcCCModel, Int iOffset, UInt uiMaxSymbol )
{
RNOK( writeSymbol( uiSymbol ? 1 : 0, pcCCModel[ 0 ] ) );
ROTRS( 0 == uiSymbol, Err::m_nOK );
Bool bCodeLast = ( uiMaxSymbol > uiSymbol );
while( --uiSymbol )
{
RNOK( writeSymbol( 1, pcCCModel[ iOffset ] ) );
}
if( bCodeLast )
{
RNOK( writeSymbol( 0, pcCCModel[ iOffset ] ) );
}
return Err::m_nOK;
}
int msSaveSymbolSetStream(symbolSetObj *symbolset, FILE *stream)
{
int i;
if (!symbolset || !stream) {
msSetError(MS_SYMERR, "Cannot save symbolset.", "msSaveSymbolSetStream()");
return MS_FAILURE;
}
/* Don't ever write out the default symbol at index 0 */
for (i=1; i<symbolset->numsymbols; i++) {
if(!symbolset->symbol[i]->inmapfile) writeSymbol((symbolset->symbol[i]), stream);
}
return MS_SUCCESS;
}
ErrVal CabaEncoder::writeExGolombMvd( UInt uiSymbol, CabacContextModel* pcCCModel, UInt uiMaxBin )
{
if( ! uiSymbol )
{
RNOK( writeSymbol( 0, *pcCCModel ) );
return Err::m_nOK;
}
RNOK( writeSymbol( 1, *pcCCModel ) );
Bool bNoExGo = ( uiSymbol < 8 );
UInt uiCount = 1;
pcCCModel++;
while( --uiSymbol && ++uiCount <= 8 )
{
RNOK( writeSymbol( 1, *pcCCModel ) );
if( uiCount == 2 )
{
pcCCModel++;
}
if( uiCount == uiMaxBin )
{
pcCCModel++;
}
}
if( bNoExGo )
{
RNOK( writeSymbol( 0, *pcCCModel ) );
}
else
{
RNOK( writeEpExGolomb( uiSymbol, 3 ) );
}
return Err::m_nOK;
}
void AstDumpToHtml::writeFnSymbol(FnSymbol* fn) {
bool first = true;
if (fn->_this && fn->_this->defPoint) {
writeSymbol(fn->_this->type->symbol, false);
fprintf(mFP, " . ");
}
writeSymbol(fn, true);
fprintf(mFP, " ( ");
for_formals(formal, fn) {
if (!first) {
fprintf(mFP, " , ");
} else {
first = false;
}
writeSymbol(formal, true);
}
fprintf(mFP, " ) ");
switch (fn->retTag) {
case RET_VALUE: break;
case RET_REF: fprintf(mFP, "<b>ref</b> "); break;
case RET_CONST_REF: fprintf(mFP, "<b>const ref</b> "); break;
case RET_PARAM: fprintf(mFP, "<b>param</b> "); break;
case RET_TYPE: fprintf(mFP, "<b>type</b> "); break;
}
if (fn->retType && fn->retType->symbol) {
fprintf(mFP, " : ");
writeSymbol(fn->retType->symbol, false);
}
}
//
// GotoStmt
//
bool AstDumpToHtml::enterGotoStmt(GotoStmt* node) {
fprintf(mFP, "<DL>\n");
switch (node->gotoTag) {
case GOTO_NORMAL: fprintf(mFP, "<B>goto</B> "); break;
case GOTO_BREAK: fprintf(mFP, "<B>break</B> "); break;
case GOTO_CONTINUE: fprintf(mFP, "<B>continue</B> "); break;
case GOTO_RETURN: fprintf(mFP, "<B>gotoReturn</B> "); break;
case GOTO_GETITER_END: fprintf(mFP, "<B>gotoGetiterEnd</B> "); break;
case GOTO_ITER_RESUME: fprintf(mFP, "<B>gotoIterResume</B> "); break;
case GOTO_ITER_END: fprintf(mFP, "<B>gotoIterEnd</B> "); break;
}
if (SymExpr* label = toSymExpr(node->label))
if (label->var != gNil)
writeSymbol(label->var, true);
return true;
}
void TextOutput::writeSymbols(
const std::string& a,
const std::string& b,
const std::string& c,
const std::string& d,
const std::string& e,
const std::string& f) {
writeSymbol(a);
writeSymbol(b);
writeSymbol(c);
writeSymbol(d);
writeSymbol(e);
writeSymbol(f);
}
void TextOutputStream::writeSymbols(
std::string const & a,
std::string const & b,
std::string const & c,
std::string const & d,
std::string const & e,
std::string const & f)
{
writeSymbol(a);
writeSymbol(b);
writeSymbol(c);
writeSymbol(d);
writeSymbol(e);
writeSymbol(f);
}
void AstDumpToHtml::writeSymbol(Symbol* sym, bool def) {
if (def) {
fprintf(mFP, "<A NAME=\"SYM%d\">", sym->id);
} else if (sym->defPoint && sym->defPoint->parentSymbol && sym->defPoint->getModule()) {
INT_ASSERT(hasHref(sym));
fprintf(mFP, "<A HREF=\"%s#SYM%d\">",
html_file_name(sPassIndex, sym->defPoint->getModule()->name),
sym->id);
} else {
INT_ASSERT(!hasHref(sym));
fprintf(mFP, "<A>");
}
if (isFnSymbol(sym)) {
fprintf(mFP, "<FONT COLOR=\"blue\">");
} else if (isTypeSymbol(sym)) {
fprintf(mFP, "<FONT COLOR=\"green\">");
} else {
fprintf(mFP, "<FONT COLOR=\"red\">");
}
fprintf(mFP, "%s", sym->name);
fprintf(mFP, "</FONT>");
fprintf(mFP, "<FONT COLOR=\"grey\">[%d]</FONT>", sym->id);
fprintf(mFP, "</A>");
if (def &&
!toTypeSymbol(sym) &&
sym->type &&
sym->type->symbol &&
sym->type != dtUnknown) {
fprintf(mFP, ":");
writeSymbol(sym->type->symbol, false);
}
}
bool AstDumpToHtml::open(ModuleSymbol* module, const char* passName) {
const char* name = html_file_name(sPassIndex, module->name);
const char* path = astr(log_dir, name);
mFP = fopen(path, "w");
if (mFP != 0) {
fprintf(sIndexFP, " <a href=\"%s\">%s</a>\n", name, module->name);
fprintf(mFP, "<CHPLTAG=\"%s\">\n", passName);
fprintf(mFP, "<HTML>\n");
fprintf(mFP, "<HEAD>\n");
fprintf(mFP, "<TITLE> AST for Module %s after Pass %s </TITLE>\n", module->name, passName);
fprintf(mFP, "<SCRIPT SRC=\"http://chapel.cray.com/developer/mktree.js\" LANGUAGE=\"JavaScript\"></SCRIPT>\n");
fprintf(mFP, "<LINK REL=\"stylesheet\" HREF=\"http://chapel.cray.com/developer/mktree.css\">\n");
fprintf(mFP, "</HEAD><BODY%s>\n",
fdump_html_wrap_lines ? "" : " style=\"white-space: nowrap;\"");
if (currentPassNo > 1)
fprintf(mFP, "<A HREF=%s>previous pass</A> \n", html_file_name(currentPassNo - 1, module->name));
if (true)
fprintf(mFP, "<A HREF=%s>next pass</A>\n", html_file_name(currentPassNo + 1, module->name));
fprintf(mFP, "<div style=\"text-align: center;\"><big><big><span style=\"font-weight: bold;\">");
fprintf(mFP, "AST for Module %s after Pass %s <br><br></span></big></big>\n", module->name, passName);
fprintf(mFP, "<div style=\"text-align: left;\">\n\n");
fprintf(mFP, "<B>module \n");
writeSymbol(module, true);
fprintf(mFP, "</B>\n");
}
return (mFP != 0) ? true : false;
}
void MachoExport::exportStore(void)
{
PolyWord *p;
#if (SIZEOF_VOIDP == 8)
struct mach_header_64 fhdr;
struct segment_command_64 sHdr;
struct section_64 *sections = new section_64[memTableEntries+1];
size_t sectionSize = sizeof(section_64);
#else
struct mach_header fhdr;
struct segment_command sHdr;
struct section *sections = new section[memTableEntries+1];
size_t sectionSize = sizeof(section);
#endif
struct symtab_command symTab;
unsigned i;
// Write out initial values for the headers. These are overwritten at the end.
// File header
memset(&fhdr, 0, sizeof(fhdr));
fhdr.filetype = MH_OBJECT;
fhdr.ncmds = 2; // One for the segment and one for the symbol table.
fhdr.sizeofcmds = sizeof(sHdr) + sectionSize * (memTableEntries+1) + sizeof(symTab);
fhdr.flags = 0;
// The machine needs to match the machine we're compiling for
// even if this is actually portable code.
#if (SIZEOF_VOIDP == 8)
fhdr.magic = MH_MAGIC_64; // (0xfeedfacf) 64-bit magic number
#else
fhdr.magic = MH_MAGIC; // Feed Face (0xfeedface)
#endif
#if defined(HOSTARCHITECTURE_X86)
fhdr.cputype = CPU_TYPE_I386;
fhdr.cpusubtype = CPU_SUBTYPE_I386_ALL;
#elif defined(HOSTARCHITECTURE_PPC)
fhdr.cputype = CPU_TYPE_POWERPC;
fhdr.cpusubtype = CPU_SUBTYPE_POWERPC_ALL;
#elif defined(HOSTARCHITECTURE_X86_64)
fhdr.cputype = CPU_TYPE_X86_64;
fhdr.cpusubtype = CPU_SUBTYPE_X86_64_ALL;
#else
#error "No support for exporting on this architecture"
#endif
fwrite(&fhdr, sizeof(fhdr), 1, exportFile); // Write it for the moment.
// Segment header.
memset(&sHdr, 0, sizeof(sHdr));
#if (SIZEOF_VOIDP == 8)
sHdr.cmd = LC_SEGMENT_64;
#else
sHdr.cmd = LC_SEGMENT;
#endif
sHdr.nsects = memTableEntries+1; // One for each entry plus one for the tables.
sHdr.cmdsize = sizeof(sHdr) + sectionSize * sHdr.nsects;
// Add up the sections to give the file size
sHdr.filesize = 0;
for (i = 0; i < memTableEntries; i++)
sHdr.filesize += memTable[i].mtLength; // Do we need any alignment?
sHdr.filesize += sizeof(exportDescription) + memTableEntries * sizeof(memoryTableEntry);
sHdr.vmsize = sHdr.filesize; // Set them the same since we don't have any "common" area.
// sHdr.fileOff is set later.
sHdr.maxprot = VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE;
sHdr.initprot = VM_PROT_READ|VM_PROT_WRITE|VM_PROT_EXECUTE;
sHdr.flags = 0;
// Write it initially.
fwrite(&sHdr, sizeof(sHdr), 1, exportFile);
// Section header for each entry in the table
POLYUNSIGNED sectAddr = sizeof(exportDescription)+sizeof(memoryTableEntry)*memTableEntries;
for (i = 0; i < memTableEntries; i++)
{
memset(&(sections[i]), 0, sectionSize);
if (memTable[i].mtFlags & MTF_WRITEABLE)
{
// Mutable areas
ASSERT(!(memTable[i].mtFlags & MTF_EXECUTABLE)); // Executable areas can't be writable.
sprintf(sections[i].sectname, "__data");
sprintf(sections[i].segname, "__DATA");
sections[i].flags = S_ATTR_LOC_RELOC | S_REGULAR;
}
else if (memTable[i].mtFlags & MTF_EXECUTABLE)
{
sprintf(sections[i].sectname, "__text");
sprintf(sections[i].segname, "__TEXT");
sections[i].flags = S_ATTR_LOC_RELOC | S_ATTR_SOME_INSTRUCTIONS | S_REGULAR;
}
else
{
sprintf(sections[i].sectname, "__const");
sprintf(sections[i].segname, "__DATA");
sections[i].flags = S_ATTR_LOC_RELOC | S_REGULAR;
}
sections[i].addr = sectAddr;
sections[i].size = memTable[i].mtLength;
sectAddr += memTable[i].mtLength;
//sections[i].offset is set later
//sections[i].reloff is set later
//sections[i].nreloc is set later
sections[i].align = 3; // 8 byte alignment
// theSection.size is set later
}
// For the tables.
memset(&(sections[memTableEntries]), 0, sectionSize);
sprintf(sections[memTableEntries].sectname, "__const");
sprintf(sections[memTableEntries].segname, "__DATA");
sections[memTableEntries].addr = 0;
sections[memTableEntries].size = sizeof(exportDescription)+sizeof(memoryTableEntry)*memTableEntries;
sections[memTableEntries].align = 3; // 8 byte alignment
// theSection.size is set later
sections[memTableEntries].flags = S_ATTR_LOC_RELOC | S_ATTR_SOME_INSTRUCTIONS | S_REGULAR;
// Write them out for the moment.
fwrite(sections, sectionSize * (memTableEntries+1), 1, exportFile);
// Symbol table header.
memset(&symTab, 0, sizeof(symTab));
symTab.cmd = LC_SYMTAB;
symTab.cmdsize = sizeof(symTab);
//symTab.symoff is set later
//symTab.nsyms is set later
//symTab.stroff is set later
//symTab.strsize is set later
fwrite(&symTab, sizeof(symTab), 1, exportFile);
// Create the symbol table first before we mess up the addresses by turning them
// into relocations.
symTab.symoff = ftell(exportFile);
// Global symbols: Just one. Mach prefixes symbols with an underscore.
writeSymbol("_poly_exports", N_EXT | N_SECT, memTableEntries, 0); // The export table comes first
// We create local symbols because they make debugging easier. They may also
// mean that we can use the usual Unix profiling tools.
writeSymbol("memTable", N_SECT, memTableEntries, sizeof(exportDescription)); // Then the memTable.
for (i = 0; i < memTableEntries; i++)
{
if (i == ioMemEntry)
writeSymbol("ioarea", N_SECT, i, 0);
else {
char buff[50];
sprintf(buff, "area%0d", i);
writeSymbol(buff, N_SECT, i, 0);
#if (SIZEOF_VOIDP == 8)
// See if we can find the names of any functions.
// This seems to break on 32-bit Mac OS X. It seems to align
// some relocations onto an 8-byte boundary so we just disable it.
char *start = (char*)memTable[i].mtAddr;
char *end = start + memTable[i].mtLength;
for (p = (PolyWord*)start; p < (PolyWord*)end; )
{
p++;
PolyObject *obj = (PolyObject*)p;
POLYUNSIGNED length = obj->Length();
if (length != 0 && obj->IsCodeObject())
{
PolyWord *name = obj->ConstPtrForCode();
// Copy as much of the name as will fit and ignore any extra.
// Do we need to worry about duplicates?
(void)Poly_string_to_C(*name, buff, sizeof(buff));
writeSymbol(buff, N_SECT, i, (char*)p - start);
}
p += length;
}
#endif
}
}
symTab.nsyms = symbolCount;
// Create and write out the relocations.
for (i = 0; i < memTableEntries; i++)
{
sections[i].reloff = ftell(exportFile);
relocationCount = 0;
if (i != ioMemEntry) // Don't relocate the IO area
{
// Create the relocation table and turn all addresses into offsets.
char *start = (char*)memTable[i].mtAddr;
char *end = start + memTable[i].mtLength;
for (p = (PolyWord*)start; p < (PolyWord*)end; )
{
p++;
PolyObject *obj = (PolyObject*)p;
POLYUNSIGNED length = obj->Length();
if (length != 0 && obj->IsCodeObject())
machineDependent->ScanConstantsWithinCode(obj, this);
relocateObject(obj);
p += length;
}
}
sections[i].nreloc = relocationCount;
}
// Additional relocations for the descriptors.
sections[memTableEntries].reloff = ftell(exportFile);
relocationCount = 0;
// Address of "memTable" within "exports". We can't use createRelocation because
// the position of the relocation is not in either the mutable or the immutable area.
createStructsRelocation(memTableEntries, offsetof(exportDescription, memTable));
// Address of "rootFunction" within "exports"
unsigned rootAddrArea = findArea(rootFunction);
POLYUNSIGNED rootOffset = (char*)rootFunction - (char*)memTable[rootAddrArea].mtAddr;
adjustOffset(rootAddrArea, rootOffset);
createStructsRelocation(rootAddrArea, offsetof(exportDescription, rootFunction));
// Addresses of the areas within memtable.
for (i = 0; i < memTableEntries; i++)
{
createStructsRelocation(i,
sizeof(exportDescription) + i * sizeof(memoryTableEntry) + offsetof(memoryTableEntry, mtAddr));
}
sections[memTableEntries].nreloc = relocationCount;
// The symbol name table
symTab.stroff = ftell(exportFile);
fwrite(stringTable.strings, stringTable.stringSize, 1, exportFile);
symTab.strsize = stringTable.stringSize;
alignFile(4);
exportDescription exports;
memset(&exports, 0, sizeof(exports));
exports.structLength = sizeof(exportDescription);
exports.memTableSize = sizeof(memoryTableEntry);
exports.memTableEntries = memTableEntries;
exports.ioIndex = 0; // The io entry is the first in the memory table
exports.memTable = (memoryTableEntry *)sizeof(exportDescription); // It follows immediately after this.
// Set the value to be the offset relative to the base of the area. We have set a relocation
// already which will add the base of the area.
exports.rootFunction = (void*)rootOffset;
exports.timeStamp = time(NULL);
exports.ioSpacing = ioSpacing;
exports.architecture = machineDependent->MachineArchitecture();
exports.rtsVersion = POLY_version_number;
sections[memTableEntries].offset = ftell(exportFile);
fwrite(&exports, sizeof(exports), 1, exportFile);
POLYUNSIGNED addrOffset = sizeof(exports)+sizeof(memoryTableEntry)*memTableEntries;
for (i = 0; i < memTableEntries; i++)
{
void *save = memTable[i].mtAddr;
memTable[i].mtAddr = (void*)addrOffset; // Set this to the relative address.
addrOffset += memTable[i].mtLength;
fwrite(&memTable[i], sizeof(memoryTableEntry), 1, exportFile);
memTable[i].mtAddr = save;
}
// Now the binary data.
for (i = 0; i < memTableEntries; i++)
{
alignFile(4);
sections[i].offset = ftell(exportFile);
fwrite(memTable[i].mtAddr, 1, memTable[i].mtLength, exportFile);
}
// Rewind to rewrite the headers with the actual offsets.
rewind(exportFile);
fwrite(&fhdr, sizeof(fhdr), 1, exportFile); // File header
fwrite(&sHdr, sizeof(sHdr), 1, exportFile); // Segment header
fwrite(sections, sectionSize * (memTableEntries+1), 1, exportFile); // Section headers
fwrite(&symTab, sizeof(symTab), 1, exportFile); // Symbol table header
fclose(exportFile); exportFile = NULL;
delete[](sections);
}
void writeRIFF(const IndexFileOut &Data, llvm::raw_ostream &OS) {
assert(Data.Symbols && "An index file without symbols makes no sense!");
riff::File RIFF;
RIFF.Type = riff::fourCC("CdIx");
llvm::SmallString<4> Meta;
{
llvm::raw_svector_ostream MetaOS(Meta);
write32(Version, MetaOS);
}
RIFF.Chunks.push_back({riff::fourCC("meta"), Meta});
StringTableOut Strings;
std::vector<Symbol> Symbols;
for (const auto &Sym : *Data.Symbols) {
Symbols.emplace_back(Sym);
visitStrings(Symbols.back(),
[&](llvm::StringRef &S) { Strings.intern(S); });
}
std::vector<IncludeGraphNode> Sources;
if (Data.Sources)
for (const auto &Source : *Data.Sources) {
Sources.push_back(Source.getValue());
visitStrings(Sources.back(),
[&](llvm::StringRef &S) { Strings.intern(S); });
}
std::vector<std::pair<SymbolID, std::vector<Ref>>> Refs;
if (Data.Refs) {
for (const auto &Sym : *Data.Refs) {
Refs.emplace_back(Sym);
for (auto &Ref : Refs.back().second) {
llvm::StringRef File = Ref.Location.FileURI;
Strings.intern(File);
Ref.Location.FileURI = File.data();
}
}
}
std::string StringSection;
{
llvm::raw_string_ostream StringOS(StringSection);
Strings.finalize(StringOS);
}
RIFF.Chunks.push_back({riff::fourCC("stri"), StringSection});
std::string SymbolSection;
{
llvm::raw_string_ostream SymbolOS(SymbolSection);
for (const auto &Sym : Symbols)
writeSymbol(Sym, Strings, SymbolOS);
}
RIFF.Chunks.push_back({riff::fourCC("symb"), SymbolSection});
std::string RefsSection;
if (Data.Refs) {
{
llvm::raw_string_ostream RefsOS(RefsSection);
for (const auto &Sym : Refs)
writeRefs(Sym.first, Sym.second, Strings, RefsOS);
}
RIFF.Chunks.push_back({riff::fourCC("refs"), RefsSection});
}
std::string SrcsSection;
{
{
llvm::raw_string_ostream SrcsOS(SrcsSection);
for (const auto &SF : Sources)
writeIncludeGraphNode(SF, Strings, SrcsOS);
}
RIFF.Chunks.push_back({riff::fourCC("srcs"), SrcsSection});
}
OS << RIFF;
}
//
// DefExpr
//
bool AstDumpToHtml::enterDefExpr(DefExpr* node) {
bool retval = true;
if (isBlockStmt(node->parentExpr)) {
fprintf(mFP, "<DL>\n");
}
fprintf(mFP, " ");
if (FnSymbol* fn = toFnSymbol(node->sym)) {
fprintf(mFP, "<UL CLASS =\"mktree\">\n<LI>");
adjacent_passes(fn);
fprintf(mFP, "<CHPLTAG=\"FN%d\">\n", fn->id);
fprintf(mFP, "<B>function ");
writeFnSymbol(fn);
fprintf(mFP, "</B><UL>\n");
} else if (isTypeSymbol(node->sym)) {
if (toAggregateType(node->sym->type)) {
fprintf(mFP, "<UL CLASS =\"mktree\">\n");
fprintf(mFP, "<LI>");
if (node->sym->hasFlag(FLAG_SYNC))
fprintf(mFP, "<B>sync</B> ");
if (node->sym->hasFlag(FLAG_SINGLE))
fprintf(mFP, "<B>single</B> ");
fprintf(mFP, "<B>type ");
writeSymbol(node->sym, true);
fprintf(mFP, "</B><UL>\n");
} else {
fprintf(mFP, "<B>type </B> ");
writeSymbol(node->sym, true);
}
} else if (VarSymbol* vs = toVarSymbol(node->sym)) {
if (vs->type->symbol->hasFlag(FLAG_SYNC))
fprintf(mFP, "<B>sync </B>");
if (vs->type->symbol->hasFlag(FLAG_SINGLE))
fprintf(mFP, "<B>single </B>");
fprintf(mFP, "<B>var </B> ");
writeSymbol(node->sym, true);
} else if (ArgSymbol* s = toArgSymbol(node->sym)) {
switch (s->intent) {
case INTENT_IN: fprintf(mFP, "<B>in</B> "); break;
case INTENT_INOUT: fprintf(mFP, "<B>inout</B> "); break;
case INTENT_OUT: fprintf(mFP, "<B>out</B> "); break;
case INTENT_CONST: fprintf(mFP, "<B>const</B> "); break;
case INTENT_CONST_IN: fprintf(mFP, "<B>const in</B> "); break;
case INTENT_CONST_REF: fprintf(mFP, "<B>const ref</B> "); break;
case INTENT_REF: fprintf(mFP, "<B>ref</B> "); break;
case INTENT_PARAM: fprintf(mFP, "<B>param</B> "); break;
case INTENT_TYPE: fprintf(mFP, "<B>type</B> "); break;
case INTENT_BLANK: break;
}
fprintf(mFP, "<B>arg</B> ");
writeSymbol(node->sym, true);
} else if (isLabelSymbol(node->sym)) {
fprintf(mFP, "<B>label</B> ");
writeSymbol(node->sym, true);
} else if (isModuleSymbol(node->sym)) {
fprintf(mFP, "</DL>\n");
// Don't process nested modules -- they'll be handled at the top-level
retval = false;
} else {
fprintf(mFP, "<B>def</B> ");
writeSymbol(node->sym, true);
}
return retval;
}
