1/*
2 * Copyright (c) 2010 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software
9 * licensed hereunder. You may use the software subject to the license
10 * terms below provided that you ensure that this notice is replicated
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Copyright (c) 2001-2005 The Regents of The University of Michigan
15 * All rights reserved.
16 *
17 * Redistribution and use in source and binary forms, with or without
18 * modification, are permitted provided that the following conditions are
19 * met: redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer;
21 * redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution;
24 * neither the name of the copyright holders nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
27 *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
39 *
40 * Authors: Ali Saidi
41 * Nathan Binkert
42 * Steve Reinhardt
43 */
44
45#include <string>
46#include <vector>
47
48#include "arch/arm/faults.hh"
49#include "arch/arm/pagetable.hh"
50#include "arch/arm/table_walker.hh"
51#include "arch/arm/tlb.hh"
52#include "arch/arm/utility.hh"
53#include "base/inifile.hh"
54#include "base/str.hh"
55#include "base/trace.hh"
56#include "cpu/thread_context.hh"
57#include "debug/Checkpoint.hh"
58#include "debug/TLB.hh"
59#include "debug/TLBVerbose.hh"
60#include "mem/page_table.hh"
61#include "params/ArmTLB.hh"
62#include "sim/full_system.hh"
63#include "sim/process.hh"
64
65#if FULL_SYSTEM
66#include "arch/arm/system.hh"
65#include "arch/arm/table_walker.hh"
67#endif
68
69using namespace std;
70using namespace ArmISA;
71
72TLB::TLB(const Params *p)
72 : BaseTLB(p), size(p->size)
73#if FULL_SYSTEM
74 , tableWalker(p->walker)
75#endif
76 , rangeMRU(1), bootUncacheability(false), miscRegValid(false)
73 : BaseTLB(p), size(p->size) , tableWalker(p->walker),
74 rangeMRU(1), bootUncacheability(false), miscRegValid(false)
75{
76 table = new TlbEntry[size];
77 memset(table, 0, sizeof(TlbEntry) * size);
78
81#if FULL_SYSTEM
79 tableWalker->setTlb(this);
83#endif
80}
81
82TLB::~TLB()
83{
84 if (table)
85 delete [] table;
86}
87
88bool
89TLB::translateFunctional(ThreadContext *tc, Addr va, Addr &pa)
90{
91 if (!miscRegValid)
92 updateMiscReg(tc);
93 TlbEntry *e = lookup(va, contextId, true);
94 if (!e)
95 return false;
96 pa = e->pAddr(va);
97 return true;
98}
99
100TlbEntry*
101TLB::lookup(Addr va, uint8_t cid, bool functional)
102{
103
104 TlbEntry *retval = NULL;
105
106 // Maitaining LRU array
107
108 int x = 0;
109 while (retval == NULL && x < size) {
110 if (table[x].match(va, cid)) {
111
112 // We only move the hit entry ahead when the position is higher than rangeMRU
113 if (x > rangeMRU) {
114 TlbEntry tmp_entry = table[x];
115 for(int i = x; i > 0; i--)
116 table[i] = table[i-1];
117 table[0] = tmp_entry;
118 retval = &table[0];
119 } else {
120 retval = &table[x];
121 }
122 break;
123 }
124 x++;
125 }
126
127 DPRINTF(TLBVerbose, "Lookup %#x, cid %#x -> %s ppn %#x size: %#x pa: %#x ap:%d\n",
128 va, cid, retval ? "hit" : "miss", retval ? retval->pfn : 0,
129 retval ? retval->size : 0, retval ? retval->pAddr(va) : 0,
130 retval ? retval->ap : 0);
131 ;
132 return retval;
133}
134
135// insert a new TLB entry
136void
137TLB::insert(Addr addr, TlbEntry &entry)
138{
139 DPRINTF(TLB, "Inserting entry into TLB with pfn:%#x size:%#x vpn: %#x"
140 " asid:%d N:%d global:%d valid:%d nc:%d sNp:%d xn:%d ap:%#x"
141 " domain:%#x\n", entry.pfn, entry.size, entry.vpn, entry.asid,
142 entry.N, entry.global, entry.valid, entry.nonCacheable, entry.sNp,
143 entry.xn, entry.ap, entry.domain);
144
145 if (table[size-1].valid)
146 DPRINTF(TLB, " - Replacing Valid entry %#x, asn %d ppn %#x size: %#x ap:%d\n",
147 table[size-1].vpn << table[size-1].N, table[size-1].asid,
148 table[size-1].pfn << table[size-1].N, table[size-1].size,
149 table[size-1].ap);
150
151 //inserting to MRU position and evicting the LRU one
152
153 for(int i = size-1; i > 0; i--)
154 table[i] = table[i-1];
155 table[0] = entry;
156
157 inserts++;
158}
159
160void
161TLB::printTlb()
162{
163 int x = 0;
164 TlbEntry *te;
165 DPRINTF(TLB, "Current TLB contents:\n");
166 while (x < size) {
167 te = &table[x];
168 if (te->valid)
169 DPRINTF(TLB, " * %#x, asn %d ppn %#x size: %#x ap:%d\n",
170 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap);
171 x++;
172 }
173}
174
175
176void
177TLB::flushAll()
178{
179 DPRINTF(TLB, "Flushing all TLB entries\n");
180 int x = 0;
181 TlbEntry *te;
182 while (x < size) {
183 te = &table[x];
184 if (te->valid) {
185 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n",
186 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap);
187 flushedEntries++;
188 }
189 x++;
190 }
191
192 memset(table, 0, sizeof(TlbEntry) * size);
193
194 flushTlb++;
195}
196
197
198void
199TLB::flushMvaAsid(Addr mva, uint64_t asn)
200{
201 DPRINTF(TLB, "Flushing mva %#x asid: %#x\n", mva, asn);
202 TlbEntry *te;
203
204 te = lookup(mva, asn);
205 while (te != NULL) {
206 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n",
207 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap);
208 te->valid = false;
209 flushedEntries++;
210 te = lookup(mva,asn);
211 }
212 flushTlbMvaAsid++;
213}
214
215void
216TLB::flushAsid(uint64_t asn)
217{
218 DPRINTF(TLB, "Flushing all entries with asid: %#x\n", asn);
219
220 int x = 0;
221 TlbEntry *te;
222
223 while (x < size) {
224 te = &table[x];
225 if (te->asid == asn) {
226 te->valid = false;
227 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n",
228 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap);
229 flushedEntries++;
230 }
231 x++;
232 }
233 flushTlbAsid++;
234}
235
236void
237TLB::flushMva(Addr mva)
238{
239 DPRINTF(TLB, "Flushing all entries with mva: %#x\n", mva);
240
241 int x = 0;
242 TlbEntry *te;
243
244 while (x < size) {
245 te = &table[x];
246 Addr v = te->vpn << te->N;
247 if (mva >= v && mva < v + te->size) {
248 te->valid = false;
249 DPRINTF(TLB, " - %#x, asn %d ppn %#x size: %#x ap:%d\n",
250 te->vpn << te->N, te->asid, te->pfn << te->N, te->size, te->ap);
251 flushedEntries++;
252 }
253 x++;
254 }
255 flushTlbMva++;
256}
257
258void
259TLB::serialize(ostream &os)
260{
261 DPRINTF(Checkpoint, "Serializing Arm TLB\n");
262
263 SERIALIZE_SCALAR(_attr);
264
265 int num_entries = size;
266 SERIALIZE_SCALAR(num_entries);
267 for(int i = 0; i < size; i++){
268 nameOut(os, csprintf("%s.TlbEntry%d", name(), i));
269 table[i].serialize(os);
270 }
271}
272
273void
274TLB::unserialize(Checkpoint *cp, const string &section)
275{
276 DPRINTF(Checkpoint, "Unserializing Arm TLB\n");
277
278 UNSERIALIZE_SCALAR(_attr);
279 int num_entries;
280 UNSERIALIZE_SCALAR(num_entries);
281 for(int i = 0; i < min(size, num_entries); i++){
282 table[i].unserialize(cp, csprintf("%s.TlbEntry%d", section, i));
283 }
284 miscRegValid = false;
285}
286
287void
288TLB::regStats()
289{
290 instHits
291 .name(name() + ".inst_hits")
292 .desc("ITB inst hits")
293 ;
294
295 instMisses
296 .name(name() + ".inst_misses")
297 .desc("ITB inst misses")
298 ;
299
300 instAccesses
301 .name(name() + ".inst_accesses")
302 .desc("ITB inst accesses")
303 ;
304
305 readHits
306 .name(name() + ".read_hits")
307 .desc("DTB read hits")
308 ;
309
310 readMisses
311 .name(name() + ".read_misses")
312 .desc("DTB read misses")
313 ;
314
315 readAccesses
316 .name(name() + ".read_accesses")
317 .desc("DTB read accesses")
318 ;
319
320 writeHits
321 .name(name() + ".write_hits")
322 .desc("DTB write hits")
323 ;
324
325 writeMisses
326 .name(name() + ".write_misses")
327 .desc("DTB write misses")
328 ;
329
330 writeAccesses
331 .name(name() + ".write_accesses")
332 .desc("DTB write accesses")
333 ;
334
335 hits
336 .name(name() + ".hits")
337 .desc("DTB hits")
338 ;
339
340 misses
341 .name(name() + ".misses")
342 .desc("DTB misses")
343 ;
344
345 accesses
346 .name(name() + ".accesses")
347 .desc("DTB accesses")
348 ;
349
350 flushTlb
351 .name(name() + ".flush_tlb")
352 .desc("Number of times complete TLB was flushed")
353 ;
354
355 flushTlbMva
356 .name(name() + ".flush_tlb_mva")
357 .desc("Number of times TLB was flushed by MVA")
358 ;
359
360 flushTlbMvaAsid
361 .name(name() + ".flush_tlb_mva_asid")
362 .desc("Number of times TLB was flushed by MVA & ASID")
363 ;
364
365 flushTlbAsid
366 .name(name() + ".flush_tlb_asid")
367 .desc("Number of times TLB was flushed by ASID")
368 ;
369
370 flushedEntries
371 .name(name() + ".flush_entries")
372 .desc("Number of entries that have been flushed from TLB")
373 ;
374
375 alignFaults
376 .name(name() + ".align_faults")
377 .desc("Number of TLB faults due to alignment restrictions")
378 ;
379
380 prefetchFaults
381 .name(name() + ".prefetch_faults")
382 .desc("Number of TLB faults due to prefetch")
383 ;
384
385 domainFaults
386 .name(name() + ".domain_faults")
387 .desc("Number of TLB faults due to domain restrictions")
388 ;
389
390 permsFaults
391 .name(name() + ".perms_faults")
392 .desc("Number of TLB faults due to permissions restrictions")
393 ;
394
395 instAccesses = instHits + instMisses;
396 readAccesses = readHits + readMisses;
397 writeAccesses = writeHits + writeMisses;
398 hits = readHits + writeHits + instHits;
399 misses = readMisses + writeMisses + instMisses;
400 accesses = readAccesses + writeAccesses + instAccesses;
401}
402
407#if !FULL_SYSTEM
403Fault
404TLB::translateSe(RequestPtr req, ThreadContext *tc, Mode mode,
405 Translation *translation, bool &delay, bool timing)
406{
407 if (!miscRegValid)
408 updateMiscReg(tc);
409 Addr vaddr = req->getVaddr();
410 uint32_t flags = req->getFlags();
411
412 bool is_fetch = (mode == Execute);
413 bool is_write = (mode == Write);
414
415 if (!is_fetch) {
416 assert(flags & MustBeOne);
417 if (sctlr.a || !(flags & AllowUnaligned)) {
418 if (vaddr & flags & AlignmentMask) {
419 return new DataAbort(vaddr, 0, is_write, ArmFault::AlignmentFault);
420 }
421 }
422 }
423
424#if !FULL_SYSTEM
425 Addr paddr;
426 Process *p = tc->getProcessPtr();
427
428 if (!p->pTable->translate(vaddr, paddr))
429 return Fault(new GenericPageTableFault(vaddr));
430 req->setPaddr(paddr);
431#endif
432
433 return NoFault;
434}
435
439#else // FULL_SYSTEM
440
436Fault
437TLB::trickBoxCheck(RequestPtr req, Mode mode, uint8_t domain, bool sNp)
438{
439 return NoFault;
440}
441
442Fault
443TLB::walkTrickBoxCheck(Addr pa, Addr va, Addr sz, bool is_exec,
444 bool is_write, uint8_t domain, bool sNp)
445{
446 return NoFault;
447}
448
449Fault
450TLB::translateFs(RequestPtr req, ThreadContext *tc, Mode mode,
456 Translation *translation, bool &delay, bool timing, bool functional)
451 Translation *translation, bool &delay, bool timing)
452{
458 // No such thing as a functional timing access
459 assert(!(timing && functional));
460
453 if (!miscRegValid) {
454 updateMiscReg(tc);
455 DPRINTF(TLBVerbose, "TLB variables changed!\n");
456 }
457
458 Addr vaddr = req->getVaddr();
459 uint32_t flags = req->getFlags();
460
461 bool is_fetch = (mode == Execute);
462 bool is_write = (mode == Write);
463 bool is_priv = isPriv && !(flags & UserMode);
464
465 req->setAsid(contextId.asid);
466
467 DPRINTF(TLBVerbose, "CPSR is priv:%d UserMode:%d\n",
468 isPriv, flags & UserMode);
469 // If this is a clrex instruction, provide a PA of 0 with no fault
470 // This will force the monitor to set the tracked address to 0
471 // a bit of a hack but this effectively clrears this processors monitor
472 if (flags & Request::CLEAR_LL){
473 req->setPaddr(0);
474 req->setFlags(Request::UNCACHEABLE);
475 req->setFlags(Request::CLEAR_LL);
476 return NoFault;
477 }
478 if ((req->isInstFetch() && (!sctlr.i)) ||
479 ((!req->isInstFetch()) && (!sctlr.c))){
480 req->setFlags(Request::UNCACHEABLE);
481 }
482 if (!is_fetch) {
483 assert(flags & MustBeOne);
484 if (sctlr.a || !(flags & AllowUnaligned)) {
485 if (vaddr & flags & AlignmentMask) {
486 alignFaults++;
487 return new DataAbort(vaddr, 0, is_write, ArmFault::AlignmentFault);
488 }
489 }
490 }
491
492 Fault fault;
493
494 if (!sctlr.m) {
495 req->setPaddr(vaddr);
496 if (sctlr.tre == 0) {
497 req->setFlags(Request::UNCACHEABLE);
498 } else {
499 if (nmrr.ir0 == 0 || nmrr.or0 == 0 || prrr.tr0 != 0x2)
500 req->setFlags(Request::UNCACHEABLE);
501 }
502
503 // Set memory attributes
504 TlbEntry temp_te;
505 tableWalker->memAttrs(tc, temp_te, sctlr, 0, 1);
506 temp_te.shareable = true;
507 DPRINTF(TLBVerbose, "(No MMU) setting memory attributes: shareable:\
508 %d, innerAttrs: %d, outerAttrs: %d\n", temp_te.shareable,
509 temp_te.innerAttrs, temp_te.outerAttrs);
510 setAttr(temp_te.attributes);
511
512 return trickBoxCheck(req, mode, 0, false);
513 }
514
515 DPRINTF(TLBVerbose, "Translating vaddr=%#x context=%d\n", vaddr, contextId);
516 // Translation enabled
517
518 TlbEntry *te = lookup(vaddr, contextId);
519 if (te == NULL) {
520 if (req->isPrefetch()){
521 //if the request is a prefetch don't attempt to fill the TLB
522 //or go any further with the memory access
523 prefetchFaults++;
524 return new PrefetchAbort(vaddr, ArmFault::PrefetchTLBMiss);
525 }
526
527 if (is_fetch)
528 instMisses++;
529 else if (is_write)
530 writeMisses++;
531 else
532 readMisses++;
533
534 // start translation table walk, pass variables rather than
535 // re-retreaving in table walker for speed
536 DPRINTF(TLB, "TLB Miss: Starting hardware table walker for %#x(%d)\n",
537 vaddr, contextId);
538 fault = tableWalker->walk(req, tc, contextId, mode, translation,
547 timing, functional);
539 timing);
540 if (timing && fault == NoFault) {
541 delay = true;
542 // for timing mode, return and wait for table walk
543 return fault;
544 }
545 if (fault)
546 return fault;
547
548 te = lookup(vaddr, contextId);
549 if (!te)
550 printTlb();
551 assert(te);
552 } else {
553 if (is_fetch)
554 instHits++;
555 else if (is_write)
556 writeHits++;
557 else
558 readHits++;
559 }
560
561 // Set memory attributes
562 DPRINTF(TLBVerbose,
563 "Setting memory attributes: shareable: %d, innerAttrs: %d, \
564 outerAttrs: %d\n",
565 te->shareable, te->innerAttrs, te->outerAttrs);
566 setAttr(te->attributes);
567 if (te->nonCacheable) {
568 req->setFlags(Request::UNCACHEABLE);
569
570 // Prevent prefetching from I/O devices.
571 if (req->isPrefetch()) {
572 return new PrefetchAbort(vaddr, ArmFault::PrefetchUncacheable);
573 }
574 }
575
584
576#if FULL_SYSTEM
577 if (!bootUncacheability &&
578 ((ArmSystem*)tc->getSystemPtr())->adderBootUncacheable(vaddr))
579 req->setFlags(Request::UNCACHEABLE);
580#endif
581
582 switch ( (dacr >> (te->domain * 2)) & 0x3) {
583 case 0:
584 domainFaults++;
585 DPRINTF(TLB, "TLB Fault: Data abort on domain. DACR: %#x domain: %#x"
586 " write:%d sNp:%d\n", dacr, te->domain, is_write, te->sNp);
587 if (is_fetch)
588 return new PrefetchAbort(vaddr,
589 (te->sNp ? ArmFault::Domain0 : ArmFault::Domain1));
590 else
591 return new DataAbort(vaddr, te->domain, is_write,
592 (te->sNp ? ArmFault::Domain0 : ArmFault::Domain1));
593 case 1:
594 // Continue with permissions check
595 break;
596 case 2:
597 panic("UNPRED domain\n");
598 case 3:
599 req->setPaddr(te->pAddr(vaddr));
600 fault = trickBoxCheck(req, mode, te->domain, te->sNp);
601 if (fault)
602 return fault;
603 return NoFault;
604 }
605
606 uint8_t ap = te->ap;
607
608 if (sctlr.afe == 1)
609 ap |= 1;
610
611 bool abt;
612
613 /* if (!sctlr.xp)
614 ap &= 0x3;
615*/
616 switch (ap) {
617 case 0:
618 DPRINTF(TLB, "Access permissions 0, checking rs:%#x\n", (int)sctlr.rs);
619 if (!sctlr.xp) {
620 switch ((int)sctlr.rs) {
621 case 2:
622 abt = is_write;
623 break;
624 case 1:
625 abt = is_write || !is_priv;
626 break;
627 case 0:
628 case 3:
629 default:
630 abt = true;
631 break;
632 }
633 } else {
634 abt = true;
635 }
636 break;
637 case 1:
638 abt = !is_priv;
639 break;
640 case 2:
641 abt = !is_priv && is_write;
642 break;
643 case 3:
644 abt = false;
645 break;
646 case 4:
647 panic("UNPRED premissions\n");
648 case 5:
649 abt = !is_priv || is_write;
650 break;
651 case 6:
652 case 7:
653 abt = is_write;
654 break;
655 default:
656 panic("Unknown permissions\n");
657 }
658 if ((is_fetch) && (abt || te->xn)) {
659 permsFaults++;
660 DPRINTF(TLB, "TLB Fault: Prefetch abort on permission check. AP:%d priv:%d"
661 " write:%d sNp:%d\n", ap, is_priv, is_write, te->sNp);
662 return new PrefetchAbort(vaddr,
663 (te->sNp ? ArmFault::Permission0 :
664 ArmFault::Permission1));
665 } else if (abt) {
666 permsFaults++;
667 DPRINTF(TLB, "TLB Fault: Data abort on permission check. AP:%d priv:%d"
668 " write:%d sNp:%d\n", ap, is_priv, is_write, te->sNp);
669 return new DataAbort(vaddr, te->domain, is_write,
670 (te->sNp ? ArmFault::Permission0 :
671 ArmFault::Permission1));
672 }
673
674 req->setPaddr(te->pAddr(vaddr));
675 // Check for a trickbox generated address fault
676 fault = trickBoxCheck(req, mode, te->domain, te->sNp);
677 if (fault)
678 return fault;
679
680 return NoFault;
681}
682
690#endif
691
683Fault
684TLB::translateAtomic(RequestPtr req, ThreadContext *tc, Mode mode)
685{
686 bool delay = false;
687 Fault fault;
697#if FULL_SYSTEM
698 fault = translateFs(req, tc, mode, NULL, delay, false);
699#else
700 fault = translateSe(req, tc, mode, NULL, delay, false);
701#endif
688 if (FullSystem)
689 fault = translateFs(req, tc, mode, NULL, delay, false);
690 else
691 fault = translateSe(req, tc, mode, NULL, delay, false);
692 assert(!delay);
693 return fault;
694}
695
696Fault
707TLB::translateFunctional(RequestPtr req, ThreadContext *tc, Mode mode)
708{
709 bool delay = false;
710 Fault fault;
711#if FULL_SYSTEM
712 fault = translateFs(req, tc, mode, NULL, delay, false, true);
713#else
714 fault = translateSe(req, tc, mode, NULL, delay, false);
715#endif
716 assert(!delay);
717 return fault;
718}
719
720Fault
697TLB::translateTiming(RequestPtr req, ThreadContext *tc,
698 Translation *translation, Mode mode)
699{
700 assert(translation);
701 bool delay = false;
702 Fault fault;
727#if FULL_SYSTEM
728 fault = translateFs(req, tc, mode, translation, delay, true);
729#else
730 fault = translateSe(req, tc, mode, translation, delay, true);
731#endif
703 if (FullSystem)
704 fault = translateFs(req, tc, mode, translation, delay, true);
705 else
706 fault = translateSe(req, tc, mode, translation, delay, true);
707 DPRINTF(TLBVerbose, "Translation returning delay=%d fault=%d\n", delay, fault !=
708 NoFault);
709 if (!delay)
710 translation->finish(fault, req, tc, mode);
711 else
712 translation->markDelayed();
713 return fault;
714}
715
716Port*
717TLB::getPort()
718{
744#if FULL_SYSTEM
719 return tableWalker->getPort("port");
746#else
747 return NULL;
748#endif
720}
721
722
723
724ArmISA::TLB *
725ArmTLBParams::create()
726{
727 return new ArmISA::TLB(this);
728}