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.55 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>
Mishigan's avatar
c debug  
Mishigan committed
9
10
#include <set>
#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();
Mishigan's avatar
c debug  
Mishigan committed
116
117
118
119
120
121
122
123
              std::set<otawa::Address *, Ptr_addr_comparator>::iterator iter = prev[index].begin();
              int debug = 1;
			  while (iter != prev[index].end()){
			    _out << *(*iter) << "\n\t\t\t\t\b";
                iter++;
                _out << debug;
                debug++;
              }
124
125

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

128
			}
129
130

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

      // DESCENTE
      for (int i = 0; i < number-1; i++)
        _out << "\n//";
      _out << io::endl;
    }
138
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
	}

	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;
};

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

185
} // namespace lrusecurity
186