[_CDCSL_93-16_]<1>Cedar>release>Cirio>XCOFFFiles.mesa

XCOFFFiles.mesa

Modified from DotOAccessImpl.mesa

Laurie Horton, June 24, 1992 6:07 pm PDT

Philip James, February 24, 1992 11:40 am PST

Last tweaked by Mike Spreitzer October 2, 1992 1:27 pm PDT

Chauser, March 24, 1992 5:25 pm PST

Katsuyuki Komatsu June 21, 1992 1:55 pm PDT

DIRECTORY

Basics USING [BITAND, BITOR, Card16FromH, Card32FromF, Comparison, FWORD, HWORD],

BasicTime USING [GMT, Now],

CCTypes USING[CCError, CCErrorCase],

CirioTypes USING [zeroBA],

Commander USING [Register, CommandProc],

CommanderOps USING [ArgumentVector, Parse],

Convert USING[IntFromRope, RopeFromChar],

IO USING[card, EndOf, GetChar, GetFWord, GetHWord, PeekChar, PutF, PutFR, SetIndex, STREAM, time, UnsafeGetBlock],

List USING[LORA, CompareProc, Sort],

ObjectFiles USING [BracketNest, BracketPairKind, CNameOfStab, CreateParsed, FileSegmentPC, GlobalVarLoc, MakeUnknownVarLoc, RopeForStabType, SimpleSeg, Stab, StabBody, StabType, unspecdBitSize, VarLoc, VarLocBody, VersionStampInfo],

ObjectFilesPrivate USING [AlterFunStabType, BracketPair, BracketPairBody, CheckStaticVar, FunStabInfo, FunStabSet, GetSPOffsetType, GetTypeRefProcType, HeaderBody, InstallStaticVarsType, LineNumToPCMapBody, MemorySegmentInfo, Module, ModuleBody, ModuleFromParsedAndPCProcType, ObjectFileFlavorBody, Parsed, ParsedBody, PCtoLineNumMapBody, RaiseUnreadableObjectFileForFun, ReadHeaderProcType, ReadInitialDataAsRope, ReadStab, ReadStabRope, RegisterObjectFileFlavor, ScanSymbolStabs, SLineData, StabList, StabRange, StabSet, TranslationTable, TranslationTableBody, VarLocFromStabProcType],

PFS USING [PathFromRope, RopeFromPath, StreamFromOpenFile, OpenFileFromStream],

PFSNames USING [PATH],

Random USING [ChooseInt, Create, RandomStream],

RCTW USING [GetTokenRope, RCTWData, RCTWDataBody],

Rope USING[Concat, Equal, Fetch, FromChar, Index, IsEmpty, Length, Match, ROPE],

SystemInterface USING[CirioFile, CloseFileSet, CreateFileSet, FileSet, GetCirioFile, GetStreamForFile, ReleaseStreamForFile];

XCOFFFiles: CEDAR MONITOR

IMPORTS Basics, BasicTime, CCTypes, Commander, CommanderOps, Convert, IO, List, ObjectFiles, ObjectFilesPrivate, PFS, Random, RCTW, Rope, SystemInterface

EXPORTS ObjectFiles

= BEGIN

CCError: ERROR[case: CCTypes.CCErrorCase, msg: Rope.ROPE ¬ NIL] ¬ CCTypes.CCError;

Useful types

ROPE: TYPE ~ Rope.ROPE;

PATH: TYPE ~ PFSNames.PATH;

Following types are defined in ObjectFiles

Stab: TYPE = ObjectFiles.Stab;

StabBody: TYPE = ObjectFiles.StabBody;

StabType: TYPE = ObjectFiles.StabType;

FileSegmentPC: TYPE = ObjectFiles.FileSegmentPC;

VersionStampInfo: TYPE = ObjectFiles.VersionStampInfo;

some Stab types

Block: BYTE = 64H;

Brac: BYTE = 65H;

LBrac: BYTE = 00H;

RBrac: BYTE = 00H;

Fun: BYTE = 8eH;

SLine: BYTE = 00H;

STSym: BYTE = 85H;

LCSym: BYTE = 00H;

Decl: BYTE = 8cH;

GSym: BYTE = 80H;

PSym: BYTE = 82H;

LSym: BYTE = 81H;

RSym: BYTE = 83H;

SO: BYTE = 67H;

HidEnt: BYTE = 6bH;

interesting symbol type

XTYSD: BYTE = 1; -- CSECT Section Definition --

interesting storage mapping class

XMCRW: BYTE = 5; -- Read Write Data --

Following types are defined in ObjectFilesPrivate

Parsed: TYPE = REF ParsedBody;

ParsedBody: PUBLIC TYPE = ObjectFilesPrivate.ParsedBody;

Header: TYPE = REF HeaderBody;

HeaderBody: PUBLIC TYPE = ObjectFilesPrivate.HeaderBody;

Module: TYPE = REF ModuleBody;

ModuleBody: PUBLIC TYPE = ObjectFilesPrivate.ModuleBody;

StabList: TYPE = ObjectFilesPrivate.StabList;

StabSet: TYPE = ObjectFilesPrivate.StabSet;

StabRange: TYPE = ObjectFilesPrivate.StabRange;

MemorySegmentInfo: TYPE ~ ObjectFilesPrivate.MemorySegmentInfo;

Following values are of global interest

unspecdBitSize: CARD ~ ObjectFiles.unspecdBitSize;

pj theContStab: Stab ~ [edo: NIL, stabX: CARD.LAST, stringX: CARD32.LAST, type: BYTE.LAST, other: BYTE.LAST, desc: CARD16.LAST, value: CARD32.LAST, rope: "don't look at me, I'm a continuation of an earlier stab", dx: CARD.LAST];

This stab is put in edo.stabs[i] wherever continuation stabs would appear.

DotOCookies

The following computations are adapted from /usr/include/sys/exec.h,

obtained by: REdit cartiff -f /usr/include/sys/exec.h

MOldsun2: CARD = 0;

M68010: CARD = 1;

M68020: CARD = 2;

MSparc: CARD = 3;

OMagic: CARD16 = 0407B;

NMagic: CARD16 = 0410B;

ZMagic: CARD16 = 0413B;

The following computations are adapted from /usr/include/sun4/a.out.h,

obtained by: REdit cartiff -f /usr/include/sun4/a.out.h

PageSize: CARD32 = 02000H;

OldPageSize: CARD32 = 00800H;

The following symbols are adapted from /usr/include/filehdr.h

FRelFlg: CARD16 = 0001H;

FExec: CARD16 = 0002H;

FLnNo: CARD16 = 0004H;

FLSyms: CARD16 = 0008H;

FAr16WR: CARD16 = 0080H;

FAr32WR: CARD16 = 0100H;

FAr32W: CARD16 = 0200H;

FDynLoad: CARD16 = 1000H;

FShrObj: CARD16 = 2000H;

FLdMinusR: CARD16 = 8000H;

The following record type was constructed based on page 1339 of the Sun Release 4.0 documentation (A.OUT documentation)

WireHeader: TYPE = REF WireHeaderBody;

WireHeaderBody: TYPE = MACHINE DEPENDENT RECORD[

magic: Basics.HWORD,

numSections: Basics.HWORD,

timeDate: Basics.FWORD,

symPtr: Basics.FWORD,

numSyms: Basics.FWORD,

sizeOptHdr: Basics.HWORD,

flags: Basics.HWORD];

SectionList: TYPE = REF SectionListBody;

SectionListBody: TYPE = RECORD[

list: SEQUENCE length: CARD OF SectionHeader];

SectionHeader: TYPE = REF SectionHeaderBody;

SectionHeaderBody: TYPE = MACHINE DEPENDENT RECORD[

pAddr: CARD32,

vAddr: CARD32,

size: CARD32,

dataPtr: CARD32,

relocPtr: CARD32,

lnnoPtr: CARD32,

numRelocEntries: CARD16,

numLnnoEntries: CARD16,

flags: CARD32];

WireSectionHeader: TYPE = REF WireSectionHeaderBody;

WireSectionHeaderBody: TYPE = MACHINE DEPENDENT RECORD[

pAddr: Basics.FWORD,

vAddr: Basics.FWORD,

size: Basics.FWORD,

dataPtr: Basics.FWORD,

relocPtr: Basics.FWORD,

lnnoPtr: Basics.FWORD,

numRelocEntries: Basics.HWORD,

numLnnoEntries: Basics.HWORD,

flags: Basics.FWORD];

WireAuxHeader: TYPE = REF WireAuxHeaderBody;

WireAuxHeaderBody: TYPE = MACHINE DEPENDENT RECORD[

magic: Basics.HWORD,

vStamp: Basics.HWORD,

textSize: Basics.FWORD,

dataSize: Basics.FWORD,

bssSize: Basics.FWORD,

entryPtr: Basics.FWORD,

textBase: Basics.FWORD,

dataBase: Basics.FWORD,

tocAddress: Basics.FWORD,

entryPtSectionNum: Basics.HWORD,

textSectionNum: Basics.HWORD,

dataSectionNum: Basics.HWORD,

tocSectionNum: Basics.HWORD,

loaderSectionNum: Basics.HWORD,

bssSectionNum: Basics.HWORD,

maxAlignmentForText: Basics.HWORD,

maxAlignmentForData: Basics.HWORD,

moduleTypeField: ARRAY [0..1] OF BYTE,

reservedField: ARRAY [0..1] OF BYTE,

maxStackSize: Basics.FWORD,

reservedFields: ARRAY [0..3] OF Basics.FWORD

];

ByteEntry: TYPE = REF ByteEntryBody;

ByteEntryBody: TYPE = MACHINE DEPENDENT RECORD[

val(0:0..7): BYTE];

TwoByteEntry: TYPE = REF TwoByteEntryBody;

TwoByteEntryBody: TYPE = MACHINE DEPENDENT RECORD[

val(0:0..15): Basics.HWORD];

StabSize: CARD ¬ 18;

WireSTEntry: TYPE = REF WireSTEntryBody;

WireSTEntryBody: TYPE = MACHINE DEPENDENT RECORD[

name(0: 0..63): PACKED ARRAY [0..7] OF BYTE,

value(0: 64..95): Basics.FWORD,

sectionNumber(0: 96..111): Basics.HWORD,

derivedType(0: 112..119): BYTE,

type(0: 120..127): BYTE,

storageClass(0: 128..135): BYTE,

numAuxEntries(0: 136..143): BYTE,

pad(0: 144..159): Basics.HWORD

];

AuxType: TYPE = {symbol, file, csect};

WireSTAuxEntry: TYPE = REF WireSTAuxEntryBody;

WireSTAuxEntryBody: TYPE = MACHINE DEPENDENT RECORD[

aux(0: 0..159): SELECT OVERLAID AuxType FROM

symbol => [

name(0: 0..63): PACKED ARRAY [0..7] OF BYTE,

pad(0: 64..159): Basics.HWORD],

file => [

fileName(0: 0..111): PACKED ARRAY [0..13] OF BYTE,

pad(0: 112..159): Basics.HWORD],

csect => [

csectLength(0: 0..31): Basics.FWORD,

parameterType(0: 32..63): Basics.FWORD,

snParameterType(0: 64..79): Basics.HWORD,

alignment(0: 80..84): [0..31],

symbolType(0: 85..87): [0..7],

storageMappingClass(0: 88..95): BYTE,

stab(0: 96..127): Basics.FWORD,

snStab(0: 128..143): Basics.HWORD,

pad(0: 144..159): Basics.HWORD]

ENDCASE];

ReadHeader: ObjectFilesPrivate.ReadHeaderProcType ~ TRUSTED {

PROC[stream: IO.STREAM] RETURNS[Header] = TRUSTED {

wHeader: WireHeader ¬ NEW[WireHeaderBody];

wAuxHeader: WireAuxHeader ¬ NEW[WireAuxHeaderBody];

nBytes: INT ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wHeader], 0, BYTES[WireHeaderBody]]];

nBytes2: INT ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wAuxHeader], 0, Basics.Card16FromH[wHeader.sizeOptHdr]]];

magic: CARD ¬ Basics.Card16FromH[wHeader.magic];

nBadMagic: BOOLEAN ¬ (magic # OMagic) AND (magic # NMagic)AND (magic # ZMagic);

flags: CARD ¬ Basics.Card16FromH[wHeader.flags];

The following computations are adapted from /usr/include/sun4/a.out.h,

obtained by: REdit cartiff -f /usr/include/sun4/a.out.h

nPageSize: CARD ¬ 01000H;

IF wHeader.machtype = MOldsun2 THEN OldPageSize ELSE PageSize;

SymbolSize: CARD ¬ 18;

RelocEntrySize: CARD ¬ 10;

LnnoEntrySize: CARD ¬ 6;

textOffset: CARD ¬ Basics.Card32FromF[wAuxHeader.textBase];

IF wHeader.machtype = MOldsun2 THEN

(IF magic = ZMagic THEN nPageSize ELSE BYTES[WireHeaderBody])

ELSE

(IF magic = ZMagic THEN 0 ELSE BYTES[WireHeaderBody]);

textSize: CARD ¬ Basics.Card32FromF[wAuxHeader.textSize];

iDataSeg: MemorySegmentInfo ¬ [Basics.Card32FromF[wAuxHeader.dataBase], Basics.Card32FromF[wAuxHeader.dataSize]];

iDataSeg: SegmentInfo ← [textOffset + textSize, Basics.Card32FromF[wHeader.iDataSize]];

symsSeg: MemorySegmentInfo ¬ [Basics.Card32FromF[wHeader.symPtr], Basics.Card32FromF[wHeader.numSyms] * SymbolSize];

dataRelocSeg.byteOffset+dataRelocSeg.byteLength, Basics.Card32FromF[wHeader.symsSize]];

debugSeg: MemorySegmentInfo ← [Basics.Card32FromF[wHeader.symPtr], Basics.Card32FromF[wHeader.numSyms] * SymbolSize];

textLoadOffset: CARD32 ¬ 0;

IF magic = ZMagic THEN 02000H ELSE 0;

text segment is loaded into memory at nominal 0 + textLoadOffset

the 02000H is the largest page size on certain machines, and allows the first page of memory to remain unmapped.

linnoSeg, debugSeg, textRelocSeg, dataRelocSeg: MemorySegmentInfo ¬ [0, 0];

iDataSeg.byteOffset+iDataSeg.byteLength, Basics.Card32FromF[wHeader.trSize]];

textRelocSeg.byteOffset+textRelocSeg.byteLength, Basics.Card32FromF[wHeader.drSize]]

numSects: CARD ¬ Basics.Card16FromH[wHeader.numSections];

sectionList: SectionList ¬ NEW[SectionListBody[numSects]];

debugIndex, textIndex, dataIndex: CARD ¬ LAST[CARD];

header: Header;

FOR i: CARD IN [0..numSects) DO

wSectionHeader: WireSectionHeader ¬ NEW[WireSectionHeaderBody];

nBytes: INT ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wSectionHeader], 0, BYTES[WireSectionHeaderBody]]];

sectionList[i] ¬ NEW[SectionHeaderBody];

FOR j: CARD IN [0..8) DO

c: CARD ¬ wSectionHeader.name[j];

ch: CHAR ¬ VAL[c];

IF c = 0 THEN EXIT;

sectionList[i].name ¬ sectionList[i].name.Concat[Convert.RopeFromChar[from: ch, quote: FALSE]];

ENDLOOP;

sectionList[i].pAddr ¬ Basics.Card32FromF[wSectionHeader.pAddr];

sectionList[i].vAddr ¬ Basics.Card32FromF[wSectionHeader.vAddr];

sectionList[i].size ¬ Basics.Card32FromF[wSectionHeader.size];

sectionList[i].dataPtr ¬ Basics.Card32FromF[wSectionHeader.dataPtr];

sectionList[i].relocPtr ¬ Basics.Card32FromF[wSectionHeader.relocPtr];

sectionList[i].lnnoPtr ¬ Basics.Card32FromF[wSectionHeader.lnnoPtr];

sectionList[i].numRelocEntries ¬ Basics.Card16FromH[wSectionHeader.numRelocEntries];

sectionList[i].numLnnoEntries ¬ Basics.Card16FromH[wSectionHeader.numLnnoEntries];

sectionList[i].flags ¬ Basics.Card32FromF[wSectionHeader.flags];

ENDLOOP;

FOR i: CARD IN [0..numSects) DO

IF Rope.Equal[sectionList[i].name, ".debug", TRUE] THEN debugIndex ¬ i;

IF Rope.Equal[sectionList[i].name, ".text", TRUE] THEN textIndex ¬ i;

IF Rope.Equal[sectionList[i].name, ".data", TRUE] THEN dataIndex ¬ i;

IF Rope.Equal[sectionList[i].name, ".loader", TRUE] THEN flags ¬ Basics.BITOR[flags, FLdMinusR];

ENDLOOP;

IF debugIndex # LAST[CARD] THEN {

debugSeg ¬ [sectionList[debugIndex].dataPtr, sectionList[debugIndex].size];

};

IF textIndex # LAST[CARD] THEN {

linnoSeg ¬ [sectionList[textIndex].lnnoPtr, sectionList[textIndex].numLnnoEntries * LnnoEntrySize];

textOffset ¬ sectionList[textIndex].dataPtr;

textRelocSeg ¬ [sectionList[textIndex].relocPtr, sectionList[textIndex].numRelocEntries * RelocEntrySize];

};

IF dataIndex # LAST[CARD] THEN {

iDataSeg.byteOffset ¬ sectionList[dataIndex].dataPtr;

dataRelocSeg ¬ [sectionList[dataIndex].relocPtr, sectionList[dataIndex].numRelocEntries * RelocEntrySize];

};

header ¬ NEW[HeaderBody ¬ [

dynamic: FALSE,

toolversion: BYTE[0],

machtype: BYTE[0],

magic: magic,

flags: flags,

text: [textOffset, textSize],

iData: iDataSeg,

textReloc: textRelocSeg,

dataReloc: dataRelocSeg,

syms: symsSeg,

debug: debugSeg,

linno: linnoSeg,

textLoadOffset: textLoadOffset,

bssSize: Basics.Card32FromF[wAuxHeader.bssSize],

entryPoint: Basics.Card32FromF[wAuxHeader.entryPtr],

nPageSize: nPageSize,

nEntries: Basics.Card32FromF[wHeader.numSyms],

stringOffset: symsSeg.byteOffset+symsSeg.byteLength

]];

RETURN[header];

};

EmbeddedDotOs

We assume that there are dbx stabs located in the dotO in the symbol table entry range [firstX..limitX).

We assume that the first stab is a SO stab whose value is the next module symbol table entry of the embedded dotO. We assume that this stab is a SO stab containing the file name.

The first and limitX have presumably been obtained by other means. For example, at this writing the CirioNub will provide access to a table of pc ranges located in the target world. (In addition, we provide a rather crude mechanism below to use when the CirioNub approach is not available. (e.g., when examining a file that is not part of a PCedar load state.)

We are unable to define a legitimate limitPC. We assume that when, later, an attempt is made to look up a pc in the bracket structure, we have already determined that that pc definitely belongs to this EmbeddedDotO. Thus, we can use header.textSize as a (bogus) limitPC.

XCOFFModuleFromParsedAndPC: ObjectFilesPrivate.ModuleFromParsedAndPCProcType ~ {

PROC[whole: Parsed, spc: FileSegmentPC, moduleRope: ROPE ← NIL] RETURNS[Module] = {

IF whole = NIL THEN RETURN[NIL] ELSE

{

stabRange, pcRange: StabRange;

firstX, limitX: CARD;

stream: IO.STREAM;

[stabRange, pcRange] ¬ AlternativeFindModuleStabRange[whole, spc.relPC, moduleRope];

IF stabRange.count = 0 THEN RETURN[NIL];

firstX ¬ stabRange.first;

limitX ¬ stabRange.first+stabRange.count;

stream ¬ SystemInterface.GetStreamForFile[whole.file];

nest so that we can catch unwinds and release the stream

{

ENABLE UNWIND => {

SystemInterface.ReleaseStreamForFile[whole.file, stream];

};

firstSO: Stab;

firstPC: CARD32 ¬ pcRange.first;

lag: LIST OF Module ¬ NIL;

[firstSO, ] ¬ BasicReadStab[whole, stream, firstX];

first, see if we already have it

FOR modules: LIST OF Module ¬ whole.modules, modules.rest WHILE modules # NIL DO

IF modules.first.firstPC = firstPC THEN -- we already have it

{

SystemInterface.ReleaseStreamForFile[whole.file, stream];

RETURN[modules.first]

};

IF firstPC < modules.first.firstPC THEN -- we should have found it by now

{

newModule: Module ¬ CreateModule[whole, stream, stabRange, pcRange];

cell: LIST OF Module ¬ LIST[newModule];

cell.rest ¬ modules;

IF lag # NIL THEN lag.rest ¬ cell ELSE whole.modules ¬ cell;

SystemInterface.ReleaseStreamForFile[whole.file, stream];

RETURN[newModule];

};

lag ¬ modules;

ENDLOOP;

{

newModule: Module ¬ CreateModule[whole, stream, stabRange, pcRange];

cell: LIST OF Module ¬ LIST[newModule];

IF lag # NIL THEN lag.rest ¬ cell ELSE whole.modules ¬ cell;

SystemInterface.ReleaseStreamForFile[whole.file, stream];

RETURN[newModule];

};

CreateModule: PROC[parsed: Parsed, stream: IO.STREAM, stabRange, pcRange: StabRange ¬ [0, 0]] RETURNS[Module] = {

module: Module ¬ NEW[ModuleBody];

rctw: RCTW.RCTWData ¬ NEW[RCTW.RCTWDataBody];

sizes: REF KnownSizeList ¬ NEW[KnownSizeList ¬ CopyList[KnownSizes]];

firstSO: Stab;

nStabs: CARD;

[firstSO, ] ¬ BasicReadStab[parsed, stream, stabRange.first, sizes];

nStabs ¬ stabRange.count;

prepare the embeddedDotO for a call on BuildBrackets

module.whole ¬ parsed;

module.firstStabX ¬ 0;

module.limitStabX ¬ stabRange.count;

module.firstPC ¬ pcRange.first; -- firstSO.value;

module.limitPC ¬ parsed.header.text.byteLength; -- (bogus, but it will suffice for reasons given earlier)

lets read the all stabs now (without their ropes)

(I did some timing tests on a Dorado for RopeImpl. It took about 6 seconds to perform this loop, including the allocates. On the other hand, it takes about 4 seconds to spin through the entries without allocating the stab records. So, since at some point I have to traverse all the entries to find the Fun stabs, I might as well allocate them.)

(we also relocate the pc value of bracket stabs.)

module.stabs ¬ NEW[StabSet[nStabs]];

rctw.module ¬ module;

{I: CARD ¬ 0;

current: CARD ¬ 0;

tmp: REF StabSet ¬ NIL;

auxCount: CARD ¬ 0;

funFlag: BOOLEAN ¬ FALSE;

WHILE I<nStabs DO

stab: Stab;

nAux: CARD;

[module.stabs[current], nAux] ¬ BasicReadStab[parsed, stream, stabRange.first+I, sizes];

stab ¬ module.stabs[current];

stab.module ¬ module;

IF funFlag THEN {

module.stabs[current - 1].rope ¬ stab.rope;

funFlag ¬ FALSE;

};

IF stab.stabType = Fun THEN

funFlag ¬ TRUE;

IF stab.stabType = LBrac OR stab.stabType = RBrac THEN

stab.value ¬ stab.value + module.firstPC;

stab.stabX ¬ stab.stabX - auxCount - stabRange.first + GlobalPreDefinedTypes.length;

current ¬ current+1;

I ¬ I+1+nAux;

auxCount ¬ auxCount + nAux;

ENDLOOP;

tmp ¬ module.stabs;

module.stabs ¬ NEW[StabSet[current + 30]];

FOR I IN [0..current) DO

module.stabs[I+GlobalPreDefinedTypes.length] ¬ tmp[I];

ENDLOOP;

FOR I IN [0..GlobalPreDefinedTypes.length) DO

module.stabs[I] ¬ NEW[StabBody ¬ [

module: module,

stabX: I,

stabType: LSym,

size: 0,

value: 0,

rope: GlobalPreDefinedTypes[I]

]];

ENDLOOP;

module.limitStabX ¬ module.stabs[current-1].stabX + GlobalPreDefinedTypes.length + 1;

nStabs ¬ current;

};

now lets finish up

module.firstSO ← module.stabs[0];

module.secondSO ← IF module.stabs[module.stabs[0].dx].stabType = SO THEN module.stabs[module.stabs[0].dx] ELSE NIL;

module.fileName ← PFS.PathFromRope[IF module.secondSO = NIL THEN ReadStabRope[module.firstSO] ELSE ReadStabRope[module.secondSO]];

module.fileName ¬ PFS.PathFromRope[ObjectFilesPrivate.ReadStabRope[module.stabs[0]]];

module.staticVarsInstalled ¬ FALSE;

module.versionStampInfo ¬ NIL;

module.outerBracket ¬ NEW[BracketPairBody¬[

module: module,

kind: syntheticOuter,

firstX: 0,

limitX: module.whole.header.nEntries,

firstPC: module.firstPC,

pcLimit: module.limitPC,

funStab: NIL,

funIndex: 0,

symbols: NIL,

innerBrackets: NIL]];

InstallPCLineNumMaps[module, stabRange];

RETURN[module];

};

Finding Embedded dotOs

StabIndexTypeAndValue: TYPE = RECORD[stabX, stabXTo: CARD, stabType: StabType, value: CARD32];

NullStabIndexTypeAndValue: StabIndexTypeAndValue = [0, 0, Invalid, 0];

This procedure should only be used when examining a dotO which is not in the load state. If we are given a pc in a running PCR, it is far faster to use procedures in LoadStateAccess to obtain the stab range for an embedded dot O. Those procedures use a table available from the nub to find the stab range, then produce the embedded dotO through a call on CreateEmbeddedDotO.

AlternativeFindModuleStabRange: PROC[whole: ObjectFilesPrivate.Parsed, relativePC: CARD, moduleRope: Rope.ROPE ¬ NIL] RETURNS[sr: StabRange, pcRange: StabRange ¬ [0, 0]] = {

stream: IO.STREAM ¬ NIL;

IF whole = NIL THEN RETURN[[0, 0]] ELSE {

ENABLE UNWIND => SystemInterface.ReleaseStreamForFile[whole.file, stream];

stream ¬ SystemInterface.GetStreamForFile[whole.file];

[sr, pcRange] ¬ AlternativeFindModuleStabRangeInner[whole, relativePC, moduleRope, stream];

SystemInterface.ReleaseStreamForFile[whole.file, stream];

};

LastStabX: CARD = 0ffffffffH;

AlternativeFindModuleStabRangeInner: PROC[whole: ObjectFilesPrivate.Parsed, relativePC: CARD, moduleRope: Rope.ROPE, stream: IO.STREAM] RETURNS[sr: StabRange, pcRange: StabRange ¬ [0, 0]] = {

firstStabX: CARD ¬ 0;

checkWholeFile: BOOL ¬ moduleRope.IsEmpty;

pattern: Rope.ROPE ¬ Rope.Concat[moduleRope, ".*"];

baseSO: Stab ¬ BasicReadStab[whole, stream, firstStabX].stab;

baseSO.value points the next baseSO on AIX.

nextStabX: CARD ¬ IF baseSO.value = 0 OR baseSO.value = LastStabX THEN whole.stabLimit ELSE baseSO.value;

IF baseSO.stabType # SO THEN RETURN[[0, 0]];

WHILE firstStabX < whole.stabLimit DO

maxPC: CARD ¬ 0;

minPC: CARD ¬ LAST[CARD];

highDbx: CARD ¬ baseSO.stabX;

IF checkWholeFile OR (~name.IsEmpty AND Rope.Match[pattern, name]) THEN {

FOR x: CARD ¬ baseSO.stabX, highDbx WHILE x < nextStabX DO

info: StabIndexTypeAndValue ¬ CheckStab[whole, stream, x];

IF info.stabType = Fun OR info.stabType = SLine OR info.stabType = LBrac OR info.stabType = RBrac -- OR info.stabType = SO -- THEN {

maxPC ¬ MAX[maxPC, info.value];

minPC ¬ MIN[minPC, info.value];

};

highDbx ¬ info.stabXTo + 1;

ENDLOOP;

IF minPC <= relativePC AND relativePC <= maxPC THEN

RETURN[[baseSO.stabX, nextStabX-baseSO.stabX], [minPC, maxPC]];

};

firstStabX ¬ nextStabX;

baseSO ¬ BasicReadStab[whole, stream, firstStabX].stab;

baseSO.value points the next baseSO on AIX.

nextStabX ¬ IF baseSO.value = 0 OR baseSO.value = LastStabX THEN whole.stabLimit ELSE baseSO.value;

name ¬ baseSO.rope;

ENDLOOP;

SystemInterface.ReleaseStreamForFile[whole.file, stream];

RETURN[[0, 0]];

};

CheckStab: ENTRY PROC[whole: Parsed, stream: IO.STREAM, stabX: CARD] RETURNS[StabIndexTypeAndValue] = {

ENABLE UNWIND => NULL;

rope: Rope.ROPE ¬ NIL;

GetRope: PROC [] RETURNS [rope: Rope.ROPE] ~ {

IF stream#previousStream THEN {

cloneStream¬PFS.StreamFromOpenFile[openFile~PFS.OpenFileFromStream[stream]];

previousStream ¬ stream;

};

rope ¬ RopeFromData[whole, stream, wireStabBuffer.name, wireStabBuffer.sectionNumber, wireStabBuffer.storageClass, IF wireStabBuffer.numAuxEntries = 0 THEN wireStabBuffer.name ELSE wsAux.name];

};

GetSymTypeAndClass: PROC [] RETURNS [symType, class: CARD] ~ {

RETURN[wsAux.symbolType, wsAux.storageMappingClass]

};

IO.SetIndex[stream, whole.header.syms.byteOffset+stabX*StabSize];

TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wireStabBuffer], 0, StabSize]]};

IF wireStabBuffer.numAuxEntries # 0 THEN {

TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wsAux], 0, StabSize]]};

};

RETURN[[stabX, stabX + wireStabBuffer.numAuxEntries, TypeFromData[wireStabBuffer.storageClass, GetRope, GetSymTypeAndClass, wireStabBuffer.type], Basics.Card32FromF[wireStabBuffer.value]]];

};

XCOFFVarLocFromStab: ObjectFilesPrivate.VarLocFromStabProcType ~ {

PROC [stab: Stab] RETURNS [DotOAccess.VarLoc] ~ {

header: Header ~ stab.module.whole.header;

MkSegment: PROC [kind: ObjectFiles.SimpleSeg] RETURNS [ObjectFiles.VarLoc] ~ {

segRope:Rope.ROPE;

segBase: CARD ~ SELECT kind FROM

text => 0,

data => header.iData.byteOffset, --header.text.byteLength,--

bss => header.textReloc.byteOffset, --header.text.byteLength + header.iData.byteLength,--

ENDCASE => ERROR;

PJames 1/31/92: Doesn't look appropriate for XCoff...stab.value has a different type of value...

IF stab.value < segBase THEN ObjectFiles.UnreadableObjectFile[IO.PutFR["value (%xH) less than segment base (%xH) for symbol %g in %g", [cardinal[stab.value]], [cardinal[segBase]], [rope[ObjectFiles.CNameOfStab[stab]]], [rope[ObjectFiles.DescribeModule[stab.module]]] ]];

SELECT kind FROM

text => segRope ¬ "text";

data => segRope ¬ "data";

bss => segRope ¬ "bss";

ENDCASE => ERROR;

RETURN [NEW [ObjectFiles.VarLocBody ¬ [

bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,

where: fSegment[

[0, segRope],

(stab.value-- - segBase--)*8,

stab.value + segBase] ]]]};

SELECT stab.stabType FROM

Fun => RETURN MkSegment[text];

STSym => RETURN MkSegment[data];

LCSym => RETURN MkSegment[bss];

LSym, PSym => {

byteOffset: INT ~ LOOPHOLE[stab.value];

vLB: ObjectFiles.VarLoc;

IF stab.stabType=PSym AND stab.size>4 AND stab.size#LAST[CARD]

THEN vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [

bitSize: stab.size*8,

where: indirect[

base: NEW[ObjectFiles.VarLocBody ¬ [

bitSize: 32,

where: frame[bitOffset: 8*byteOffset]]],

offset: CirioTypes.zeroBA]]]

ELSE vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [

bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,

where: frame[bitOffset: 8*byteOffset]]];

RETURN[vLB]};

RSym => {

vLB: ObjectFiles.VarLoc;

IF stab.size>4 AND stab.size#LAST[CARD]

THEN vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [

bitSize: stab.size*8,

where: indirect[

base: NEW[ObjectFiles.VarLocBody ¬ [

bitSize: 32,

where: register[regNum: stab.value]]],

offset: CirioTypes.zeroBA]]]

ELSE vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [

bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,

where: register[regNum: stab.value]]];

RETURN[vLB]

};

GSym => RETURN [NEW [ObjectFiles.VarLocBody ¬ [

bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,

where: namedCommon[Rope.Concat["←", ObjectFiles.CNameOfStab[stab]], 0, 0, FALSE, FALSE] ]]];

ENDCASE => RETURN ObjectFiles.MakeUnknownVarLoc[IO.PutFR["unrecognized stabType (%02xH) for %g", [cardinal[stab.size]], [rope[ObjectFiles.CNameOfStab[stab]]] ]];

};

C Line-Number to Relative-PC maps

PCtoLineNumMap: TYPE = REF PCtoLineNumMapBody;

PCtoLineNumMapBody: TYPE = ObjectFilesPrivate.PCtoLineNumMapBody;

sorted by PC

LineNumToPCMap: TYPE = REF LineNumToPCMapBody;

LineNumToPCMapBody: TYPE = ObjectFilesPrivate.LineNumToPCMapBody;

sorted by Line Num

SLineData: TYPE = ObjectFilesPrivate.SLineData;

FMap: TYPE ~ LIST OF FMapData;

FMapBody: TYPE ~ RECORD [

seq: SEQUENCE len: CARD OF FMapData];

FMapData: TYPE ~ REF FMapDataBody;

FMapDataBody: TYPE ~ RECORD[

fName: Rope.ROPE,

stabOffset: CARD];

InstallPCLineNumMaps: PROC[module: Module, stabRange: StabRange] = {

fMap, fMapTmp: FMap ¬ NIL;

firstStabX: CARD ¬ stabRange.first;

limitStabX: CARD ¬ stabRange.first + stabRange.count;

CompareByCLineNum: PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] =

BEGIN

info1: REF SLineData ¬ NARROW[ref1];

info2: REF SLineData ¬ NARROW[ref2];

IF info1.cLineNum < info2.cLineNum THEN RETURN[less];

IF info1.cLineNum > info2.cLineNum THEN RETURN[greater];

IF info1.parsedRelPC.relPC < info2.parsedRelPC.relPC THEN RETURN[less];

IF info1.parsedRelPC.relPC > info2.parsedRelPC.relPC THEN RETURN[greater];

RETURN[equal];

END;

CompareByPC: PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] =

BEGIN

info1: REF SLineData ¬ NARROW[ref1];

info2: REF SLineData ¬ NARROW[ref2];

IF info1.parsedRelPC.relPC < info2.parsedRelPC.relPC THEN RETURN[less];

IF info1.parsedRelPC.relPC > info2.parsedRelPC.relPC THEN RETURN[greater];

IF info1.cLineNum < info2.cLineNum THEN RETURN[less];

IF info1.cLineNum > info2.cLineNum THEN RETURN[greater];

RETURN[equal];

END;

CompareBySI: PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] =

BEGIN

info1: FMapData ← NARROW[ref1];

info2: FMapData ← NARROW[ref2];

IF info1.stabOffset < info2.stabOffset THEN RETURN[less];

IF info1.stabOffset > info2.stabOffset THEN RETURN[greater];

RETURN[equal];

END;

IF module.pcToLineNum # NIL OR module.lineNumToPC # NIL THEN {

IF module.pcToLineNum = NIL OR module.lineNumToPC = NIL THEN ERROR;

RETURN;

};

we have to create them

{

nItems: INTEGER ¬ 0;

list1: LIST OF REF ANY ¬ NIL; -- LIST OF REF SLineData

list2: LIST OF REF ANY ¬ NIL; -- LIST OF REF SLineData

sortedList: LIST OF REF ANY ¬ NIL;

linno, relPC, pOffset: CARD ¬ 0;

inCurrentModule: BOOLEAN ¬ FALSE;

stream: IO.STREAM ¬ SystemInterface.GetStreamForFile[module.whole.file];

IO.SetIndex[stream, module.whole.header.linno.byteOffset];

FOR I: CARD IN [0..module.whole.header.linno.byteLength / 6) DO

IO.SetIndex[stream, module.whole.header.linno.byteOffset + I*6];

relPC ¬ Basics.Card32FromF[IO.GetFWord[stream]];

linno ¬ Basics.Card16FromH[IO.GetHWord[stream]];

IF linno = 0 THEN

IF relPC <= limitStabX AND relPC >= firstStabX THEN {

inCurrentModule ¬ TRUE;

IO.SetIndex[stream, module.whole.header.syms.byteOffset + 18 * relPC + 18 * 5 + 4];

pOffset ¬ Basics.Card16FromH[IO.GetHWord[stream]];

}

ELSE

inCurrentModule ¬ FALSE

ELSE

IF inCurrentModule THEN {

info: REF SLineData ¬ NEW[SLineData ¬ [cLineNum: linno + pOffset - 1, parsedRelPC: [[0 --??--, PFS.RopeFromPath[module.fileName]], relPC]]];

list1 ¬ CONS[info, list1];

list2 ¬ CONS[info, list2];

nItems¬nItems + 1;

};

ENDLOOP;

SystemInterface.ReleaseStreamForFile[module.whole.file, stream];

FOR I: CARD IN [module.firstStabX..module.limitStabX) DO

stab: Stab ← ReadStab[module, I];

IF stab.stabType = SLine THEN {

info: REF SLineData ← NEW[SLineData←[cLineNum: --pj fill this in! stab.desc-- 0, parsedRelPC: [[2, ".text"], stab.value]]];

list1 ← CONS[info, list1];

list2 ← CONS[info, list2];

nItems ← nItems+1};

ENDLOOP;

sortedList ¬ List.Sort[list1, CompareByCLineNum];

module.lineNumToPC ¬ NEW[LineNumToPCMapBody[nItems]];

FOR I: INTEGER IN [0..nItems) DO

info: REF SLineData ¬ NARROW[sortedList.first];

module.lineNumToPC[I] ¬ info;

sortedList ¬ sortedList.rest;

ENDLOOP;

sortedList ¬ List.Sort[list2, CompareByPC];

module.pcToLineNum ¬ NEW[PCtoLineNumMapBody[nItems]];

FOR I: INTEGER IN [0..nItems) DO

info: REF SLineData ¬ NARROW[sortedList.first];

module.pcToLineNum[I] ¬ info;

sortedList ¬ sortedList.rest;

ENDLOOP;

};

Stabs

This routine treats stabX as relative to the entire containing dotO file.

warning: does NOT relocate LBrac or RBrac stabs.

warning: does NOT read the associated rope

Also: the edo field is set to NIL;

BasicReadStab: ENTRY PROC[parsed: Parsed, stream: IO.STREAM, stabX: CARD, sizes: REF KnownSizeList ¬ NIL] RETURNS[stab: Stab, nAux: CARD ¬ 0] ~ {

ENABLE UNWIND => NULL;

stab ¬ NEW[StabBody];

[stab, nAux] ¬ ReadStabBody[parsed, stream, stabX, sizes];

RETURN

};

TypeFromData: PROC [data: BYTE, getName: PROC RETURNS [Rope.ROPE], getSymTypeAndClass: PROC RETURNS [symType, class: CARD], typ: BYTE ¬ 0] RETURNS [stabType: StabType] ~ {

dataVal: CARD ¬ data;

typeVal: CARD ¬ typ;

IF typeVal = 20H THEN

stabType ¬ Fun

ELSE

SELECT dataVal FROM

Block =>

{

SELECT TRUE FROM

Rope.Equal[".bb", name] => stabType ¬ LBrac;

Rope.Equal[".eb", name] => stabType ¬ RBrac;

ENDCASE => ERROR;

};

Brac =>

{

SELECT TRUE FROM

Rope.Equal[".bf", name] => stabType ¬ LBrac;

Rope.Equal[".ef", name] => stabType ¬ RBrac;

ENDCASE => ERROR;

};

00000H => SLine; -- no SLine s in XCOFF

Fun => stabType ← Fun; -- gets in the way.

PSym => stabType ¬ PSym;

LSym => stabType ¬ LSym;

RSym => stabType ¬ RSym;

STSym => stabType ¬ STSym;

00000H => LCSym; -- ?

GSym => stabType ¬ GSym;

HidEnt =>

{

symType, class: CARD;

[symType, class] ¬ getSymTypeAndClass[];

IF symType = XTYSD AND class = XMCRW THEN stabType ¬ Invalid ELSE stabType ¬ Unspecified;

};

00000H => Main; -- not used?

SO => stabType ¬ SO;

00000H => BIncl;

00000H => EIncl;

00000H => SOL;

ENDCASE => stabType ¬ Unspecified

};

DebugStab: CARD = 0fffeH;

previousStream: IO.STREAM ¬ NIL;

cloneStream: IO.STREAM ¬ NIL;

ReadStabBody: PROC [parsed: Parsed, stream: IO.STREAM, stabX: CARD, sizes: REF KnownSizeList] RETURNS [stab: StabBody, nAux: CARD ¬ 0] ~ {

size: CARD;

rope: Rope.ROPE ¬ NIL;

GetRope: PROC [] RETURNS [Rope.ROPE] ~ {

RETURN[rope]

};

GetSymTypeAndClass: PROC [] RETURNS [symType, class: CARD] ~ {

RETURN[wsAux.symbolType, wsAux.storageMappingClass]

};

IO.SetIndex[stream, parsed.header.syms.byteOffset+stabX*StabSize];

TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wireStabBuffer], 0, StabSize]]};

IF wireStabBuffer.numAuxEntries # 0 THEN {

TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wsAux], 0, StabSize]]};

};

nAux ¬ wireStabBuffer.numAuxEntries;

IF stream#previousStream THEN {

cloneStream¬PFS.StreamFromOpenFile[openFile~PFS.OpenFileFromStream[stream]];

previousStream ¬ stream;

};

rope ¬ RopeFromData[parsed, cloneStream, wireStabBuffer.name, wireStabBuffer.sectionNumber, wireStabBuffer.storageClass, IF wireStabBuffer.numAuxEntries = 0 THEN wireStabBuffer.name ELSE wsAux.name];

IF sizes # NIL THEN

[size, sizes] ¬ SizeFromName[rope, sizes]

ELSE

size ¬ 0;

stab ¬ [

module: NIL,

stabX: stabX,

stabType: TypeFromData[wireStabBuffer.storageClass, GetRope, GetSymTypeAndClass, wireStabBuffer.type], --wireStabBuffer.type,

value: Basics.Card32FromF[wireStabBuffer.value],

size: size,

rope: rope

];

RETURN};

dataChar: ByteEntry ¬ NEW[ByteEntryBody];

RopeFromData: PROC [parsed: Parsed, stream: IO.STREAM, data: PACKED ARRAY [0..7] OF BYTE, sn: Basics.HWORD, storeClass: BYTE, auxData: PACKED ARRAY [0..7] OF BYTE] RETURNS [name: Rope.ROPE ¬ NIL] ~ TRUSTED {

len: TwoByteEntry ¬ NEW[TwoByteEntryBody];

dbg: BOOL ¬ IF Basics.Card16FromH[sn] = DebugStab THEN TRUE ELSE FALSE;

sum, offset: CARD ¬ 0;

IF dbg AND storeClass = 67H THEN {

data ¬ auxData;

dbg ¬ FALSE;

};

offset ¬ IF dbg THEN parsed.header.debug.byteOffset ELSE parsed.header.stringOffset;

FOR i: CARD IN [0..4) DO

n: CARD ¬ data[i];

sum ¬ sum + n;

ENDLOOP;

IF sum = 0 THEN {

FOR i: CARD IN [4..8) DO

n: CARD ¬ data[i];

sum ¬ sum * 256 + n;

ENDLOOP;

IO.SetIndex[stream, offset + sum];

IF IO.EndOf[stream] THEN RETURN[""];

c: CHAR ¬ ' ;

c ¬ IO.GetChar[stream];

TRUSTED{[] ← IO.UnsafeGetBlock[stream, [LOOPHOLE[@dataChar^], 0, 1]]};

c ← dataChar.val;

IF c = VAL[0] THEN EXIT;

name ¬ name.Concat[Convert.RopeFromChar[from: c, quote: FALSE]];

ENDLOOP;

}

ELSE

FOR i: CARD IN [0..8) DO

num: CARD ¬ data[i];

IF num = 0 THEN EXIT;

name ¬ name.Concat[Convert.RopeFromChar[from: VAL[num], quote: FALSE]];

ENDLOOP;

RETURN

};

wireStabBuffer: WireSTEntry ¬ NEW[WireSTEntryBody];

wsAux: WireSTAuxEntry ¬ NEW[WireSTAuxEntryBody];

all users should be in the monitor

RandomTestFindStabRange: Commander.CommandProc =

{

args: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd];

path: PATH ¬ PFS.PathFromRope[args[1]];

fileSet: SystemInterface.FileSet ¬ SystemInterface.CreateFileSet[];

{ ENABLE UNWIND => SystemInterface.CloseFileSet[fileSet];

file: SystemInterface.CirioFile ¬ SystemInterface.GetCirioFile[fileSet, path];

nextSeed: INT ¬ IF args.argc < 3 THEN 4466 ELSE Convert.IntFromRope[args[2]];

start: BasicTime.GMT ¬ BasicTime.Now[];

WHILE TRUE DO

rs: Random.RandomStream ¬ Random.Create[seed: nextSeed];

whole: Parsed ¬ ObjectFiles.CreateParsed[file, "XCOFF"];

IO.PutF[cmd.out, "beginning seed = %g at %g\N", IO.card[nextSeed], IO.time[start]];

FOR I: INT IN [0..100) DO

range: StabRange;

pc: CARD ¬ Random.ChooseInt[rs, 0, whole.header.text.byteLength];

[range, ] ¬ AlternativeFindModuleStabRange[whole, pc];

IO.PutF[cmd.out, "\Tpc = %g gives firstX: %g count: %g\N", IO.card[pc], IO.card[range.first], IO.card[range.count]];

ENDLOOP;

};

SystemInterface.CloseFileSet[fileSet];

};

SizeFromName: PROC[name:ROPE, sizes: KnownSizeList ¬ NIL] RETURNS [size: CARD ¬ 0, newSizes: KnownSizeList] ~ {

c: CHAR;

newID: CARD;

where: CARD ¬ 0;

IF sizes = NIL THEN RETURN;

newSizes ¬ sizes;

where ¬ Rope.Index[name, 0, ":"] + 1;

IF where = ABS[name.Length[]]+ 1 THEN RETURN;

IF (c ¬ name.Fetch[where]) # 't AND c # 'T THEN {

typeID: INT;

IF IsDigit[c] OR c = '- THEN

[typeID, ] ¬ GetNum[name, where]

ELSE

[typeID, ] ¬ GetNum[name, where+1];

typeID: INT ← -1;

IF IsDigit[c] THEN

typeID ← Convert.IntFromRope[name.Substr[where]]

ELSE

typeID ← Convert.IntFromRope[name.Substr[where + 1]];

RETURN[FindInList[typeID, sizes], newSizes];

};

[newID, where] ¬ GetNum[name, where+ 1];

IF name.Fetch[where] # '= THEN ERROR;

where ¬ where + 1;

SELECT name.Fetch[where] FROM

'f => {

type: INT;

[type, where] ¬ GetNum[name, where+ 1];

size ¬ FindInList[type, sizes];

};

'*, 'e => size ¬ 4;

'u, 's => {

[size, where] ¬ GetNum[name, where +1]};

'a => {

garb, start, end, type: INT;

baseSize: CARD;

c: CHAR ¬ name.Fetch[where + 1];

IF c# 'r THEN ERROR;

[garb, where] ¬ GetNum[name, where+2];

IF name.Fetch[where] # '; THEN ERROR;

[start, where] ¬ GetNum[name, where+1];

IF name.Fetch[where] # '; THEN ERROR;

[end, where] ¬ GetNum[name, where+1];

IF name.Fetch[where] # '; THEN ERROR;

[type, where] ¬ GetNum[name, where+1];

baseSize ¬ FindInList[type, sizes];

size ¬ (end - start + 1) * baseSize;

};

ENDCASE => size ¬ 0;

newSizes ¬ CONS[[newID, size], newSizes];

size ¬ 0;

};

GetNum: PROC [rope: ROPE, index: CARD] RETURNS [num: INT ¬ 0, newIndex: CARD ¬ 0] ~ {

len: CARD ¬ rope.Length[];

i: CARD;

negFlag: BOOL ¬ FALSE;

FOR i ¬ index, i + 1 UNTIL i = len DO

c: CHAR ¬ rope.Fetch[i];

IF ~IsDigit[c] AND c # '- THEN {

newIndex ¬ i;

EXIT;

};

IF c = '- THEN

negFlag ¬ TRUE

ELSE

num ¬ num * 10 + (c - '0);

ENDLOOP;

IF i = len THEN

newIndex ¬ i;

IF negFlag THEN

num ¬ -num;

};

KnownSize: TYPE ~ RECORD[typeID: INT, size: CARD];

KnownSizeList: TYPE ~ LIST OF KnownSize;

These sizes were determined from /usr/include/dbxstclass.h (no guarantees though)

KnownSizes: KnownSizeList ¬ LIST[[-1, 4], [-2, 1], [-3, 2], [-4, 4], [-5, 1], [-6, 1], [-7, 2], [-8, 4], [-9, 4], [-10, 4], [-11, 0], [-12, 4], [-13, 8], [-14, 10], [-15, 4], [-16, 1], [-17, 4], [-18, 8], [-19, 1], [-20, 1], [-21, 1], [-22, 2], [-23, 1], [-24, 1], [-25, 8], [-26, 16], [-27, 1], [-28, 2], [-29, 4], [-30, 2]];

CopyList: PROC [l: KnownSizeList] RETURNS [n: KnownSizeList ¬ NIL] ~ {

n ¬ NIL;

FOR i: KnownSizeList ¬ l, i.rest WHILE i # NIL DO

n ¬ CONS[i.first, n];

ENDLOOP;

};

FindInList: PROC [i: INT, l: KnownSizeList] RETURNS [s: CARD ¬ LAST[CARD]] ~ {

FOR loop: KnownSizeList ¬ l, loop.rest WHILE loop # NIL DO

IF loop.first.typeID = i THEN RETURN[loop.first.size];

ENDLOOP;

ERROR;

};

IsDigit: PROC [c: CHAR] RETURNS [BOOL]

= INLINE { RETURN [c IN ['0 .. '9]] };

XCOFFGetTypeRef: ObjectFilesPrivate.GetTypeRefProcType ~ {

PROC [sourceStream:IO.STREAM] RETURNS [Rope.ROPE]

typeRef: Rope.ROPE;

lastChar: CHAR;

IF IsDigit[lastChar ¬ IO.PeekChar[sourceStream]] OR lastChar = '- THEN {

typeRef ¬ RCTW.GetTokenRope[sourceStream];

RETURN[typeRef]}

ELSE DO

lastChar ¬ IO.GetChar[sourceStream];

typeRef ¬ Rope.Concat[typeRef, Rope.FromChar[lastChar]];

IF lastChar = ') THEN RETURN[typeRef]

ENDLOOP

};

The function stab is module.funStabs[funStabIndex].stab

XCOFFInstallBracketPairsForOneFunStab: PROC[module: Module, funStabIndex: CARD] =

{

funStab: Stab ¬ module.funStabs[funStabIndex].stab;

paramNames, lastParamName: LIST OF Rope.ROPE ¬ NIL;

paramStabs, lastParamStab: LIST OF Stab ¬ NIL; -- includes param mod stabs

x: CARD ¬ funStab.stabX+1;

good: BOOL ¬ TRUE;

module.funStabs[funStabIndex].brackets ¬ NEW[BracketPairBody¬[

module: module,

kind: syntheticFun,

firstX: funStab.stabX,

limitX: 0,

firstPC: funStab.value,

pcLimit: 0,

funStab: funStab,

funIndex: funStabIndex,

symbols: NIL,

innerBrackets: NIL]];

The following loop finds the limitX and pcLimit. These might be at different X values if there are global symbols between procedures (which can happen with Sun's cc). good goes false once we've found the limitX and are just looking for the pcLimit. The loop also accumulates innerBrackets, if any. We make a feeble attempt to distinguish parameters from local variables; this attempt will fail for Gnu cc; it it's important to get this right, look at the `symbol descriptor' in a variable's stab.

We assume the following structure:

some param stabs

some stabs that modify the param stabs

symbol stabs for the first inner block (if any)

Note that both C compilers feels free to omit the LBrac and RBrac of a procedure with no local variables. Gnu cc further feels free to omit the L&RBrac of procedures with no non-trivial nested scopes.

WHILE x < module.limitStabX DO

stab: Stab ¬ ObjectFilesPrivate.ReadStab[module, x];

TakeBP: PROC ~ {

finalRBracX: CARD;

[finalRBracX, module.funStabs[funStabIndex].brackets.innerBrackets, paramStabs] ¬ ScanOneBracketPairSequence[module, funStab, funStabIndex, x, paramStabs, lastParamStab];

IF good THEN module.funStabs[funStabIndex].brackets.limitX ¬ finalRBracX+1;

module.funStabs[funStabIndex].brackets.pcLimit ¬

IF finalRBracX<module.limitStabX

THEN ObjectFilesPrivate.ReadStab[module, finalRBracX].value

ELSE module.limitPC;

RETURN};

IF stab = NIL THEN LOOP;

SELECT stab.stabType FROM

PSym => {

stabCell: LIST OF Stab ¬ LIST[stab];

nameCell: LIST OF Rope.ROPE ¬ LIST[name];

IF paramStabs#NIL AND stab=paramStabs.first THEN ERROR;

IF paramNames = NIL THEN paramNames ¬ nameCell ELSE lastParamName.rest ¬ nameCell;

lastParamName ¬ nameCell;

IF paramStabs = NIL THEN paramStabs ¬ stabCell ELSE lastParamStab.rest ¬ stabCell;

lastParamStab ¬ stabCell};

RSym, LSym => {

stabCell: LIST OF Stab ¬ LIST[stab];

isAParam: BOOLEAN ¬ FALSE; -- initial value

FOR pNames: LIST OF Rope.ROPE ¬ paramNames, pNames.rest WHILE pNames # NIL DO

IF Rope.Equal[name, pNames.first] THEN

{isAParam ¬ TRUE; EXIT};

ENDLOOP;

IF isAParam THEN {

IF paramStabs = NIL THEN paramStabs ¬ stabCell ELSE lastParamStab.rest ¬ stabCell;

lastParamStab ¬ stabCell}

ELSE -- we are facing the first symbol of a nested block

{TakeBP[]; EXIT};

};

GSym, LCSym, STSym => IF good THEN {

module.funStabs[funStabIndex].brackets.limitX ¬ stab.stabX;

good ¬ FALSE};

SLine, Unspecified => NULL;

LBrac => {TakeBP[]; EXIT};

Fun => {

IF good THEN module.funStabs[funStabIndex].brackets.limitX ¬ stab.stabX;

module.funStabs[funStabIndex].brackets.pcLimit ¬ stab.value;

EXIT};

ENDCASE => ObjectFilesPrivate.RaiseUnreadableObjectFileForFun[

IO.PutFR["Unexpected stab (of stabType %02xH) in intro to %g",

[rope[ObjectFiles.RopeForStabType[stab.stabType]]],

[rope[ObjectFiles.CNameOfStab[funStab]]] ],

module, funStab];

x ¬ x + 1;

REPEAT

FINISHED => {

IF good THEN module.funStabs[funStabIndex].brackets.limitX ¬ module.limitStabX;

module.funStabs[funStabIndex].brackets.pcLimit ¬ module.limitPC;

};

ENDLOOP;

module.funStabs[funStabIndex].brackets.symbols ¬ paramStabs;

RETURN};

this is coded to expect the symbols before the LBrac.

We have discovered that the Sun C compiler places local variables symbols in the symbol table before their enclosing left bracket.!! This is confirmed by the example in "Dbx and Dbxtool Interfaces, Second Edition, Revised, 7 January 1988. See lines 46 and 47 on page 28. It is also confirmed by some comments in /import/gdb/dbxread.c. See source position 90236. This is in the vicinity of "case N←RBRAC". On the positive side, the code in /import/gdb/dbxread.c confirms that the local variables symbols are expected to be properly sorted in some way with respect to the RBrac/LBrac stabs.

The comment in /import/gdb/dbxread.c also suggests that there are some C compilers that place the symbols inside the LBrac/RBrac pair. It shouldn't be difficult to recode this to handle the second case. One will have to collect the symbols during the scan. For full generality, one might expect to receive the symbols anytime one is outside an inner pair.

We assume that firstX is pointing at the first symbol of the first bracket pair. (If the enclosing bracket pair is an innermost pair, then firstX is pointing at either an RBrac, a Fun, or is an attempt to go past the end of the symbol table.)

Upon return, nextX will point to an unmatched RBrac, a Fun, or will be an attempt to go past the end of the symbol table.

BracketPair: TYPE ~ ObjectFilesPrivate.BracketPair;

BracketPairBody: TYPE ~ ObjectFilesPrivate.BracketPairBody;

ScanOneBracketPairSequence: PROC[module: Module, fun: Stab, funIndex: CARD, firstX: CARD, symHead, symTail: StabList] RETURNS[--finalRBracX-- CARD, --innerBrackets-- LIST OF BracketPair, --symbols-- StabList] =

{

innerBrackets: LIST OF BracketPair ¬ NIL;

lastInnerBracket: LIST OF BracketPair ¬ NIL;

x: CARD ¬ firstX;

xAfterSymbs: CARD;

stabAfterSymbs: Stab;

[xAfterSymbs, symHead, symTail] ¬ ObjectFilesPrivate.ScanSymbolStabs[module, x, symHead, symTail];

IF xAfterSymbs >= module.limitStabX THEN

RETURN[xAfterSymbs, innerBrackets, symHead];

stabAfterSymbs ¬ ObjectFilesPrivate.ReadStab[module, xAfterSymbs];

SELECT stabAfterSymbs.stabType FROM

LBrac =>

{

finalRBracX: CARD;

nestedInnerBrackets: LIST OF BracketPair;

bracket: BracketPair;

bracketCell: LIST OF BracketPair;

[finalRBracX, nestedInnerBrackets, symHead] ¬ ScanOneBracketPairSequence[module, fun, funIndex, xAfterSymbs+1, symHead, symTail];

bracket ¬ NEW[BracketPairBody¬[

module: module,

kind: actual,

firstX: stabAfterSymbs.stabX,

limitX: finalRBracX+1,

firstPC: stabAfterSymbs.value,

pcLimit: IF finalRBracX<module.limitStabX THEN ObjectFilesPrivate.ReadStab[module, finalRBracX].value ELSE module.limitPC,

funIndex: funIndex,

symbols: symHead,

innerBrackets: nestedInnerBrackets]];

bracketCell ¬ LIST[bracket];

IF innerBrackets = NIL THEN innerBrackets ¬ bracketCell ELSE lastInnerBracket.rest ¬ bracketCell;

lastInnerBracket ¬ bracketCell;

symHead ¬ symTail ¬ NIL;

x ¬ finalRBracX+1;

};

RBrac, Fun, GSym, STSym, LCSym => RETURN[xAfterSymbs, innerBrackets, symHead];

ENDCASE => ERROR; -- can't happen

ENDLOOP};

GlobalPreDefinedTypes: REF PDTType ¬ NIL;

GPTDs: LIST OF Rope.ROPE ¬ LIST [

"int:t-1=r-1;-2147483648;2147483647",

"char:t-2=@s8;r-2;0;255",

"short:t-3=@s16;r-3;-32768;32767",

"long:t-4=-1",

"unsigned char:t-5=@s8;r-5;0;255",

"signed char:t-6=@s8;r-6;-128;127",

"unsigned short:t-7=@s16;r-7;0;65535",

"unsigned int:t-8=r-8;0;4294967295",

"unsigned:t-9=-8",

"unsigned long:t-10=-8",

"void:t-11=r-11;0;0",

"float:t-12=g-12;4",

"double:t-13=g-12;8",

"long double:t-14=g-12;10",

"integer:t-15=-1",

"boolean:t-16=efalse:0,true:1,",

"shortreal:t-17=g-12;4",

"real:t-18=g-12;8",

"stringptr:t-19=N-19",

"character:t-20=@s8;r-20;0;255",

"logical*1:t-21=@s8;r-21;0;255",

"logical*2:t-22=@s16;r-22;0;65535",

"logical*4:t-23=r-23;0;4294967295",

"logical:t-24=-23",

"complex:t-25=c-25;8",

"double complex:t-26=c-25;16",

"integer*1:t-27=-6",

"integer*2:t-28=-3",

"integer*4:t-29=-1",

"wchar:t-30=@s16;r-30;0;65535"];

PDTType: TYPE ~ RECORD [body: SEQUENCE length: CARD OF Rope.ROPE];

IntallPreDefinedTypes: PROC ~ {

l: LIST OF Rope.ROPE ¬ NIL;

FOR l ¬ GPTDs, l.rest UNTIL l = NIL DO

count ¬ count + 1;

ENDLOOP;

GlobalPreDefinedTypes ¬ NEW[PDTType[count]];

l ¬ GPTDs;

FOR index: CARD IN [0..count) DO

GlobalPreDefinedTypes[index] ¬ l.first;

l ¬ l.rest;

ENDLOOP;

};

It seems AIX ld doesn't relocate static symbol (STSym) offset. So, we get data section's base offset and add the offset to local symbol offset.

GetDataSectionOffset: PROC[module: Module] RETURNS[CARD] ~ {

IsDotO: PROC RETURNS[BOOL] ~ {

RETURN[Basics.BITAND[module.whole.header.flags, (FLdMinusR+FShrObj+FDynLoad+FExec)] = 0];

};

Section's base offset doesn't correct if file is .o.

IF IsDotO[] THEN RETURN [0];

FOR x: CARD DECREASING IN [module.firstStabX..module.limitStabX) DO

stab: Stab ¬ ObjectFilesPrivate.ReadStab[module, x];

IF stab.stabType = Invalid THEN RETURN [stab.value];

ENDLOOP;

RETURN [0];

};

XCOFFInstallStaticVars: ObjectFilesPrivate.InstallStaticVarsType ~

PROC[module: Module] =

this procedure examines all stabs up to the first Fun stab, looking for certain expected stabs. These are recorded in the whole.

{

numFuns: INT ¬ 1;

dataStabOffset: CARD ¬ 0; -- globalFrame stab seems to be offset from versionStringStab, which has to be searched for at times...

IF NOT module.staticVarsInstalled THEN

FOR y: CARD IN [module.firstStabX..module.limitStabX)

x: CARD ¬ module.firstStabX + module.limitStabX - 1 - y;

stab: Stab ¬ ObjectFilesPrivate.ReadStab[module, x];

IF stab = NIL THEN LOOP;

IF stab.stabType = Fun THEN {

IF numFuns = 0 THEN EXIT;

numFuns ¬ numFuns - 1;

};

IF stab.stabType = STSym OR stab.stabType = LCSym THEN

{

IF module.versionStampStab = NIL THEN

{

gvi: ObjectFiles.GlobalVarLoc ¬ NIL;

gvi ¬ NARROW[ObjectFilesPrivate.CheckStaticVar[stab, "versionStamp", TRUE]];

IF gvi # NIL THEN

{

stream: IO.STREAM ¬ NIL;

dataRope: Rope.ROPE;

module.versionStampStab ¬ stab;

dataStabOffset ¬ GetDataSectionOffset[module];

dataRope ¬ ObjectFilesPrivate.ReadInitialDataAsRope[module, gvi.fileByteOffset + dataStabOffset];

IF dataRope.IsEmpty[] THEN {

ENABLE UNWIND => SystemInterface.ReleaseStreamForFile [module.whole.file, stream];

Force find the version stamp mob

Before ld, the version stamp mob is further into the

.data section than usual, and the stab entry shows

no indication of this, so if no rope was found at

the correct location, walk through until @(#) is found.

searchFor: Rope.ROPE ¬ "@(#)";

c: CHAR;

searchForIndex: INT ¬ 0;

found: BOOL ¬ FALSE;

stream ¬ SystemInterface.GetStreamForFile[module.whole.file];

IO.SetIndex[stream, gvi.fileByteOffset + dataStabOffset];

dataRope ¬ "";

WHILE ~found DO

tmpOffset: CARD ¬ 0;

WHILE ((c ¬ IO.GetChar[stream]) # searchFor.Fetch[searchForIndex]) DO

dataStabOffset ¬ dataStabOffset + 1;

ENDLOOP;

tmpOffset ¬ tmpOffset + 1;

searchForIndex ¬ searchForIndex + 1;

WHILE (searchForIndex < searchFor.Length[] AND (c ¬ IO.GetChar[stream]) = searchFor.Fetch[searchForIndex]) DO

tmpOffset ¬ tmpOffset + 1;

searchForIndex ¬ searchForIndex + 1;

ENDLOOP;

tmpOffset ¬ tmpOffset + 1;

IF searchForIndex = searchFor.Length[] THEN

found ¬ TRUE

ELSE

dataStabOffset ¬ dataStabOffset + tmpOffset;

ENDLOOP;

dataRope ¬ searchFor;

WHILE ((c ¬ IO.GetChar[stream]) # '\000) DO

dataRope ¬ dataRope.Concat[Rope.FromChar[c]];

ENDLOOP;

SystemInterface.ReleaseStreamForFile [module.whole.file, stream];

};

stab.value ¬ stab.value+dataStabOffset;

IF module.globalFrameStab # NIL THEN

module.globalFrameStab.value ¬ module.globalFrameStab.value + dataStabOffset;

IF module.globalFrameStab # NIL THEN {

module.globalFrameGvl.bitOffset ¬ module.globalFrameGvl.bitOffset + dataStabOffset * 8;

module.globalFrameGvl.fileByteOffset ¬ module.globalFrameGvl.fileByteOffset + dataStabOffset;

};

module.versionStampInfo ¬ NEW[ObjectFiles.VersionStampInfo¬[gvi, dataRope]];

LOOP;

};

IF module.globalFrameStab = NIL THEN

{

gvi: ObjectFiles.GlobalVarLoc ¬ NIL;

gvi ¬ NARROW[ObjectFilesPrivate.CheckStaticVar[stab, "globalframe", TRUE]];

IF gvi # NIL THEN

{

module.globalFrameStab ¬ stab;

module.globalFrameGvl ¬ gvi;

LOOP;

};

ENDLOOP;

module.staticVarsInstalled ¬ TRUE;

};

XCOFFAlterFunStab: ObjectFilesPrivate.AlterFunStabType ~ {

rope assignement has been done in CreateModule.

module.funStabs[funStabX].stab.rope ← module.stabs[module.funStabs[funStabX].firstX+1].rope;

RETURN [module.funStabs[funStabX].stab]; };

XCOFFGetSPOffset: ObjectFilesPrivate.GetSPOffsetType ~ {

On AIX, SP offset from FP is always 0 (SP = FP).

RETURN [0];

};

Main code

transTable: ObjectFilesPrivate.TranslationTable;

IntallPreDefinedTypes[];

transTable ¬NEW[ObjectFilesPrivate.TranslationTableBody[1]];

Commander.Register["xcoffRandomTestFindStabRange", RandomTestFindStabRange];

transTable[0] ¬ [0, 2, 479, "XCOFF"];

ObjectFilesPrivate.RegisterObjectFileFlavor[NEW [ObjectFilesPrivate.ObjectFileFlavorBody ¬ [

"XCOFF",

XCOFF,

ReadHeader,

XCOFFModuleFromParsedAndPC,

XCOFFVarLocFromStab,

XCOFFGetTypeRef,

XCOFFInstallBracketPairsForOneFunStab,

NIL, NIL, NIL,

FALSE,

XCOFFInstallStaticVars,

XCOFFAlterFunStab,

XCOFFGetSPOffset

]],

transTable];

END.