6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-02-08 21:32:39 +00:00
Code Issues Projects Releases Wiki Activity

llvm-mc: Fix case were we would skip a line in the .s file after an instruction

Browse Source 
match failure.

Also, fixes a few memory leak FIXMEs.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@102986 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Dunbar 2010-05-04 00:33:07 +00:00
parent ba609c88a5
commit 31e8e1d085
2 changed files with 27 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/MC/MCAssembler.cpp
View File

@ -212,7 +212,7 @@ static bool isScatteredFixupFullyResolvedSimple(const MCAssembler &Asm,
// resolved. This also works in conjunction with absolutized .set, which
// requires the compiler to use .set to absolutize the differences between
// symbols which the compiler knows to be assembly time constants, so we don't
// need to worry about consider symbol differences fully resolved.
// need to worry about considering symbol differences fully resolved.
// Non-relative fixups are only resolved if constant.
if (!BaseSection)
@ -715,6 +715,8 @@ bool MCAssembler::FixupNeedsRelaxation(const MCAsmFixup &Fixup,
return true;
// Otherwise, relax if the value is too big for a (signed) i8.
//
// FIXME: This is target dependent!
return int64_t(Value) != int64_t(int8_t(Value));
}

49
lib/MC/MCParser/AsmParser.cpp
View File

@ -729,39 +729,38 @@ bool AsmParser::ParseStatement() {
return false;
}
SmallVector<MCParsedAsmOperand*, 8> ParsedOperands;
if (getTargetParser().ParseInstruction(IDVal, IDLoc, ParsedOperands))
// FIXME: Leaking ParsedOperands on failure.
return true;
if (Lexer.isNot(AsmToken::EndOfStatement))
// FIXME: Leaking ParsedOperands on failure.
return TokError("unexpected token in argument list");
bool HadError = getTargetParser().ParseInstruction(IDVal, IDLoc,
ParsedOperands);
if (!HadError && Lexer.isNot(AsmToken::EndOfStatement))
HadError = TokError("unexpected token in argument list");
// Eat the end of statement marker.
Lex();
// If parsing succeeded, match the instruction.
if (!HadError) {
MCInst Inst;
if (!getTargetParser().MatchInstruction(ParsedOperands, Inst)) {
// Emit the instruction on success.
Out.EmitInstruction(Inst);
} else {
// Otherwise emit a diagnostic about the match failure and set the error
// flag.
//
// FIXME: We should give nicer diagnostics about the exact failure.
Error(IDLoc, "unrecognized instruction");
HadError = true;
}
}
MCInst Inst;
bool MatchFail = getTargetParser().MatchInstruction(ParsedOperands, Inst);
// If there was no error, consume the end-of-statement token. Otherwise this
// will be done by our caller.
if (!HadError)
Lex();
// Free any parsed operands.
for (unsigned i = 0, e = ParsedOperands.size(); i != e; ++i)
delete ParsedOperands[i];
if (MatchFail) {
// FIXME: We should give nicer diagnostics about the exact failure.
Error(IDLoc, "unrecognized instruction");
return true;
}
// Instruction is good, process it.
Out.EmitInstruction(Inst);
// Skip to end of line for now.
return false;
return HadError;
}
bool AsmParser::ParseAssignment(const StringRef &Name) {