src/sim/process.cc

   1 /*
   2  * Copyright (c) 2014 Advanced Micro Devices, Inc.
   3  * Copyright (c) 2012 ARM Limited
   4  * All rights reserved
   5  *
   6  * The license below extends only to copyright in the software and shall
   7  * not be construed as granting a license to any other intellectual
   8  * property including but not limited to intellectual property relating
   9  * to a hardware implementation of the functionality of the software
  10  * licensed hereunder.  You may use the software subject to the license
  11  * terms below provided that you ensure that this notice is replicated
  12  * unmodified and in its entirety in all distributions of the software,
  13  * modified or unmodified, in source code or in binary form.
  14  *
  15  * Copyright (c) 2001-2005 The Regents of The University of Michigan
  16  * All rights reserved.
  17  *
  18  * Redistribution and use in source and binary forms, with or without
  19  * modification, are permitted provided that the following conditions are
  20  * met: redistributions of source code must retain the above copyright
  21  * notice, this list of conditions and the following disclaimer;
  22  * redistributions in binary form must reproduce the above copyright
  23  * notice, this list of conditions and the following disclaimer in the
  24  * documentation and/or other materials provided with the distribution;
  25  * neither the name of the copyright holders nor the names of its
  26  * contributors may be used to endorse or promote products derived from
  27  * this software without specific prior written permission.
  28  *
  29  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  30  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  31  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  32  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  33  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  34  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  36  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  37  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  38  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  39  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  * Authors: Nathan Binkert
  42  *          Steve Reinhardt
  43  *          Ali Saidi
  44  */
  45
  46 #include <fcntl.h>
  47 #include <unistd.h>
  48
  49 #include <cstdio>
  50 #include <map>
  51 #include <string>
  52
  53 #include "base/loader/object_file.hh"
  54 #include "base/loader/symtab.hh"
  55 #include "base/intmath.hh"
  56 #include "base/statistics.hh"
  57 #include "config/the_isa.hh"
  58 #include "cpu/thread_context.hh"
  59 #include "mem/page_table.hh"
  60 #include "mem/multi_level_page_table.hh"
  61 #include "mem/se_translating_port_proxy.hh"
  62 #include "params/LiveProcess.hh"
  63 #include "params/Process.hh"
  64 #include "sim/debug.hh"
  65 #include "sim/process.hh"
  66 #include "sim/process_impl.hh"
  67 #include "sim/stats.hh"
  68 #include "sim/syscall_emul.hh"
  69 #include "sim/system.hh"
  70
  71 #if THE_ISA == ALPHA_ISA
  72 #include "arch/alpha/linux/process.hh"
  73 #include "arch/alpha/tru64/process.hh"
  74 #elif THE_ISA == SPARC_ISA
  75 #include "arch/sparc/linux/process.hh"
  76 #include "arch/sparc/solaris/process.hh"
  77 #elif THE_ISA == MIPS_ISA
  78 #include "arch/mips/linux/process.hh"
  79 #elif THE_ISA == ARM_ISA
  80 #include "arch/arm/linux/process.hh"
  81 #include "arch/arm/freebsd/process.hh"
  82 #elif THE_ISA == X86_ISA
  83 #include "arch/x86/linux/process.hh"
  84 #elif THE_ISA == POWER_ISA
  85 #include "arch/power/linux/process.hh"
  86 #else
  87 #error "THE_ISA not set"
  88 #endif
  89
  90
  91 using namespace std;
  92 using namespace TheISA;
  93
  94 // current number of allocated processes
  95 int num_processes = 0;
  96
  97 template<class IntType>
  98 AuxVector<IntType>::AuxVector(IntType type, IntType val)
  99 {
 100     a_type = TheISA::htog(type);
 101     a_val = TheISA::htog(val);
 102 }
 103
 104 template struct AuxVector<uint32_t>;
 105 template struct AuxVector<uint64_t>;
 106
 107 static int
 108 openFile(const string& filename, int flags, mode_t mode)
 109 {
 110     int sim_fd = open(filename.c_str(), flags, mode);
 111     if (sim_fd != -1)
 112         return sim_fd;
 113     fatal("Unable to open %s with mode %O", filename, mode);
 114 }
 115
 116 static int
 117 openInputFile(const string &filename)
 118 {
 119     return openFile(filename, O_RDONLY, 0);
 120 }
 121
 122 static int
 123 openOutputFile(const string &filename)
 124 {
 125     return openFile(filename, O_WRONLY | O_CREAT | O_TRUNC, 0664);
 126 }
 127
 128 Process::Process(ProcessParams * params)
 129     : SimObject(params), system(params->system),
 130       brk_point(0), stack_base(0), stack_size(0), stack_min(0),
 131       max_stack_size(params->max_stack_size),
 132       next_thread_stack_base(0),
 133       M5_pid(system->allocatePID()),
 134       useArchPT(params->useArchPT),
 135       kvmInSE(params->kvmInSE),
 136       pTable(useArchPT ?
 137         static_cast<PageTableBase *>(new ArchPageTable(name(), M5_pid, system)) :
 138         static_cast<PageTableBase *>(new FuncPageTable(name(), M5_pid)) ),
 139       initVirtMem(system->getSystemPort(), this,
 140                   SETranslatingPortProxy::Always),
 141       fd_array(make_shared<array<FDEntry, NUM_FDS>>()),
 142       imap {{"",       -1},
 143             {"cin",    STDIN_FILENO},
 144             {"stdin",  STDIN_FILENO}},
 145       oemap{{"",       -1},
 146             {"cout",   STDOUT_FILENO},
 147             {"stdout", STDOUT_FILENO},
 148             {"cerr",   STDERR_FILENO},
 149             {"stderr", STDERR_FILENO}}
 150 {
 151     int sim_fd;
 152     std::map<string,int>::iterator it;
 153
 154     // Search through the input options and set fd if match is found;
 155     // otherwise, open an input file and seek to location.
 156     FDEntry *fde_stdin = get_fd_entry(STDIN_FILENO);
 157     if ((it = imap.find(params->input)) != imap.end())
 158         sim_fd = it->second;
 159     else
 160         sim_fd = openInputFile(params->input);
 161     fde_stdin->set(sim_fd, params->input, O_RDONLY, -1, false);
 162
 163     // Search through the output/error options and set fd if match is found;
 164     // otherwise, open an output file and seek to location.
 165     FDEntry *fde_stdout = get_fd_entry(STDOUT_FILENO);
 166     if ((it = oemap.find(params->output)) != oemap.end())
 167         sim_fd = it->second;
 168     else
 169         sim_fd = openOutputFile(params->output);
 170     fde_stdout->set(sim_fd, params->output, O_WRONLY | O_CREAT | O_TRUNC,
 171                     0664, false);
 172
 173     FDEntry *fde_stderr = get_fd_entry(STDERR_FILENO);
 174     if (params->output == params->errout)
 175         // Reuse the same file descriptor if these match.
 176         sim_fd = fde_stdout->fd;
 177     else if ((it = oemap.find(params->errout)) != oemap.end())
 178         sim_fd = it->second;
 179     else
 180         sim_fd = openOutputFile(params->errout);
 181     fde_stderr->set(sim_fd, params->errout, O_WRONLY | O_CREAT | O_TRUNC,
 182                     0664, false);
 183
 184     mmap_start = mmap_end = 0;
 185     nxm_start = nxm_end = 0;
 186     // other parameters will be initialized when the program is loaded
 187 }
 188
 189
 190 void
 191 Process::regStats()
 192 {
 193     using namespace Stats;
 194
 195     num_syscalls
 196         .name(name() + ".num_syscalls")
 197         .desc("Number of system calls")
 198         ;
 199 }
 200
 201 void
 202 Process::inheritFdArray(Process *p)
 203 {
 204     fd_array = p->fd_array;
 205 }
 206
 207 ThreadContext *
 208 Process::findFreeContext()
 209 {
 210     for (int id : contextIds) {
 211         ThreadContext *tc = system->getThreadContext(id);
 212         if (tc->status() == ThreadContext::Halted)
 213             return tc;
 214     }
 215     return NULL;
 216 }
 217
 218 void
 219 Process::initState()
 220 {
 221     if (contextIds.empty())
 222         fatal("Process %s is not associated with any HW contexts!\n", name());
 223
 224     // first thread context for this process... initialize & enable
 225     ThreadContext *tc = system->getThreadContext(contextIds[0]);
 226
 227     // mark this context as active so it will start ticking.
 228     tc->activate();
 229
 230     pTable->initState(tc);
 231 }
 232
 233 DrainState
 234 Process::drain()
 235 {
 236     find_file_offsets();
 237     return DrainState::Drained;
 238 }
 239
 240 int
 241 Process::alloc_fd(int sim_fd, const string& filename, int flags, int mode,
 242                   bool pipe)
 243 {
 244     if (sim_fd == -1)
 245         return -1;
 246
 247     for (int free_fd = 0; free_fd < fd_array->size(); free_fd++) {
 248         FDEntry *fde = get_fd_entry(free_fd);
 249         if (fde->isFree()) {
 250             fde->set(sim_fd, filename, flags, mode, pipe);
 251             return free_fd;
 252         }
 253     }
 254
 255     fatal("Out of target file descriptors");
 256 }
 257
 258 void
 259 Process::reset_fd_entry(int tgt_fd)
 260 {
 261     FDEntry *fde = get_fd_entry(tgt_fd);
 262     assert(fde->fd > -1);
 263
 264     fde->reset();
 265 }
 266
 267 int
 268 Process::sim_fd(int tgt_fd)
 269 {
 270     FDEntry *entry = get_fd_entry(tgt_fd);
 271     return entry ? entry->fd : -1;
 272 }
 273
 274 FDEntry *
 275 Process::get_fd_entry(int tgt_fd)
 276 {
 277     assert(0 <= tgt_fd && tgt_fd < fd_array->size());
 278     return &(*fd_array)[tgt_fd];
 279 }
 280
 281 int
 282 Process::tgt_fd(int sim_fd)
 283 {
 284     for (int index = 0; index < fd_array->size(); index++)
 285         if ((*fd_array)[index].fd == sim_fd)
 286             return index;
 287     return -1;
 288 }
 289
 290 void
 291 Process::allocateMem(Addr vaddr, int64_t size, bool clobber)
 292 {
 293     int npages = divCeil(size, (int64_t)PageBytes);
 294     Addr paddr = system->allocPhysPages(npages);
 295     pTable->map(vaddr, paddr, size, clobber ? PageTableBase::Clobber : 0);
 296 }
 297
 298 bool
 299 Process::fixupStackFault(Addr vaddr)
 300 {
 301     // Check if this is already on the stack and there's just no page there
 302     // yet.
 303     if (vaddr >= stack_min && vaddr < stack_base) {
 304         allocateMem(roundDown(vaddr, PageBytes), PageBytes);
 305         return true;
 306     }
 307
 308     // We've accessed the next page of the stack, so extend it to include
 309     // this address.
 310     if (vaddr < stack_min && vaddr >= stack_base - max_stack_size) {
 311         while (vaddr < stack_min) {
 312             stack_min -= TheISA::PageBytes;
 313             if (stack_base - stack_min > max_stack_size)
 314                 fatal("Maximum stack size exceeded\n");
 315             allocateMem(stack_min, TheISA::PageBytes);
 316             inform("Increasing stack size by one page.");
 317         };
 318         return true;
 319     }
 320     return false;
 321 }
 322
 323 void
 324 Process::fix_file_offsets()
 325 {
 326     auto seek = [] (FDEntry *fde)
 327     {
 328         if (lseek(fde->fd, fde->fileOffset, SEEK_SET) < 0)
 329             fatal("Unable to see to location in %s", fde->filename);
 330     };
 331
 332     std::map<string,int>::iterator it;
 333
 334     // Search through the input options and set fd if match is found;
 335     // otherwise, open an input file and seek to location.
 336     FDEntry *fde_stdin = get_fd_entry(STDIN_FILENO);
 337     if ((it = imap.find(fde_stdin->filename)) != imap.end()) {
 338         fde_stdin->fd = it->second;
 339     } else {
 340         fde_stdin->fd = openInputFile(fde_stdin->filename);
 341         seek(fde_stdin);
 342     }
 343
 344     // Search through the output/error options and set fd if match is found;
 345     // otherwise, open an output file and seek to location.
 346     FDEntry *fde_stdout = get_fd_entry(STDOUT_FILENO);
 347     if ((it = oemap.find(fde_stdout->filename)) != oemap.end()) {
 348         fde_stdout->fd = it->second;
 349     } else {
 350         fde_stdout->fd = openOutputFile(fde_stdout->filename);
 351         seek(fde_stdout);
 352     }
 353
 354     FDEntry *fde_stderr = get_fd_entry(STDERR_FILENO);
 355     if (fde_stdout->filename == fde_stderr->filename) {
 356         // Reuse the same file descriptor if these match.
 357         fde_stderr->fd = fde_stdout->fd;
 358     } else if ((it = oemap.find(fde_stderr->filename)) != oemap.end()) {
 359         fde_stderr->fd = it->second;
 360     } else {
 361         fde_stderr->fd = openOutputFile(fde_stderr->filename);
 362         seek(fde_stderr);
 363     }
 364
 365     for (int tgt_fd = 3; tgt_fd < fd_array->size(); tgt_fd++) {
 366         FDEntry *fde = get_fd_entry(tgt_fd);
 367         if (fde->fd == -1)
 368             continue;
 369
 370         if (fde->isPipe) {
 371             if (fde->filename == "PIPE-WRITE")
 372                 continue;
 373             assert(fde->filename == "PIPE-READ");
 374
 375             int fds[2];
 376             if (pipe(fds) < 0)
 377                 fatal("Unable to create new pipe");
 378
 379             fde->fd = fds[0];
 380
 381             FDEntry *fde_write = get_fd_entry(fde->readPipeSource);
 382             assert(fde_write->filename == "PIPE-WRITE");
 383             fde_write->fd = fds[1];
 384         } else {
 385             fde->fd = openFile(fde->filename.c_str(), fde->flags, fde->mode);
 386             seek(fde);
 387         }
 388     }
 389 }
 390
 391 void
 392 Process::find_file_offsets()
 393 {
 394     for (auto& fde : *fd_array) {
 395         if (fde.fd != -1)
 396             fde.fileOffset = lseek(fde.fd, 0, SEEK_CUR);
 397     }
 398 }
 399
 400 void
 401 Process::setReadPipeSource(int read_pipe_fd, int source_fd)
 402 {
 403     FDEntry *fde = get_fd_entry(read_pipe_fd);
 404     assert(source_fd >= -1);
 405     fde->readPipeSource = source_fd;
 406 }
 407
 408 void
 409 Process::serialize(CheckpointOut &cp) const
 410 {
 411     SERIALIZE_SCALAR(brk_point);
 412     SERIALIZE_SCALAR(stack_base);
 413     SERIALIZE_SCALAR(stack_size);
 414     SERIALIZE_SCALAR(stack_min);
 415     SERIALIZE_SCALAR(next_thread_stack_base);
 416     SERIALIZE_SCALAR(mmap_start);
 417     SERIALIZE_SCALAR(mmap_end);
 418     SERIALIZE_SCALAR(nxm_start);
 419     SERIALIZE_SCALAR(nxm_end);
 420     pTable->serialize(cp);
 421     for (int x = 0; x < fd_array->size(); x++) {
 422         (*fd_array)[x].serializeSection(cp, csprintf("FDEntry%d", x));
 423     }
 424     SERIALIZE_SCALAR(M5_pid);
 425
 426 }
 427
 428 void
 429 Process::unserialize(CheckpointIn &cp)
 430 {
 431     UNSERIALIZE_SCALAR(brk_point);
 432     UNSERIALIZE_SCALAR(stack_base);
 433     UNSERIALIZE_SCALAR(stack_size);
 434     UNSERIALIZE_SCALAR(stack_min);
 435     UNSERIALIZE_SCALAR(next_thread_stack_base);
 436     UNSERIALIZE_SCALAR(mmap_start);
 437     UNSERIALIZE_SCALAR(mmap_end);
 438     UNSERIALIZE_SCALAR(nxm_start);
 439     UNSERIALIZE_SCALAR(nxm_end);
 440     pTable->unserialize(cp);
 441     for (int x = 0; x < fd_array->size(); x++) {
 442         FDEntry *fde = get_fd_entry(x);
 443         fde->unserializeSection(cp, csprintf("FDEntry%d", x));
 444     }
 445     fix_file_offsets();
 446     UNSERIALIZE_OPT_SCALAR(M5_pid);
 447     // The above returns a bool so that you could do something if you don't
 448     // find the param in the checkpoint if you wanted to, like set a default
 449     // but in this case we'll just stick with the instantiated value if not
 450     // found.
 451 }
 452
 453
 454 bool
 455 Process::map(Addr vaddr, Addr paddr, int size, bool cacheable)
 456 {
 457     pTable->map(vaddr, paddr, size,
 458                 cacheable ? 0 : PageTableBase::Uncacheable);
 459     return true;
 460 }
 461
 462
 463 ////////////////////////////////////////////////////////////////////////
 464 //
 465 // LiveProcess member definitions
 466 //
 467 ////////////////////////////////////////////////////////////////////////
 468
 469
 470 LiveProcess::LiveProcess(LiveProcessParams *params, ObjectFile *_objFile)
 471     : Process(params), objFile(_objFile),
 472       argv(params->cmd), envp(params->env), cwd(params->cwd),
 473       __uid(params->uid), __euid(params->euid),
 474       __gid(params->gid), __egid(params->egid),
 475       __pid(params->pid), __ppid(params->ppid),
 476       drivers(params->drivers)
 477 {
 478
 479     // load up symbols, if any... these may be used for debugging or
 480     // profiling.
 481     if (!debugSymbolTable) {
 482         debugSymbolTable = new SymbolTable();
 483         if (!objFile->loadGlobalSymbols(debugSymbolTable) ||
 484             !objFile->loadLocalSymbols(debugSymbolTable) ||
 485             !objFile->loadWeakSymbols(debugSymbolTable)) {
 486             // didn't load any symbols
 487             delete debugSymbolTable;
 488             debugSymbolTable = NULL;
 489         }
 490     }
 491 }
 492
 493 void
 494 LiveProcess::syscall(int64_t callnum, ThreadContext *tc)
 495 {
 496     num_syscalls++;
 497
 498     SyscallDesc *desc = getDesc(callnum);
 499     if (desc == NULL)
 500         fatal("Syscall %d out of range", callnum);
 501
 502     desc->doSyscall(callnum, this, tc);
 503 }
 504
 505 IntReg
 506 LiveProcess::getSyscallArg(ThreadContext *tc, int &i, int width)
 507 {
 508     return getSyscallArg(tc, i);
 509 }
 510
 511
 512 EmulatedDriver *
 513 LiveProcess::findDriver(std::string filename)
 514 {
 515     for (EmulatedDriver *d : drivers) {
 516         if (d->match(filename))
 517             return d;
 518     }
 519
 520     return NULL;
 521 }
 522
 523
 524 LiveProcess *
 525 LiveProcess::create(LiveProcessParams * params)
 526 {
 527     LiveProcess *process = NULL;
 528
 529     string executable =
 530         params->executable == "" ? params->cmd[0] : params->executable;
 531     ObjectFile *objFile = createObjectFile(executable);
 532     if (objFile == NULL) {
 533         fatal("Can't load object file %s", executable);
 534     }
 535
 536     if (objFile->isDynamic())
 537        fatal("Object file is a dynamic executable however only static "
 538              "executables are supported!\n       Please recompile your "
 539              "executable as a static binary and try again.\n");
 540
 541 #if THE_ISA == ALPHA_ISA
 542     if (objFile->getArch() != ObjectFile::Alpha)
 543         fatal("Object file architecture does not match compiled ISA (Alpha).");
 544
 545     switch (objFile->getOpSys()) {
 546       case ObjectFile::Tru64:
 547         process = new AlphaTru64Process(params, objFile);
 548         break;
 549
 550       case ObjectFile::UnknownOpSys:
 551         warn("Unknown operating system; assuming Linux.");
 552         // fall through
 553       case ObjectFile::Linux:
 554         process = new AlphaLinuxProcess(params, objFile);
 555         break;
 556
 557       default:
 558         fatal("Unknown/unsupported operating system.");
 559     }
 560 #elif THE_ISA == SPARC_ISA
 561     if (objFile->getArch() != ObjectFile::SPARC64 &&
 562         objFile->getArch() != ObjectFile::SPARC32)
 563         fatal("Object file architecture does not match compiled ISA (SPARC).");
 564     switch (objFile->getOpSys()) {
 565       case ObjectFile::UnknownOpSys:
 566         warn("Unknown operating system; assuming Linux.");
 567         // fall through
 568       case ObjectFile::Linux:
 569         if (objFile->getArch() == ObjectFile::SPARC64) {
 570             process = new Sparc64LinuxProcess(params, objFile);
 571         } else {
 572             process = new Sparc32LinuxProcess(params, objFile);
 573         }
 574         break;
 575
 576
 577       case ObjectFile::Solaris:
 578         process = new SparcSolarisProcess(params, objFile);
 579         break;
 580
 581       default:
 582         fatal("Unknown/unsupported operating system.");
 583     }
 584 #elif THE_ISA == X86_ISA
 585     if (objFile->getArch() != ObjectFile::X86_64 &&
 586         objFile->getArch() != ObjectFile::I386)
 587         fatal("Object file architecture does not match compiled ISA (x86).");
 588     switch (objFile->getOpSys()) {
 589       case ObjectFile::UnknownOpSys:
 590         warn("Unknown operating system; assuming Linux.");
 591         // fall through
 592       case ObjectFile::Linux:
 593         if (objFile->getArch() == ObjectFile::X86_64) {
 594             process = new X86_64LinuxProcess(params, objFile);
 595         } else {
 596             process = new I386LinuxProcess(params, objFile);
 597         }
 598         break;
 599
 600       default:
 601         fatal("Unknown/unsupported operating system.");
 602     }
 603 #elif THE_ISA == MIPS_ISA
 604     if (objFile->getArch() != ObjectFile::Mips)
 605         fatal("Object file architecture does not match compiled ISA (MIPS).");
 606     switch (objFile->getOpSys()) {
 607       case ObjectFile::UnknownOpSys:
 608         warn("Unknown operating system; assuming Linux.");
 609         // fall through
 610       case ObjectFile::Linux:
 611         process = new MipsLinuxProcess(params, objFile);
 612         break;
 613
 614       default:
 615         fatal("Unknown/unsupported operating system.");
 616     }
 617 #elif THE_ISA == ARM_ISA
 618     ObjectFile::Arch arch = objFile->getArch();
 619     if (arch != ObjectFile::Arm && arch != ObjectFile::Thumb &&
 620         arch != ObjectFile::Arm64)
 621         fatal("Object file architecture does not match compiled ISA (ARM).");
 622     switch (objFile->getOpSys()) {
 623       case ObjectFile::UnknownOpSys:
 624         warn("Unknown operating system; assuming Linux.");
 625         // fall through
 626       case ObjectFile::Linux:
 627         if (arch == ObjectFile::Arm64) {
 628             process = new ArmLinuxProcess64(params, objFile,
 629                                             objFile->getArch());
 630         } else {
 631             process = new ArmLinuxProcess32(params, objFile,
 632                                             objFile->getArch());
 633         }
 634         break;
 635       case ObjectFile::FreeBSD:
 636         if (arch == ObjectFile::Arm64) {
 637             process = new ArmFreebsdProcess64(params, objFile,
 638                                               objFile->getArch());
 639         } else {
 640             process = new ArmFreebsdProcess32(params, objFile,
 641                                               objFile->getArch());
 642         }
 643         break;
 644       case ObjectFile::LinuxArmOABI:
 645         fatal("M5 does not support ARM OABI binaries. Please recompile with an"
 646               " EABI compiler.");
 647       default:
 648         fatal("Unknown/unsupported operating system.");
 649     }
 650 #elif THE_ISA == POWER_ISA
 651     if (objFile->getArch() != ObjectFile::Power)
 652         fatal("Object file architecture does not match compiled ISA (Power).");
 653     switch (objFile->getOpSys()) {
 654       case ObjectFile::UnknownOpSys:
 655         warn("Unknown operating system; assuming Linux.");
 656         // fall through
 657       case ObjectFile::Linux:
 658         process = new PowerLinuxProcess(params, objFile);
 659         break;
 660
 661       default:
 662         fatal("Unknown/unsupported operating system.");
 663     }
 664 #else
 665 #error "THE_ISA not set"
 666 #endif
 667
 668     if (process == NULL)
 669         fatal("Unknown error creating process object.");
 670     return process;
 671 }
 672
 673 LiveProcess *
 674 LiveProcessParams::create()
 675 {
 676     return LiveProcess::create(this);
 677 }