Vous avez reçu un message "Your GitLab account has been locked ..." ? Pas d'inquiétude : lisez cet article https://docs.gricad-pages.univ-grenoble-alpes.fr/help/unlock/

lrusecurity_Displayer.cpp 4.59 KB
Newer Older
1
#include <lrupreanalysis/features.h>
2
#include <lrusecurity/features.h>
3
4
5
6
7
#include <elm/sys/Path.h>
#include <elm/sys/System.h>

#include <otawa/proc/BBProcessor.h>
#include <otawa/prog/Process.h>
Valentin Touzeau's avatar
Valentin Touzeau committed
8
#include <lruexact/features.h>
9
#include <set>
Mishigan's avatar
c debug  
Mishigan committed
10
#include<iterator>
Valentin Touzeau's avatar
Valentin Touzeau committed
11
//#include "SecCFGOutput.h"
12
using namespace otawa;
13

14
namespace lrusecurity
15
16
{

17
class SecurityDisplayer : public BBProcessor
18
19
20
21
{
public:
	static otawa::p::declare reg;

22
	SecurityDisplayer() :
23
24
25
26
27
28
29
30
31
32
33
		otawa::BBProcessor(reg),
		_path(""),
		_toFile(false),
		_stream(nullptr),
		_line(false)
	{
	}

	virtual void configure(const PropList& props) override
	{
		otawa::BBProcessor::configure(props);
Valentin Touzeau's avatar
Valentin Touzeau committed
34
35
36
37
		if(props.hasProp(lruexact::CLASSIFICATION_PATH))
		  _path = lruexact::CLASSIFICATION_PATH(props);
		if(props.hasProp(lruexact::CLASSIFICATION_TO_FILE))
		  _toFile = lruexact::CLASSIFICATION_TO_FILE(props);
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
	}
protected:

	virtual void setup(WorkSpace *ws) override
	{
		// Check if source is available
		if(ws->isProvided(SOURCE_LINE_FEATURE))
			_line = true;
		if(logFor(LOG_PROC))
			log << "\tsource/line information " << (_line ? "" : "not ") << "available\n";

		if(!_path && _toFile)
			_path = _ << "access_classification.txt";

		if(_path) {
			try {
				_stream = elm::sys::System::createFile(_path);
			}
			catch(elm::sys::SystemException& e) {
				throw ProcessorException(*this, _ << "cannot open \"" << _path << "\"");
			}

			_out.setStream(*_stream);
		}
62
		_out << "ACCESS\t\tKIND\tCATEGORY\t\tBB\t";
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
		if(_line)
			_out << "\tLINE";

		_out << io::endl;
	}

	virtual void processCFG(WorkSpace* ws, CFG* cfg) override
	{
		_out << "FUNCTION " << cfg->label() << io::endl;
		BBProcessor::processCFG(ws, cfg);
	}

	virtual void processBB(WorkSpace* ws, CFG* cfg, Block* b) override
	{
		if(!b->isBasic())
			return;

		BasicBlock* bb = b->toBasic();

		for(Block::EdgeIter edgeIter(bb->ins()); edgeIter; ++edgeIter) {
			const Edge* e = *edgeIter;
84
			const Bag<icache::Access>& bag = otawa::icache::ACCESSES(e);
85
86
87
			processBag(ws, cfg, bag, bb);
		}

88
		const Bag<icache::Access>& bag = otawa::icache::ACCESSES(bb);
89
90
91
92
93
94
95
96
97
		processBag(ws, cfg, bag, bb);
	}

	void processBag(WorkSpace* ws, CFG* cfg, const Bag<icache::Access>& bag, BasicBlock* bb)
	{
		for(int i = 0; i < bag.size(); ++i)
			processAccess(ws, cfg, &bag[i], bb);
	}

98
  void processAccess(WorkSpace* ws, CFG*, const otawa::icache::Access* access, BasicBlock* bb)
99
	{
100
101
	       SecurityCategory cat = SECURITY_CATEGORY(access);
	       if(cat == SecurityCategory::UNSAFE){
102
103
		_out << access->address() << "\t";
		switch(access->kind()){
104
105
106
			case otawa::icache::NONE: _out << "NONE\t"; break;
			case otawa::icache::FETCH: _out << "FETCH\t"; break;
			case otawa::icache::PREFETCH: _out << "PREFETCH\t"; break;
107
		}
108
			_out << "UNSAFE ";
109
			int set = otawa::icat3::LBLOCK(access)->set();
110
111

            int number = 0;
112
			if (bb->hasProp(EXIST_HIT_PREV_IN)) {
113
			  ACSSecurity prev = (*EXIST_HIT_PREV_IN(bb))[set];
114
			  int index = otawa::icat3::LBLOCK(access)->index();
115
              number = prev[index].size();
Julien Balette-Pape's avatar
Julien Balette-Pape committed
116
              std::set<const otawa::icache::Access *>::iterator iter;
117

Julien Balette-Pape's avatar
Julien Balette-Pape committed
118
			  for (iter = prev[index].begin(); iter != prev[index].end(); iter++){
Julien Balette-Pape's avatar
Julien Balette-Pape committed
119
120
121
122
123
                  if (*iter){
			        _out << (**iter).address() << "\n\t\t\t\t\b";
                  } else {
			        _out << "00000000" << "\n\t\t\t\t\b";
                  }
Mishigan's avatar
c debug  
Mishigan committed
124
              }
125
126

              // REMONTEE
Mishigan's avatar
Mishigan committed
127
              _out << "\033[" << number << "A";
128

129
			}
130
131

		_out << "\t\t\tBB " << bb->index() << "\t\t";
132
		printLine(ws, bb->address(), bb->topAddress().offset());
133
134
135
136
137
138

      // DESCENTE
      for (int i = 0; i < number-1; i++)
        _out << "\n//";
      _out << io::endl;
    }
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
	}

	void printLine(WorkSpace* ws, Address begin, Address::offset_t offset)
	{

		// Display line
		if(_line) {
			bool one = false;
			Pair<cstring, int> old = pair(cstring(""), 0);
			for(Address addr = begin; addr.offset() < offset; addr = addr + 1) {
				Option<Pair<cstring, int> > res = ws->process()->getSourceLine(addr);
				if(res) {
					if((*res).fst != old.fst) {
						old = *res;
			 			if(one)
			 				_out << ", ";
			 			else
			 				one = true;
			 			_out << old.fst << ':' << old.snd;
					}
					else if((*res).snd != old.snd) {
						old = *res;
						_out << ',' << old.snd;
					}
				}
			}
		}
	}

	virtual void cleanup(WorkSpace*) override
	{
		if(_stream)
			delete _stream;
	}

	elm::io::Output _out;
	elm::sys::Path _path;
	bool _toFile;
	elm::io::OutStream* _stream;
	bool _line;
	bool _mcAnalysis;
};

182
183
184
p::declare SecurityDisplayer::reg = p::init("lrusecurity::SecurityDisplayer", Version(1, 0, 0))
	.require(SECURITY_CATEGORY_FEATURE)
	.make<SecurityDisplayer>();
185

186
} // namespace lrusecurity
187