← Back to branch summary

~ubuntu-branches/ubuntu/maverick/clamav/maverick-updates

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/CodeGen/SimpleHazardRecognizer.h

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-12-17 12:30:20 UTC
  • mfrom: (97.1.1 maverick-proposed)
  • Revision ID: james.westby@ubuntu.com-20101217123020-o02fhyzykv5z98ri
Tags: 0.96.5+dfsg-1ubuntu1.10.10.1
https://launchpad.net/bugs/691414
* Microversion update for Maverick (LP: #691414)
  - Improved database login times
  - Expanded use of new bytecode signatures
  - Other bugfixes/improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/CodeGen/SimpleHazardRecognizer.h
1
 
//=- llvm/CodeGen/SimpleHazardRecognizer.h - Scheduling Support -*- C++ -*-=//
2
 
//
3
 
//                     The LLVM Compiler Infrastructure
4
 
//
5
 
// This file is distributed under the University of Illinois Open Source
6
 
// License. See LICENSE.TXT for details.
7
 
//
8
 
//===----------------------------------------------------------------------===//
9
 
//
10
 
// This file implements the SimpleHazardRecognizer class, which
11
 
// implements hazard-avoidance heuristics for scheduling, based on the
12
 
// scheduling itineraries specified for the target.
13
 
//
14
 
//===----------------------------------------------------------------------===//
15
 
 
16
 
#ifndef LLVM_CODEGEN_SIMPLEHAZARDRECOGNIZER_H
17
 
#define LLVM_CODEGEN_SIMPLEHAZARDRECOGNIZER_H
18
 
 
19
 
#include "llvm/CodeGen/ScheduleHazardRecognizer.h"
20
 
#include "llvm/CodeGen/ScheduleDAG.h"
21
 
#include "llvm/Target/TargetMachine.h"
22
 
#include "llvm/Target/TargetInstrInfo.h"
23
 
 
24
 
namespace llvm {
25
 
  /// SimpleHazardRecognizer - A *very* simple hazard recognizer. It uses
26
 
  /// a coarse classification and attempts to avoid that instructions of
27
 
  /// a given class aren't grouped too densely together.
28
 
  class SimpleHazardRecognizer : public ScheduleHazardRecognizer {
29
 
    /// Class - A simple classification for SUnits.
30
 
    enum Class {
31
 
      Other, Load, Store
32
 
    };
33
 
 
34
 
    /// Window - The Class values of the most recently issued
35
 
    /// instructions.
36
 
    Class Window[8];
37
 
 
38
 
    /// getClass - Classify the given SUnit.
39
 
    Class getClass(const SUnit *SU) {
40
 
      const MachineInstr *MI = SU->getInstr();
41
 
      const TargetInstrDesc &TID = MI->getDesc();
42
 
      if (TID.mayLoad())
43
 
        return Load;
44
 
      if (TID.mayStore())
45
 
        return Store;
46
 
      return Other;
47
 
    }
48
 
 
49
 
    /// Step - Rotate the existing entries in Window and insert the
50
 
    /// given class value in position as the most recent.
51
 
    void Step(Class C) {
52
 
      std::copy(Window+1, array_endof(Window), Window);
53
 
      Window[array_lengthof(Window)-1] = C;
54
 
    }
55
 
 
56
 
  public:
57
 
    SimpleHazardRecognizer() : Window() {
58
 
      Reset();
59
 
    }
60
 
 
61
 
    virtual HazardType getHazardType(SUnit *SU) {
62
 
      Class C = getClass(SU);
63
 
      if (C == Other)
64
 
        return NoHazard;
65
 
      unsigned Score = 0;
66
 
      for (unsigned i = 0; i != array_lengthof(Window); ++i)
67
 
        if (Window[i] == C)
68
 
          Score += i + 1;
69
 
      if (Score > array_lengthof(Window) * 2)
70
 
        return Hazard;
71
 
      return NoHazard;
72
 
    }
73
 
 
74
 
    virtual void Reset() {
75
 
      for (unsigned i = 0; i != array_lengthof(Window); ++i)
76
 
        Window[i] = Other;
77
 
    }
78
 
 
79
 
    virtual void EmitInstruction(SUnit *SU) {
80
 
      Step(getClass(SU));
81
 
    }
82
 
 
83
 
    virtual void AdvanceCycle() {
84
 
      Step(Other);
85
 
    }
86
 
  };
87
 
}
88
 
 
89
 
#endif