llvm-6502/lib/MC/MCAtom.cpp
Rafael Espindola 49978e6125 Fix MCDataAtom never calling remap when adding data.
This patch fixes a small mistake in MCDataAtom::addData() where it doesn't ever
call remap():

-  if (Data.size() > Begin - End - 1)
+  if (Data.size() > End + 1 - Begin)
     remap(Begin, End + 1);

This is currently not visible because of another bug is the disassembler, so
the patch includes a unit test.

Patch by Stephen Checkoway.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@192823 91177308-0d34-0410-b5e6-96231b3b80d8
2013-10-16 18:26:16 +00:00

112 lines
3.2 KiB
C++

//===- lib/MC/MCAtom.cpp - MCAtom implementation --------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/MC/MCAtom.h"
#include "llvm/MC/MCModule.h"
#include "llvm/Support/ErrorHandling.h"
#include <iterator>
using namespace llvm;
void MCAtom::remap(uint64_t NewBegin, uint64_t NewEnd) {
Parent->remap(this, NewBegin, NewEnd);
}
void MCAtom::remapForTruncate(uint64_t TruncPt) {
assert((TruncPt >= Begin && TruncPt < End) &&
"Truncation point not contained in atom!");
remap(Begin, TruncPt);
}
void MCAtom::remapForSplit(uint64_t SplitPt,
uint64_t &LBegin, uint64_t &LEnd,
uint64_t &RBegin, uint64_t &REnd) {
assert((SplitPt > Begin && SplitPt <= End) &&
"Splitting at point not contained in atom!");
// Compute the new begin/end points.
LBegin = Begin;
LEnd = SplitPt - 1;
RBegin = SplitPt;
REnd = End;
// Remap this atom to become the lower of the two new ones.
remap(LBegin, LEnd);
}
// MCDataAtom
void MCDataAtom::addData(const MCData &D) {
Data.push_back(D);
if (Data.size() > End + 1 - Begin)
remap(Begin, End + 1);
}
void MCDataAtom::truncate(uint64_t TruncPt) {
remapForTruncate(TruncPt);
Data.resize(TruncPt - Begin + 1);
}
MCDataAtom *MCDataAtom::split(uint64_t SplitPt) {
uint64_t LBegin, LEnd, RBegin, REnd;
remapForSplit(SplitPt, LBegin, LEnd, RBegin, REnd);
MCDataAtom *RightAtom = Parent->createDataAtom(RBegin, REnd);
RightAtom->setName(getName());
std::vector<MCData>::iterator I = Data.begin() + (RBegin - LBegin);
assert(I != Data.end() && "Split point not found in range!");
std::copy(I, Data.end(), std::back_inserter(RightAtom->Data));
Data.erase(I, Data.end());
return RightAtom;
}
// MCTextAtom
void MCTextAtom::addInst(const MCInst &I, uint64_t Size) {
if (NextInstAddress + Size - 1 > End)
remap(Begin, NextInstAddress + Size - 1);
Insts.push_back(MCDecodedInst(I, NextInstAddress, Size));
NextInstAddress += Size;
}
void MCTextAtom::truncate(uint64_t TruncPt) {
remapForTruncate(TruncPt);
InstListTy::iterator I = Insts.begin();
while (I != Insts.end() && I->Address <= TruncPt) ++I;
assert(I != Insts.end() && "Truncation point not found in disassembly!");
assert(I->Address == TruncPt + 1 &&
"Truncation point does not fall on instruction boundary");
Insts.erase(I, Insts.end());
}
MCTextAtom *MCTextAtom::split(uint64_t SplitPt) {
uint64_t LBegin, LEnd, RBegin, REnd;
remapForSplit(SplitPt, LBegin, LEnd, RBegin, REnd);
MCTextAtom *RightAtom = Parent->createTextAtom(RBegin, REnd);
RightAtom->setName(getName());
InstListTy::iterator I = Insts.begin();
while (I != Insts.end() && I->Address < SplitPt) ++I;
assert(I != Insts.end() && "Split point not found in disassembly!");
assert(I->Address == SplitPt &&
"Split point does not fall on instruction boundary!");
std::copy(I, Insts.end(), std::back_inserter(RightAtom->Insts));
Insts.erase(I, Insts.end());
Parent->splitBasicBlocksForAtom(this, RightAtom);
return RightAtom;
}