← Back to branch summary

~xnox/ubuntu/trusty/gcc-arm-linux-androideabi/dima

« back to all changes in this revision

Viewing changes to android/frameworks/native/libs/utils/CallStack.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs
  • Date: 2013-07-05 10:12:24 UTC
  • Revision ID: package-import@ubuntu.com-20130705101224-6qo3e8jbz8p31aa1
Tags: upstream-0.20130705.1
Import upstream version 0.20130705.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
android/frameworks/native/libs/utils/CallStack.cpp
 
1
/*
 
2
 * Copyright (C) 2007 The Android Open Source Project
 
3
 *
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 *
 
8
 *      http://www.apache.org/licenses/LICENSE-2.0
 
9
 *
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
 
 
17
#define LOG_TAG "CallStack"
 
18
 
 
19
#include <string.h>
 
20
 
 
21
#include <utils/Log.h>
 
22
#include <utils/Errors.h>
 
23
#include <utils/CallStack.h>
 
24
#include <corkscrew/backtrace.h>
 
25
 
 
26
/*****************************************************************************/
 
27
namespace android {
 
28
 
 
29
CallStack::CallStack() :
 
30
        mCount(0) {
 
31
}
 
32
 
 
33
CallStack::CallStack(const CallStack& rhs) :
 
34
        mCount(rhs.mCount) {
 
35
    if (mCount) {
 
36
        memcpy(mStack, rhs.mStack, mCount * sizeof(backtrace_frame_t));
 
37
    }
 
38
}
 
39
 
 
40
CallStack::~CallStack() {
 
41
}
 
42
 
 
43
CallStack& CallStack::operator = (const CallStack& rhs) {
 
44
    mCount = rhs.mCount;
 
45
    if (mCount) {
 
46
        memcpy(mStack, rhs.mStack, mCount * sizeof(backtrace_frame_t));
 
47
    }
 
48
    return *this;
 
49
}
 
50
 
 
51
bool CallStack::operator == (const CallStack& rhs) const {
 
52
    if (mCount != rhs.mCount)
 
53
        return false;
 
54
    return !mCount || memcmp(mStack, rhs.mStack, mCount * sizeof(backtrace_frame_t)) == 0;
 
55
}
 
56
 
 
57
bool CallStack::operator != (const CallStack& rhs) const {
 
58
    return !operator == (rhs);
 
59
}
 
60
 
 
61
bool CallStack::operator < (const CallStack& rhs) const {
 
62
    if (mCount != rhs.mCount)
 
63
        return mCount < rhs.mCount;
 
64
    return memcmp(mStack, rhs.mStack, mCount * sizeof(backtrace_frame_t)) < 0;
 
65
}
 
66
 
 
67
bool CallStack::operator >= (const CallStack& rhs) const {
 
68
    return !operator < (rhs);
 
69
}
 
70
 
 
71
bool CallStack::operator > (const CallStack& rhs) const {
 
72
    if (mCount != rhs.mCount)
 
73
        return mCount > rhs.mCount;
 
74
    return memcmp(mStack, rhs.mStack, mCount * sizeof(backtrace_frame_t)) > 0;
 
75
}
 
76
 
 
77
bool CallStack::operator <= (const CallStack& rhs) const {
 
78
    return !operator > (rhs);
 
79
}
 
80
 
 
81
const void* CallStack::operator [] (int index) const {
 
82
    if (index >= int(mCount))
 
83
        return 0;
 
84
    return reinterpret_cast<const void*>(mStack[index].absolute_pc);
 
85
}
 
86
 
 
87
void CallStack::clear() {
 
88
    mCount = 0;
 
89
}
 
90
 
 
91
void CallStack::update(int32_t ignoreDepth, int32_t maxDepth) {
 
92
    if (maxDepth > MAX_DEPTH) {
 
93
        maxDepth = MAX_DEPTH;
 
94
    }
 
95
    ssize_t count = unwind_backtrace(mStack, ignoreDepth + 1, maxDepth);
 
96
    mCount = count > 0 ? count : 0;
 
97
}
 
98
 
 
99
void CallStack::dump(const char* prefix) const {
 
100
    backtrace_symbol_t symbols[mCount];
 
101
 
 
102
    get_backtrace_symbols(mStack, mCount, symbols);
 
103
    for (size_t i = 0; i < mCount; i++) {
 
104
        char line[MAX_BACKTRACE_LINE_LENGTH];
 
105
        format_backtrace_line(i, &mStack[i], &symbols[i],
 
106
                line, MAX_BACKTRACE_LINE_LENGTH);
 
107
        ALOGD("%s%s", prefix, line);
 
108
    }
 
109
    free_backtrace_symbols(symbols, mCount);
 
110
}
 
111
 
 
112
String8 CallStack::toString(const char* prefix) const {
 
113
    String8 str;
 
114
    backtrace_symbol_t symbols[mCount];
 
115
 
 
116
    get_backtrace_symbols(mStack, mCount, symbols);
 
117
    for (size_t i = 0; i < mCount; i++) {
 
118
        char line[MAX_BACKTRACE_LINE_LENGTH];
 
119
        format_backtrace_line(i, &mStack[i], &symbols[i],
 
120
                line, MAX_BACKTRACE_LINE_LENGTH);
 
121
        str.append(prefix);
 
122
        str.append(line);
 
123
        str.append("\n");
 
124
    }
 
125
    free_backtrace_symbols(symbols, mCount);
 
126
    return str;
 
127
}
 
128
 
 
129
}; // namespace android